@kubohiroya/turbowarp-asset-cache 0.2.1 → 0.3.0

package/dist/composition.js

@@ -1,3 +1,418 @@
+//#region src/audio-output.ts
+/** Media volume handles attenuation and fades; this shared graph adds amplification. */
+var shared;
+var maximumFloat = 34028234663852886e22;
+function createAudioAmplifier(audio) {
+	if (typeof globalThis.AudioContext !== "function") throw new Error("Audio amplification requires Web Audio support.");
+	if (!shared || shared.context.state === "closed") shared = {
+		context: new AudioContext(),
+		users: 0
+	};
+	const owner = shared;
+	owner.users++;
+	let source;
+	let gain;
+	let released = false;
+	const dispose = () => {
+		if (released) return;
+		released = true;
+		source?.disconnect();
+		gain?.disconnect();
+		owner.users--;
+		if (owner.users === 0) {
+			if (shared === owner) shared = void 0;
+			owner.context.close().catch(() => {});
+		}
+	};
+	try {
+		source = owner.context.createMediaElementSource(audio);
+		gain = owner.context.createGain();
+		source.connect(gain);
+		gain.connect(owner.context.destination);
+	} catch (error) {
+		dispose();
+		throw error;
+	}
+	const node = gain;
+	return {
+		setGain(value) {
+			node.gain.value = Math.min(maximumFloat, Math.max(1, value));
+		},
+		resume() {
+			return owner.context.state === "running" ? Promise.resolve() : owner.context.resume();
+		},
+		dispose
+	};
+}
+//#endregion
+//#region src/audio-playback.ts
+function playbackGain(value) {
+	const gain = value === void 0 ? 1 : value;
+	if (typeof gain !== "number" || !Number.isFinite(gain) || gain < 0) throw new TypeError("Audio gain must be a finite non-negative number.");
+	return gain;
+}
+function rate(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < .25 || value > 4) throw new TypeError("Audio playback rate must be from 0.25 to 4.");
+	return value;
+}
+function validateAudioPlaybackOptions(options) {
+	if (!options || typeof options !== "object" || Array.isArray(options) || Object.keys(options).some((key) => ![
+		"gain",
+		"muted",
+		"playbackRate",
+		"fadeIn",
+		"fadeOut"
+	].includes(key))) throw new TypeError("Invalid audio playback options.");
+	playbackGain(options.gain);
+	if (options.muted !== void 0 && typeof options.muted !== "boolean") throw new TypeError("Audio muted must be a boolean.");
+	rate(options.playbackRate ?? 1);
+	fadeSeconds(options.fadeIn, "fadeIn");
+	fadeSeconds(options.fadeOut, "fadeOut");
+}
+function fadeSeconds(value, label) {
+	const seconds = value === void 0 ? 0 : value;
+	if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds < 0) throw new TypeError(`Audio ${label} must be a finite non-negative number of seconds.`);
+	return seconds;
+}
+function aborted() {
+	const error = /* @__PURE__ */ new Error("Audio playback was cancelled.");
+	error.name = "AbortError";
+	return error;
+}
+/** One reusable native element; the caller owns source resolution and resource release. */
+function createBrowserAudioPlayback(audio, options, release, playbackError) {
+	validateAudioPlaybackOptions(options);
+	let gain = playbackGain(options.gain);
+	audio.volume = Math.min(1, gain);
+	audio.muted = options.muted ?? false;
+	audio.playbackRate = options.playbackRate ?? 1;
+	audio.loop = false;
+	const defaultFadeIn = fadeSeconds(options.fadeIn, "fadeIn");
+	const defaultFadeOut = fadeSeconds(options.fadeOut, "fadeOut");
+	let activeFadeIn = defaultFadeIn;
+	let activeFadeOut = defaultFadeOut;
+	let envelope = 1;
+	let fadeStarted = 0;
+	let playing = false;
+	let fadeTimer;
+	let stopping;
+	let amplifier;
+	const pendingGain = /* @__PURE__ */ new Set();
+	let disposed = false;
+	let generation = 0;
+	let ended = Promise.resolve();
+	let settle;
+	let rejectStart;
+	let detachAbort;
+	const pendingMetadata = /* @__PURE__ */ new Set();
+	const requireActive = () => {
+		if (disposed) throw new Error("Audio playback is disposed.");
+	};
+	const clearFadeTimer = () => {
+		if (fadeTimer !== void 0) clearTimeout(fadeTimer);
+		fadeTimer = void 0;
+	};
+	const finish = (error) => {
+		playing = false;
+		for (const reject of pendingGain) reject(error ?? aborted());
+		pendingGain.clear();
+		clearFadeTimer();
+		const previousStop = stopping;
+		stopping = void 0;
+		previousStop?.detach();
+		previousStop?.reject(error ?? aborted());
+		generation++;
+		rejectStart?.(error ?? aborted());
+		rejectStart = void 0;
+		detachAbort?.();
+		detachAbort = void 0;
+		settle?.(error);
+		settle = void 0;
+	};
+	const writeVolume = () => {
+		audio.volume = Math.min(1, gain) * envelope;
+		amplifier?.setGain(gain);
+	};
+	const prepareAmplifier = () => {
+		if (!amplifier && gain > 1) amplifier = createAudioAmplifier(audio);
+		writeVolume();
+	};
+	const stopNow = () => {
+		const completed = stopping;
+		stopping = void 0;
+		completed?.detach();
+		audio.pause();
+		audio.loop = false;
+		audio.currentTime = 0;
+		finish();
+		envelope = 1;
+		writeVolume();
+		completed?.resolve();
+	};
+	const refreshFade = () => {
+		clearFadeTimer();
+		if (disposed || !playing && !stopping) return;
+		const now = performance.now();
+		let delay = 16;
+		if (stopping) {
+			const progress = Math.min(1, (now - stopping.started) / (stopping.seconds * 1e3));
+			envelope = stopping.from * (1 - progress);
+			writeVolume();
+			if (progress >= 1) {
+				stopNow();
+				return;
+			}
+		} else {
+			const fadeIn = activeFadeIn === 0 ? 1 : Math.min(1, (now - fadeStarted) / (activeFadeIn * 1e3));
+			const remaining = Number.isFinite(audio.duration) ? Math.max(0, audio.duration - audio.currentTime) / audio.playbackRate : Infinity;
+			const fadeOut = !audio.loop && activeFadeOut > 0 ? Math.min(1, remaining / activeFadeOut) : 1;
+			envelope = Math.max(0, Math.min(fadeIn, fadeOut));
+			writeVolume();
+			if (fadeIn >= 1) {
+				if (audio.loop || activeFadeOut === 0) return;
+				if (!Number.isFinite(remaining)) delay = 250;
+				else if (remaining > activeFadeOut) delay = Math.min(250, Math.max(16, (remaining - activeFadeOut) * 1e3));
+			}
+		}
+		fadeTimer = setTimeout(refreshFade, delay);
+	};
+	const onEnded = () => {
+		if (stopping) {
+			stopNow();
+			return;
+		}
+		finish();
+		if (activeFadeOut > 0 && !audio.loop) {
+			envelope = 0;
+			writeVolume();
+		}
+	};
+	const onError = () => {
+		audio.pause();
+		const error = playbackError(audio.error ?? /* @__PURE__ */ new Error("The browser audio element reported a playback error."));
+		finish(error);
+		for (const complete of pendingMetadata) complete(error);
+	};
+	audio.addEventListener("ended", onEnded);
+	audio.addEventListener("error", onError);
+	for (const event of [
+		"durationchange",
+		"ratechange",
+		"seeked"
+	]) audio.addEventListener(event, refreshFade);
+	return Object.freeze({
+		get ended() {
+			return ended;
+		},
+		get currentTime() {
+			return audio.currentTime;
+		},
+		get paused() {
+			return audio.paused;
+		},
+		get loop() {
+			return audio.loop;
+		},
+		get gain() {
+			return gain;
+		},
+		get muted() {
+			return audio.muted;
+		},
+		get playbackRate() {
+			return audio.playbackRate;
+		},
+		async play(playOptions = {}) {
+			requireActive();
+			if (!playOptions || typeof playOptions !== "object" || Array.isArray(playOptions) || Object.keys(playOptions).some((key) => ![
+				"restart",
+				"loop",
+				"signal",
+				"fadeIn",
+				"fadeOut",
+				"gain"
+			].includes(key)) || playOptions.restart !== void 0 && typeof playOptions.restart !== "boolean" || playOptions.loop !== void 0 && typeof playOptions.loop !== "boolean") throw new TypeError("Invalid audio play options.");
+			const fadeIn = fadeSeconds(playOptions.fadeIn === void 0 ? defaultFadeIn : playOptions.fadeIn, "fadeIn");
+			const fadeOut = fadeSeconds(playOptions.fadeOut === void 0 ? defaultFadeOut : playOptions.fadeOut, "fadeOut");
+			const nextGain = playOptions.gain === void 0 ? gain : playbackGain(playOptions.gain);
+			const signal = playOptions.signal;
+			if (signal?.aborted) throw aborted();
+			finish();
+			const run = generation;
+			gain = nextGain;
+			if (playOptions.restart) audio.currentTime = 0;
+			audio.loop = playOptions.loop ?? audio.loop;
+			activeFadeIn = fadeIn;
+			activeFadeOut = fadeOut;
+			envelope = fadeIn > 0 ? 0 : 1;
+			writeVolume();
+			ended = new Promise((resolve, reject) => {
+				settle = (error) => error === void 0 ? resolve() : reject(error);
+			});
+			ended.catch(() => {});
+			const onAbort = () => {
+				audio.pause();
+				finish(aborted());
+			};
+			signal?.addEventListener("abort", onAbort, { once: true });
+			detachAbort = () => signal?.removeEventListener("abort", onAbort);
+			try {
+				prepareAmplifier();
+				const started = audio.play();
+				const ready = amplifier ? Promise.all([started, amplifier.resume()]) : Promise.resolve(started);
+				await Promise.race([ready, new Promise((_resolve, reject) => {
+					rejectStart = reject;
+				})]);
+				if (run !== generation) throw aborted();
+				rejectStart = void 0;
+				playing = true;
+				fadeStarted = performance.now();
+				refreshFade();
+			} catch (cause) {
+				if (run !== generation) throw cause;
+				audio.pause();
+				const error = playbackError(cause);
+				finish(error);
+				throw error;
+			}
+		},
+		pause() {
+			requireActive();
+			audio.pause();
+			finish();
+		},
+		stop(stopOptions = {}) {
+			requireActive();
+			if (!stopOptions || typeof stopOptions !== "object" || Array.isArray(stopOptions) || Object.keys(stopOptions).some((key) => !["fadeOut", "signal"].includes(key))) throw new TypeError("Invalid audio stop options.");
+			const seconds = fadeSeconds(stopOptions.fadeOut === void 0 ? activeFadeOut : stopOptions.fadeOut, "fadeOut");
+			const signal = stopOptions.signal;
+			if (signal?.aborted) throw aborted();
+			if (seconds === 0 || audio.paused || !playing) {
+				stopNow();
+				return;
+			}
+			const previous = stopping;
+			stopping = void 0;
+			previous?.detach();
+			previous?.reject(aborted());
+			return new Promise((resolve, reject) => {
+				const onAbort = () => {
+					const current = stopping;
+					stopping = void 0;
+					current?.detach();
+					stopNow();
+					reject(aborted());
+				};
+				stopping = {
+					started: performance.now(),
+					seconds,
+					from: envelope,
+					resolve,
+					reject,
+					detach: () => signal?.removeEventListener("abort", onAbort)
+				};
+				signal?.addEventListener("abort", onAbort, { once: true });
+				if (signal?.aborted) onAbort();
+				else refreshFade();
+			});
+		},
+		async seek(seconds, signal) {
+			requireActive();
+			if (!Number.isFinite(seconds) || seconds < 0) throw new TypeError("Audio seek time must be non-negative.");
+			if (signal?.aborted) throw aborted();
+			if (audio.readyState < 1) await new Promise((resolve, reject) => {
+				const complete = (error) => {
+					clearTimeout(timer);
+					audio.removeEventListener("loadedmetadata", ready);
+					signal?.removeEventListener("abort", cancel);
+					pendingMetadata.delete(complete);
+					if (error === void 0) resolve();
+					else reject(error);
+				};
+				const ready = () => complete();
+				const cancel = () => complete(aborted());
+				const timer = setTimeout(() => complete(/* @__PURE__ */ new Error("Audio metadata did not become ready.")), 1e4);
+				pendingMetadata.add(complete);
+				audio.addEventListener("loadedmetadata", ready, { once: true });
+				signal?.addEventListener("abort", cancel, { once: true });
+				if (signal?.aborted) cancel();
+				else if (audio.readyState >= 1) ready();
+			});
+			requireActive();
+			if (signal?.aborted) throw aborted();
+			if (Number.isFinite(audio.duration) && seconds > audio.duration) throw new RangeError("Audio seek exceeds its duration.");
+			audio.currentTime = seconds;
+			refreshFade();
+		},
+		setGain(value) {
+			const normalized = playbackGain(value);
+			requireActive();
+			const previous = gain;
+			gain = normalized;
+			try {
+				if (playing) prepareAmplifier();
+				else writeVolume();
+			} catch (error) {
+				gain = previous;
+				writeVolume();
+				throw playbackError(error);
+			}
+			if (playing && amplifier) {
+				const run = generation;
+				let rejectResume;
+				const cancelled = new Promise((_resolve, reject) => {
+					rejectResume = reject;
+				});
+				pendingGain.add(rejectResume);
+				return Promise.race([amplifier.resume(), cancelled]).catch((cause) => {
+					if (run !== generation) throw cause;
+					audio.pause();
+					const error = playbackError(cause);
+					finish(error);
+					throw error;
+				}).finally(() => pendingGain.delete(rejectResume));
+			}
+		},
+		setMuted(value) {
+			if (typeof value !== "boolean") throw new TypeError("Audio muted must be a boolean.");
+			requireActive();
+			audio.muted = value;
+		},
+		setPlaybackRate(value) {
+			const normalized = rate(value);
+			requireActive();
+			audio.playbackRate = normalized;
+			refreshFade();
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			try {
+				audio.pause();
+				audio.currentTime = 0;
+			} catch {}
+			finish();
+			for (const complete of pendingMetadata) complete(aborted());
+			audio.removeEventListener("ended", onEnded);
+			audio.removeEventListener("error", onError);
+			for (const event of [
+				"durationchange",
+				"ratechange",
+				"seeked"
+			]) audio.removeEventListener(event, refreshFade);
+			try {
+				audio.removeAttribute?.("src");
+				audio.load?.();
+			} finally {
+				try {
+					amplifier?.dispose();
+				} finally {
+					release();
+				}
+			}
+		}
+	});
+}
 var block_definitions_default = {
 	extensionName: "Asset Cache",
 	blocks: [
@@ -278,7 +693,404 @@ var block_definitions_default = {
 	]
 };
 //#endregion
-//#region node_modules/.pnpm/@kubohiroya+turbowarp-named-data@0.1.0/node_modules/@kubohiroya/turbowarp-named-data/dist/composition.js
+//#region node_modules/.pnpm/@kubohiroya+turbowarp-extension-data-editor@0.2.1_react@18.3.1/node_modules/@kubohiroya/turbowarp-extension-data-editor/dist/fixed-input-schema.js
+var numberToken = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/u;
+var invalidNumber = Object.freeze({
+	kind: "invalid",
+	code: "fixed-number-input-invalid"
+});
+/**
+* Parse a NEW numeric draft according to NP-finite-new-input-v1.
+* Never apply this to opening/no-op raw values or use it as an owner validator.
+* Keep the validated token so negative zero, precision and exponent spelling survive.
+*/
+function parseFixedNumberInput(input) {
+	if (typeof input === "number") {
+		if (!Number.isFinite(input)) return invalidNumber;
+		return Object.freeze({
+			kind: "valid",
+			token: Object.is(input, -0) ? "-0" : String(input),
+			value: input
+		});
+	}
+	if (typeof input !== "string") return invalidNumber;
+	const token = input.trim();
+	if (!numberToken.test(token)) return invalidNumber;
+	const value = Number(token);
+	return Number.isFinite(value) ? Object.freeze({
+		kind: "valid",
+		token,
+		value
+	}) : invalidNumber;
+}
+var block_editor_fixed_inputs_schema_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://kubohiroya.github.io/turbowarp-asset-cache/schemas/block-editor-fixed-inputs.schema.json",
+	$defs: {
+		"setTextStyle": {
+			"type": "object",
+			"properties": {
+				"PROPERTY": {
+					"type": "string",
+					"enum": [
+						"animation",
+						"font",
+						"color",
+						"width",
+						"align"
+					]
+				},
+				"VALUE": { "type": "string" }
+			},
+			"additionalProperties": false
+		},
+		"animation": {
+			"type": "string",
+			"enum": [
+				"",
+				"none",
+				"type",
+				"rainbow",
+				"zoom",
+				"shake"
+			]
+		},
+		"font": { "type": "string" },
+		"color": {
+			"type": "string",
+			"pattern": "^(?:|#[0-9a-fA-F]{3}|#[0-9a-fA-F]{6})$"
+		},
+		"width": {
+			"type": "string",
+			"$comment": "Empty/trimmed empty resets; otherwise normalizeTextStyleValue requires Number(value) finite and positive. Preserve the existing STRING grammar, including hexadecimal and leading plus."
+		},
+		"align": {
+			"type": "string",
+			"enum": [
+				"",
+				"left",
+				"center",
+				"right"
+			]
+		},
+		"loadingCostumeAt": {
+			"type": "object",
+			"properties": { "INDEX": { "type": "number" } },
+			"additionalProperties": false
+		}
+	}
+};
+//#endregion
+//#region src/fixed-input-schema.ts
+/** Canonical owner schema fragments; no network resources or runtime providers. */
+function fixedInputBundle(fragment, schema) {
+	const source = {
+		repository: "turbowarp-asset-cache",
+		path: "schemas/block-editor-fixed-inputs.schema.json",
+		symbol: {
+			"setTextStyle-PROPERTY": "#/$defs/setTextStyle/properties/PROPERTY",
+			"setTextStyle-VALUE": "#/$defs/setTextStyle/properties/VALUE",
+			"loadingCostumeAt-INDEX": "#/$defs/loadingCostumeAt/properties/INDEX"
+		}[fragment] ?? `#/$defs/${fragment}`
+	};
+	return {
+		identity: {
+			ownerId: "turbowarp-asset-cache",
+			contractId: "fixed-inputs",
+			revision: "1",
+			variantId: fragment
+		},
+		dialect: "2020-12",
+		root: {
+			retrievalUri: block_editor_fixed_inputs_schema_default.$id,
+			document: schema,
+			artifact: {
+				role: "canonical-schema",
+				source
+			}
+		},
+		resources: [],
+		provenance: {
+			canonicalSources: [
+				source,
+				{
+					repository: "turbowarp-asset-cache",
+					path: "src/text-style.ts",
+					symbol: "normalizeTextStyleProperty / normalizeTextStyleValue"
+				},
+				{
+					repository: "turbowarp-asset-cache",
+					path: "src/extension.ts",
+					symbol: "getInfo / loadingCostumeAt"
+				}
+			],
+			generatedFiles: [],
+			referenceSchemas: [],
+			generationSources: []
+		}
+	};
+}
+var fixedSchemas = block_editor_fixed_inputs_schema_default.$defs;
+//#endregion
+//#region src/text-style.ts
+var TEXT_RUNTIME_NAMESPACE = "text";
+var TEXT_STYLE_RUNTIME_NAMESPACE = "textStyle";
+var TEXT_STYLE_PROPERTIES = [
+	"animation",
+	"font",
+	"color",
+	"width",
+	"align"
+];
+var DEFAULT_STAGE_WIDTH = 480;
+var DEFAULT_FONT = "Handwriting";
+var DEFAULT_COLOR = "#ffffff";
+var DEFAULT_ALIGNMENT = "center";
+var DEFAULT_OUTLINE_COLOR = "#000000";
+function textRuntimeVariableName(name) {
+	return `${TEXT_RUNTIME_NAMESPACE}:${name}`;
+}
+function textStyleRuntimeVariableName(name, property) {
+	return `${TEXT_STYLE_RUNTIME_NAMESPACE}:${name}:${property}`;
+}
+function normalizeTextStyleProperty(value) {
+	const property = String(value ?? "").trim().toLowerCase();
+	if (TEXT_STYLE_PROPERTIES.includes(property)) return property;
+	throw new Error(`Unknown text style property: ${property || "(empty)"}`);
+}
+/**
+* Normalize a DSL-facing style value for runtime-variable storage.
+* An empty value intentionally resets the property to its default.
+*/
+function normalizeTextStyleValue(property, value) {
+	const raw = String(value ?? "").trim();
+	if (!raw) return "";
+	switch (property) {
+		case "animation": {
+			const animation = raw.toLowerCase() === "typing" ? "type" : raw.toLowerCase();
+			if (animation === "none" || animation === "type" || animation === "rainbow" || animation === "zoom" || animation === "shake") return animation;
+			throw new Error(`Invalid text animation: ${raw}`);
+		}
+		case "font": return raw;
+		case "color": {
+			if (/^#[0-9a-f]{6}$/i.test(raw)) return raw.toLowerCase();
+			const shortColor = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(raw);
+			if (shortColor) return `#${shortColor[1]}${shortColor[1]}${shortColor[2]}${shortColor[2]}${shortColor[3]}${shortColor[3]}`.toLowerCase();
+			throw new Error(`Invalid text color: ${raw}`);
+		}
+		case "width": {
+			const width = Number(raw);
+			if (!Number.isFinite(width) || width <= 0) throw new Error(`Text width must be a positive number: ${raw}`);
+			return String(width);
+		}
+		case "align": {
+			const align = raw.toLowerCase();
+			if (align === "left" || align === "center" || align === "right") return align;
+			throw new Error(`Invalid text alignment: ${raw}`);
+		}
+	}
+}
+function resolveTextStyle(name, stageWidth, getRuntimeVariable) {
+	const width = Number(stageWidth);
+	const defaults = {
+		animation: "none",
+		font: DEFAULT_FONT,
+		color: DEFAULT_COLOR,
+		width: Number.isFinite(width) && width > 0 ? width : DEFAULT_STAGE_WIDTH,
+		align: DEFAULT_ALIGNMENT
+	};
+	const read = (property) => normalizeTextStyleValue(property, getRuntimeVariable(textStyleRuntimeVariableName(name, property)));
+	const animation = read("animation");
+	const font = read("font");
+	const color = read("color");
+	const configuredWidth = read("width");
+	const align = read("align");
+	return {
+		animation: animation ? animation : defaults.animation,
+		font: font || defaults.font,
+		color: color || defaults.color,
+		width: configuredWidth ? Number(configuredWidth) : defaults.width,
+		align: align ? align : defaults.align
+	};
+}
+//#endregion
+//#region src/fixed-input-editors.ts
+var extensionId = "kubohiroyaassetcache";
+var choices = (values) => values.map((value) => ({ value }));
+var context = () => ({
+	consumerId: "turbowarp-asset-cache",
+	nowMs: 0,
+	settings: null
+});
+var string = (value) => {
+	if (typeof value !== "string") throw new TypeError("Expected a string literal.");
+	return value;
+};
+var issue = () => [{ message: "Invalid asset style value." }];
+/** New edits preserve the candidate token; existing aliases are display projections only. */
+function styleBinding(property) {
+	const values = property === "animation" ? [
+		"",
+		"none",
+		"type",
+		"rainbow",
+		"zoom",
+		"shake"
+	] : property === "align" ? [
+		"",
+		"left",
+		"center",
+		"right"
+	] : void 0;
+	return {
+		argument: "VALUE",
+		schemaBundle: fixedInputBundle(property, fixedSchemas[property]),
+		control: {
+			kind: values ? "enum" : property === "color" ? "color" : property === "width" ? "number" : "text",
+			reset: "",
+			...values ? { choices: choices(values) } : {}
+		},
+		read(value) {
+			return normalizeTextStyleValue(property, string(value));
+		},
+		encode(value) {
+			const raw = string(value);
+			if (property !== "width" || raw === "") return raw;
+			normalizeTextStyleValue(property, raw);
+			return raw;
+		},
+		validateCandidate(value) {
+			try {
+				normalizeTextStyleValue(property, string(value));
+				return [];
+			} catch {
+				return issue();
+			}
+		}
+	};
+}
+var fixedInputEditors = [{
+	apiVersion: 1,
+	extensionId,
+	editorId: "text-style-fixed",
+	opcodes: [`${extensionId}_setTextStyle`],
+	contractId: "CP-asset-cache",
+	contractRevision: "1",
+	validationContext: context,
+	bindings: [{
+		argument: "PROPERTY",
+		schemaBundle: fixedInputBundle("setTextStyle-PROPERTY", fixedSchemas.setTextStyle.properties.PROPERTY),
+		control: {
+			kind: "enum",
+			choices: choices(TEXT_STYLE_PROPERTIES)
+		},
+		read(value) {
+			const raw = string(value);
+			try {
+				return normalizeTextStyleProperty(raw);
+			} catch {
+				return raw;
+			}
+		},
+		encode: (value) => string(value),
+		validateCandidate(value) {
+			try {
+				normalizeTextStyleProperty(value);
+				return [];
+			} catch {
+				return issue();
+			}
+		}
+	}, {
+		argument: "VALUE",
+		schemaBundle: fixedInputBundle("setTextStyle-VALUE", fixedSchemas.setTextStyle.properties.VALUE),
+		read: (value) => string(value),
+		encode: (value) => string(value),
+		validateCandidate: () => []
+	}],
+	dependencies: [{
+		selector: "PROPERTY",
+		dependents: ["VALUE"]
+	}],
+	branchPolicies: [{
+		selector: "PROPERTY",
+		normalize: {
+			trim: true,
+			lowercase: true
+		},
+		cases: TEXT_STYLE_PROPERTIES.map((property) => ({
+			values: [property],
+			activeDependents: ["VALUE"],
+			bindings: [styleBinding(property)]
+		}))
+	}]
+}, {
+	apiVersion: 1,
+	extensionId,
+	editorId: "loading-costume-index-fixed",
+	opcodes: [`${extensionId}_loadingCostumeAt`],
+	contractId: "turbowarp-asset-cache/loadingCostumeAt.INDEX",
+	contractRevision: "1",
+	validationContext: context,
+	bindings: [{
+		argument: "INDEX",
+		schemaBundle: fixedInputBundle("loadingCostumeAt-INDEX", fixedSchemas.loadingCostumeAt.properties.INDEX),
+		control: { kind: "number" },
+		read(value) {
+			if (typeof value !== "number" && typeof value !== "string" || typeof value === "string" && value.trim() === "") throw new TypeError("Non-numeric index.");
+			const number = Number(value);
+			if (!Number.isFinite(number)) throw new TypeError("Nonfinite index.");
+			return number;
+		},
+		encode(value) {
+			const parsed = parseFixedNumberInput(value);
+			if (parsed.kind !== "valid") throw new TypeError("Invalid index.");
+			return parsed.token;
+		},
+		validateCandidate(value) {
+			return Number.isFinite(Number(value)) ? [] : [{ message: "Invalid index." }];
+		}
+	}]
+}];
+/** Per-instance, idempotent registration. Legacy hosts never acquire the fixed capability. */
+function fixedInputRegistration(scratch) {
+	const host = scratch;
+	let active;
+	let removers = [];
+	let disposed = false;
+	const dispose = () => {
+		host.vm?.runtime?.off?.("RUNTIME_DISPOSED", shutdown);
+		for (const remove of removers.splice(0).reverse()) remove();
+		active = void 0;
+	};
+	const shutdown = () => {
+		disposed = true;
+		dispose();
+	};
+	return {
+		ensure(opcodes) {
+			const api = host.gui?.blockEditors;
+			if (disposed || api === active) return;
+			dispose();
+			if (api?.apiVersion !== 1 || typeof api.registerFixedInputEditor !== "function") return;
+			try {
+				for (const definition of fixedInputEditors) if (definition.opcodes.every((opcode) => opcodes.includes(opcode))) {
+					const remove = api.registerFixedInputEditor.call(api, definition);
+					if (typeof remove !== "function") throw new TypeError("Invalid fixed registration cleanup.");
+					removers.push(remove);
+				}
+				active = api;
+				host.vm?.runtime?.on?.("RUNTIME_DISPOSED", shutdown);
+			} catch (error) {
+				dispose();
+				throw error;
+			}
+		},
+		dispose: shutdown
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@kubohiroya+turbowarp-named-data@0.3.1/node_modules/@kubohiroya/turbowarp-named-data/dist/composition.js
 var NAMED_DATA_REGISTRY_SYMBOL_KEY = "@kubohiroya/turbowarp-named-data/registry";
 var NAMED_DATA_REGISTRY_SYMBOL = Symbol.for(NAMED_DATA_REGISTRY_SYMBOL_KEY);
 var NAMED_DATA_NAMESPACE_PATTERN = /^[a-z][a-z0-9.-]{0,63}$/u;
@@ -299,6 +1111,8 @@ var NAMED_DATA_REPRESENTATIONS = [
 	"markdown",
 	"raw"
 ];
+var NAMED_DATA_SCHEMA_ID_PATTERN = /^[a-z][a-z0-9.-]{0,127}$/u;
+var NAMED_DATA_SCHEMA_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/u;
 var NAMED_DATA_ERROR_CODES = [
 	"NAMED_DATA_INVALID_REF",
 	"NAMED_DATA_INVALID_REGISTRY",
@@ -307,6 +1121,9 @@ var NAMED_DATA_ERROR_CODES = [
 	"NAMED_DATA_NOT_FOUND",
 	"NAMED_DATA_KIND_MISMATCH",
 	"NAMED_DATA_SCOPE_MISMATCH",
+	"NAMED_DATA_SCHEMA_NOT_FOUND",
+	"NAMED_DATA_SCHEMA_VERSION_MISMATCH",
+	"NAMED_DATA_SCHEMA_UNRESOLVED",
 	"NAMED_DATA_REPRESENTATION_UNSUPPORTED",
 	"NAMED_DATA_INVALID_METADATA",
 	"NAMED_DATA_BODY_TOO_LARGE",
@@ -527,9 +1344,21 @@ function validateReferenceShape(reference, representation) {
 	if (!reference || typeof reference !== "object") throw invalidReference$1();
 	requireNamespace(reference.namespace);
 	if (typeof reference.name !== "string" || reference.name.length === 0 || reference.name.length > 256 || containsControlCharacter(reference.name) || !NAMED_DATA_KINDS.includes(reference.kind) || !NAMED_DATA_SCOPES.includes(reference.scope) || !NAMED_DATA_REPRESENTATIONS.includes(representation)) throw invalidReference$1();
+	if (reference.schemaRef !== void 0) validateSchemaRef(reference.kind, reference.schemaRef);
 }
 function validateMetadata(metadata, reference, representation) {
 	if (metadata.representation !== representation || !isNativeRepresentation(metadata.reference.kind, metadata.nativeRepresentation) || metadata.reference.namespace !== reference.namespace || metadata.reference.name !== reference.name || metadata.reference.kind !== reference.kind || metadata.reference.scope !== reference.scope || typeof metadata.mediaType !== "string" || metadata.mediaType.length === 0 || typeof metadata.revision !== "string" || metadata.revision.length === 0 || typeof metadata.replayable !== "boolean" || metadata.byteLength !== void 0 && (!Number.isSafeInteger(metadata.byteLength) || metadata.byteLength < 0) || metadata.digest !== void 0 && !/^sha256-[A-Za-z0-9_-]+$/u.test(metadata.digest)) throw new NamedDataError("NAMED_DATA_INVALID_METADATA", "Provider returned invalid metadata.");
+	const expectedSchema = reference.schemaRef;
+	const actualSchema = metadata.schemaRef;
+	if (actualSchema !== void 0) validateSchemaRef(metadata.reference.kind, actualSchema, "NAMED_DATA_INVALID_METADATA");
+	if (metadata.reference.schemaRef !== void 0) validateSchemaRef(metadata.reference.kind, metadata.reference.schemaRef, "NAMED_DATA_INVALID_METADATA");
+	if (!sameSchemaRef(expectedSchema, actualSchema) || !sameSchemaRef(expectedSchema, metadata.reference.schemaRef)) throw new NamedDataError("NAMED_DATA_SCHEMA_VERSION_MISMATCH", "Provider schemaRef does not match the requested reference.");
+}
+function validateSchemaRef(kind, schemaRef, errorCode = "NAMED_DATA_INVALID_REF") {
+	if (kind !== "structured" || typeof schemaRef !== "object" || schemaRef === null || !NAMED_DATA_SCHEMA_ID_PATTERN.test(String(schemaRef.id ?? "")) || !NAMED_DATA_SCHEMA_VERSION_PATTERN.test(String(schemaRef.version ?? "")) || Object.keys(schemaRef).some((key) => key !== "id" && key !== "version")) throw new NamedDataError(errorCode, "Invalid schemaRef; schema references require a structured value, stable id, and full SemVer version.");
+}
+function sameSchemaRef(left, right) {
+	return left === void 0 ? right === void 0 : right !== void 0 && left.id === right.id && left.version === right.version;
 }
 function isNativeRepresentation(kind, representation) {
 	if (kind === "structured") return representation === "json" || representation === "yaml";
@@ -566,7 +1395,10 @@ function configuredFlag$1(name) {
 	const value = globalThis.__TW_NAMED_DATA_FEATURE_FLAGS__?.[name];
 	return value === true || value === "true";
 }
-Object.freeze({ NAMED_DATA_REGISTRY_MVP: configuredFlag$1("NAMED_DATA_REGISTRY_MVP") });
+Object.freeze({
+	NAMED_DATA_REGISTRY_MVP: configuredFlag$1("NAMED_DATA_REGISTRY_MVP"),
+	NAMED_DATA_SCHEMA_REF: configuredFlag$1("NAMED_DATA_SCHEMA_REF")
+});
 //#endregion
 //#region src/asset-cache-error.ts
 var AssetManagerError = class extends Error {
@@ -948,88 +1780,6 @@ function throwIfNamedBodyAborted(signal) {
 	if (signal?.aborted) throw namedBodyAbortError();
 }
 //#endregion
-//#region src/text-style.ts
-var TEXT_RUNTIME_NAMESPACE = "text";
-var TEXT_STYLE_RUNTIME_NAMESPACE = "textStyle";
-var TEXT_STYLE_PROPERTIES = [
-	"animation",
-	"font",
-	"color",
-	"width",
-	"align"
-];
-var DEFAULT_STAGE_WIDTH = 480;
-var DEFAULT_FONT = "Handwriting";
-var DEFAULT_COLOR = "#ffffff";
-var DEFAULT_ALIGNMENT = "center";
-var DEFAULT_OUTLINE_COLOR = "#000000";
-function textRuntimeVariableName(name) {
-	return `${TEXT_RUNTIME_NAMESPACE}:${name}`;
-}
-function textStyleRuntimeVariableName(name, property) {
-	return `${TEXT_STYLE_RUNTIME_NAMESPACE}:${name}:${property}`;
-}
-function normalizeTextStyleProperty(value) {
-	const property = String(value ?? "").trim().toLowerCase();
-	if (TEXT_STYLE_PROPERTIES.includes(property)) return property;
-	throw new Error(`Unknown text style property: ${property || "(empty)"}`);
-}
-/**
-* Normalize a DSL-facing style value for runtime-variable storage.
-* An empty value intentionally resets the property to its default.
-*/
-function normalizeTextStyleValue(property, value) {
-	const raw = String(value ?? "").trim();
-	if (!raw) return "";
-	switch (property) {
-		case "animation": {
-			const animation = raw.toLowerCase() === "typing" ? "type" : raw.toLowerCase();
-			if (animation === "none" || animation === "type" || animation === "rainbow" || animation === "zoom" || animation === "shake") return animation;
-			throw new Error(`Invalid text animation: ${raw}`);
-		}
-		case "font": return raw;
-		case "color": {
-			if (/^#[0-9a-f]{6}$/i.test(raw)) return raw.toLowerCase();
-			const shortColor = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(raw);
-			if (shortColor) return `#${shortColor[1]}${shortColor[1]}${shortColor[2]}${shortColor[2]}${shortColor[3]}${shortColor[3]}`.toLowerCase();
-			throw new Error(`Invalid text color: ${raw}`);
-		}
-		case "width": {
-			const width = Number(raw);
-			if (!Number.isFinite(width) || width <= 0) throw new Error(`Text width must be a positive number: ${raw}`);
-			return String(width);
-		}
-		case "align": {
-			const align = raw.toLowerCase();
-			if (align === "left" || align === "center" || align === "right") return align;
-			throw new Error(`Invalid text alignment: ${raw}`);
-		}
-	}
-}
-function resolveTextStyle(name, stageWidth, getRuntimeVariable) {
-	const width = Number(stageWidth);
-	const defaults = {
-		animation: "none",
-		font: DEFAULT_FONT,
-		color: DEFAULT_COLOR,
-		width: Number.isFinite(width) && width > 0 ? width : DEFAULT_STAGE_WIDTH,
-		align: DEFAULT_ALIGNMENT
-	};
-	const read = (property) => normalizeTextStyleValue(property, getRuntimeVariable(textStyleRuntimeVariableName(name, property)));
-	const animation = read("animation");
-	const font = read("font");
-	const color = read("color");
-	const configuredWidth = read("width");
-	const align = read("align");
-	return {
-		animation: animation ? animation : defaults.animation,
-		font: font || defaults.font,
-		color: color || defaults.color,
-		width: configuredWidth ? Number(configuredWidth) : defaults.width,
-		align: align ? align : defaults.align
-	};
-}
-//#endregion
 //#region src/extension.ts
 var EXTENSION_ID = "kubohiroyaassetcache";
 var EXTENSION_VERSION = "0.14.0";
@@ -1493,6 +2243,7 @@ var AssetManagerExtension = class {
 	textAssets = /* @__PURE__ */ new Map();
 	assetRegistry = /* @__PURE__ */ new Map();
 	displayedAssets = /* @__PURE__ */ new Map();
+	explicitAudio = /* @__PURE__ */ new WeakSet();
 	playingAudio = /* @__PURE__ */ new Map();
 	audioVoiceStops = /* @__PURE__ */ new WeakMap();
 	registrationVersions = /* @__PURE__ */ new Map();
@@ -1534,6 +2285,7 @@ var AssetManagerExtension = class {
 		this.unbindNamedDataRegistryLifecycle?.();
 		this.unbindNamedDataRegistryLifecycle = void 0;
 	};
+	fixedEditors = fixedInputRegistration(Scratch);
 	constructor(featureFlags = FEATURE_FLAGS) {
 		this.featureFlags = Object.freeze({ ...featureFlags });
 		if (this.featureFlags.NAMED_ASSET_BODY_PROVIDER) {
@@ -1600,6 +2352,8 @@ var AssetManagerExtension = class {
 		return loadingCostumes[((Number.isFinite(numericIndex) ? Math.max(1, Math.trunc(numericIndex)) : 1) - 1) % loadingCostumes.length];
 	}
 	getInfo() {
+		const blocks = blockDefinitions.map((block) => this.toScratchBlock(block));
+		this.fixedEditors.ensure(blocks.map((block) => `${EXTENSION_ID}_${block.opcode}`));
 		return {
 			id: EXTENSION_ID,
 			name: Scratch.translate(block_definitions_default.extensionName),
@@ -1608,9 +2362,13 @@ var AssetManagerExtension = class {
 			color1: "#5b7cfa",
 			color2: "#425ed8",
 			color3: "#2f46aa",
-			blocks: blockDefinitions.map((block) => this.toScratchBlock(block))
+			blocks
 		};
 	}
+	/** Release only this optional editor registration; runtime data remains unchanged. */
+	dispose() {
+		this.fixedEditors.dispose();
+	}
 	/**
 	* Exposes the stock extension registry through a host-neutral DOM image
 	* resource contract for other unsandboxed extensions.
@@ -1858,6 +2616,50 @@ var AssetManagerExtension = class {
 		await playback.started;
 		return playback.voice;
 	}
+	async createAudioPlayback(source, options = {}, onDispose = () => {}) {
+		validateAudioPlaybackOptions(options);
+		if (!source || typeof source !== "object" || Array.isArray(source) || Object.keys(source).length !== 1 || Object.hasOwn(source, "asset") === Object.hasOwn(source, "url")) throw new TypeError("Audio requires exactly one asset or URL.");
+		if (Object.hasOwn(source, "url")) {
+			if (typeof source.url !== "string" || !/^https?:\/\/[^\s]+$/u.test(source.url)) throw new TypeError("Audio URL must use HTTP(S) without credentials.");
+			const url = new URL(source.url);
+			if (!url.hostname || url.username || url.password) throw new TypeError("Invalid audio URL.");
+			return this.prepareBrowserAudio("", source.url, options, onDispose, "createAudioPlayback");
+		}
+		const name = normalizeName(source.asset);
+		const version = this.registrationVersions.get(name);
+		const resource = await this.resolveAudioBytes(name);
+		if (!this.assetRegistry.has(name) || version !== this.registrationVersions.get(name)) throw new Error("Audio source was released or replaced while preparing.");
+		const bytes = resource.bytes instanceof Uint8Array ? new Uint8Array(resource.bytes).buffer : resource.bytes;
+		const url = URL.createObjectURL(new Blob([bytes], { type: resource.mimeType }));
+		return this.prepareBrowserAudio(name, url, options, () => {
+			URL.revokeObjectURL(url);
+			onDispose();
+		}, "createAudioPlayback");
+	}
+	prepareBrowserAudio(name, url, options, release, operation) {
+		let audio;
+		let controller;
+		try {
+			const directAudio = operation === "createAudioPlayback" && /^https?:/u.test(url);
+			audio = directAudio ? new Audio() : new Audio(url);
+			if (directAudio) {
+				audio.crossOrigin = "anonymous";
+				audio.src = url;
+			}
+			controller = createBrowserAudioPlayback(audio, options, () => {
+				this.playingAudio.delete(audio);
+				this.audioVoiceStops.delete(audio);
+				release();
+			}, (cause) => this.playbackError(name, cause, operation));
+		} catch (cause) {
+			release();
+			throw this.playbackError(name, cause, operation);
+		}
+		if (operation === "createAudioPlayback") this.explicitAudio.add(audio);
+		this.playingAudio.set(audio, name);
+		this.audioVoiceStops.set(audio, () => controller.dispose());
+		return controller;
+	}
 	stopSound(args) {
 		const name = normalizeName(args.NAME);
 		const kind = this.assetRegistry.get(name);
@@ -1867,12 +2669,12 @@ var AssetManagerExtension = class {
 			if (!asset) throw this.assetNotRegistered("stopSound", name);
 			asset.mimeType = normalizeMimeType(asset.mimeType, asset.url || name);
 			if (!asset.mimeType.startsWith("audio/")) throw this.assetTypeMismatch("stopSound", name, "audio", `external/${this.externalMediaKind(asset)}`);
-			for (const [audio, assetName] of [...this.playingAudio]) if (assetName === name) this.stopExternalAudio(audio);
+			for (const [audio, assetName] of [...this.playingAudio]) if (assetName === name && !this.explicitAudio.has(audio)) this.stopExternalAudio(audio);
 			return;
 		}
 		if (kind === "sound") {
 			const { target, sound, soundBank } = this.resolveSoundReference(name);
-			for (const [audio, assetName] of [...this.playingAudio]) if (assetName === name) this.stopExternalAudio(audio);
+			for (const [audio, assetName] of [...this.playingAudio]) if (assetName === name && !this.explicitAudio.has(audio)) this.stopExternalAudio(audio);
 			soundBank.stop(target, sound.soundId);
 			return;
 		}
@@ -2120,6 +2922,7 @@ var AssetManagerExtension = class {
 	}
 	unregisterAsset(name) {
 		this.cancelRegistrations(name);
+		for (const [audio, assetName] of [...this.playingAudio]) if (assetName === name) this.stopExternalAudio(audio);
 		this.invalidateDOMImageResources(name);
 		const kind = this.assetRegistry.get(name);
 		if (!kind) return;
@@ -2935,73 +3738,33 @@ var AssetManagerExtension = class {
 	}
 	startBrowserAudioVoice(name, bytes, mimeType, initialGain, operation) {
 		const blobBytes = bytes instanceof Uint8Array ? new Uint8Array(bytes).buffer : bytes;
-		const objectUrl = URL.createObjectURL(new Blob([blobBytes], { type: mimeType }));
-		let audio;
-		try {
-			audio = new Audio(objectUrl);
-			audio.volume = initialGain;
-		} catch (error) {
-			URL.revokeObjectURL(objectUrl);
-			throw this.playbackError(name, error, operation);
-		}
+		const url = URL.createObjectURL(new Blob([blobBytes], { type: mimeType }));
+		const controller = this.prepareBrowserAudio(name, url, { gain: initialGain }, () => URL.revokeObjectURL(url), operation);
 		let active = true;
-		let resolveEnded;
-		let rejectEnded;
-		const ended = new Promise((resolve, reject) => {
-			resolveEnded = resolve;
-			rejectEnded = reject;
-		});
-		ended.catch(() => {});
-		const cleanup = (error) => {
-			if (!active) return;
-			active = false;
-			audio.removeEventListener("ended", handleEnded);
-			audio.removeEventListener("error", handleError);
-			this.playingAudio.delete(audio);
-			this.audioVoiceStops.delete(audio);
-			URL.revokeObjectURL(objectUrl);
-			if (error === void 0) resolveEnded();
-			else rejectEnded(error);
-		};
-		const handleEnded = () => cleanup();
-		const handleError = () => cleanup(operation === "createAudioVoice" ? this.playbackError(name, /* @__PURE__ */ new Error("The browser audio element reported a playback error."), operation) : void 0);
 		const stop = () => {
 			if (!active) return;
-			try {
-				audio.pause();
-				audio.currentTime = 0;
-			} catch {}
-			cleanup();
+			active = false;
+			controller.dispose();
 		};
-		const voice = Object.freeze({
-			ended,
-			setGain(value) {
-				const gain = normalizeAudioVoiceGain(value);
-				if (active) audio.volume = gain;
-			},
-			stop
+		const started = controller.play();
+		const ended = controller.ended.then(() => stop(), (error) => {
+			stop();
+			if (operation === "createAudioVoice") throw error;
 		});
-		audio.addEventListener("ended", handleEnded, { once: true });
-		audio.addEventListener("error", handleError, { once: true });
-		this.playingAudio.set(audio, name);
-		this.audioVoiceStops.set(audio, stop);
-		let playResult;
-		try {
-			playResult = audio.play();
-		} catch (error) {
-			const playbackError = this.playbackError(name, error, operation);
-			cleanup(playbackError);
-			return {
-				voice,
-				started: Promise.reject(playbackError)
-			};
-		}
+		ended.catch(() => {});
 		return {
-			voice,
-			started: Promise.resolve(playResult).catch((error) => {
-				const playbackError = this.playbackError(name, error, operation);
-				cleanup(playbackError);
-				throw playbackError;
+			voice: Object.freeze({
+				ended,
+				setGain(value) {
+					const gain = normalizeAudioVoiceGain(value);
+					if (active) controller.setGain(gain);
+				},
+				stop
+			}),
+			started: started.catch((error) => {
+				const legacyStop = operation === "playSound" && !active && error instanceof Error && error.name === "AbortError";
+				stop();
+				if (!legacyStop) throw error;
 			})
 		};
 	}
@@ -8041,6 +8804,8 @@ function createAssetManagerComposition(featureFlags, options = {}) {
 			}
 		});
 	}
+	const audioPlaybacks = /* @__PURE__ */ new Set();
+	let audioGeneration = 0;
 	function releaseAsset(name) {
 		const owned = ownedName(name);
 		if (!owned) return;
@@ -8221,7 +8986,13 @@ function createAssetManagerComposition(featureFlags, options = {}) {
 		releaseAsset,
 		releaseAll() {
 			releaseAllDOMImageResources();
+			audioGeneration++;
 			const errors = [];
+			for (const playback of audioPlaybacks) try {
+				playback.dispose();
+			} catch (error) {
+				errors.push(error);
+			}
 			for (const name of [...ownedNames.keys()].reverse()) try {
 				releaseAsset(name);
 			} catch (error) {
@@ -8267,6 +9038,21 @@ function createAssetManagerComposition(featureFlags, options = {}) {
 		createAudioVoice(name, options) {
 			return extension.createAudioVoice(ownedName(name)?.internal ?? name, options);
 		},
+		async createAudioPlayback(source, options) {
+			if (!source || typeof source !== "object" || Array.isArray(source) || Object.keys(source).length !== 1) throw new TypeError("Invalid audio source.");
+			const generation = audioGeneration;
+			const normalizedSource = Object.hasOwn(source, "asset") ? { asset: ownedName(source.asset)?.internal ?? source.asset } : source;
+			let playback;
+			playback = await extension.createAudioPlayback(normalizedSource, options, () => {
+				if (playback) audioPlaybacks.delete(playback);
+			});
+			if (generation !== audioGeneration) {
+				playback.dispose();
+				throw new Error("Audio composition was released while preparing.");
+			}
+			audioPlaybacks.add(playback);
+			return playback;
+		},
 		stopSound(name) {
 			extension.stopSound({ NAME: ownedName(name)?.internal ?? name });
 		},