Skip to content

godothub/godot-minigame / skills

godot-wechat-minigame-adapter

Unverified

Apply the bundled self-contained Godot WeChat Mini Game adapter kit to an official Godot checkout. Use when the user wants to port official Godot to WeChat Mini Game, refresh a nearby 4.6-based port, or inspect the shipped patch/source bundle for WXMEMFS, `wx.request`, audio cleanup, display/input, WXGLX dual-path rendering, `.wasm.br`, and `wx.exitMiniProgram`. This skill is version-locked to the bundled upstream base and must not be described as a generic “Godot 4.x” patch dump.

FileKindSize
SKILL.mdskill md6.0 KB
agents/openai.yamlconfig269 B
assets/min-runtime/godot-loader.jsscript16.6 KB
assets/min-runtime/godot-sdk.jsscript7.8 KB
patches/fixes/4.7-webgl-context/001-context-swap-control.patchother4.2 KB
patches/fixes/4.7-webgl-context/README.mdmarkdown1.5 KB
patches/godot-4.6.2-rc-a16e481cf4/core/001-build-and-runtime-glue.patchother12.4 KB
patches/godot-4.6.2-rc-a16e481cf4/core/002-native-audio-routing.patchother6.3 KB
patches/godot-4.6.2-rc-a16e481cf4/core/003-wxglx-nine-patch-expansion.patchother5.7 KB
patches/godot-4.6.2-rc-a16e481cf4/core/004-wxglx-nine-patch-runtime-scope.patchother7.2 KB
patches/godot-4.6.2-rc-a16e481cf4/core/series.txtmarkdown142 B
patches/godot-4.6.2-rc-a16e481cf4/manifest.jsonconfig993 B
patches/godot-4.6.2-rc-a16e481cf4/optional/001-audio-worker.patchother820 B
patches/godot-4.6.2-rc-a16e481cf4/optional/series.txtmarkdown23 B
references/compatibility-matrix.mdmarkdown1.2 KB
references/migration-modules.mdmarkdown5.8 KB
references/recent-commit-deltas.mdmarkdown2.2 KB
references/runtime-shell.mdmarkdown3.8 KB
references/validation-checklist.mdmarkdown3.4 KB
references/wxglx-adaptation.mdmarkdown8.8 KB
scripts/apply_godot_patchset.pyscript5.6 KB
scripts/compress_wasm.batscript100 B
scripts/compress_wasm.shscript91 B
scripts/godot_process.jsscript5.3 KB
scripts/install_min_runtime.pyscript1.1 KB
scripts/validate_template_runtime.jsscript2.8 KB
sources/godot-4.6.2-rc-a16e481cf4/compress_wasm.batscript237 B
sources/godot-4.6.2-rc-a16e481cf4/compress_wasm.shscript215 B
sources/godot-4.6.2-rc-a16e481cf4/godot_process.jsscript5.3 KB
sources/godot-4.6.2-rc-a16e481cf4/optional/platform/web/js/libs/audio.worker.jsscript6.6 KB
sources/godot-4.6.2-rc-a16e481cf4/optional/platform/web/js/libs/lib.wx.api.d.tsscript516.7 KB
sources/godot-4.6.2-rc-a16e481cf4/platform/web/js/libs/library_blob.jsscript27.1 KB
sources/godot-4.6.2-rc-a16e481cf4/platform/web/js/libs/library_godot_audio.jsscript88.8 KB
sources/godot-4.6.2-rc-a16e481cf4/platform/web/js/libs/library_godot_crypto.jsscript116 B
sources/godot-4.6.2-rc-a16e481cf4/platform/web/js/libs/library_godot_display.jsscript26.4 KB
sources/godot-4.6.2-rc-a16e481cf4/platform/web/js/libs/library_godot_fetch.jsscript8.9 KB
sources/godot-4.6.2-rc-a16e481cf4/platform/web/js/libs/library_godot_fs.jsscript29.4 KB
sources/godot-4.6.2-rc-a16e481cf4/platform/web/js/libs/library_godot_input.jsscript23.2 KB
tests/test_godot_process_commit_frame.jsscript2.6 KB
tests/test_min_runtime_loader.jsscript3.8 KB
tests/test_template_glx_config.jsscript1.3 KB
tests/test_wechat_audio_context_source_reuse.jsscript3.9 KB
tests/test_wxglx_nine_patch_patch.jsscript2.2 KB

sources/godot-4.6.2-rc-a16e481cf4/platform/web/js/libs/library_godot_audio.js

View on GitHub
/**************************************************************************/
/*  library_godot_audio.js                                                */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

/**
 * @typedef { "disabled" | "forward" | "backward" | "pingpong" } LoopMode
 */

/**
 * @typedef {{
 *   id: string
 *   audioBuffer: AudioBuffer
 * }} SampleParams
 * @typedef {{
 *   numberOfChannels?: number
 *   sampleRate?: number
 *   loopMode?: LoopMode
 *   loopBegin?: number
 *   loopEnd?: number
 * }} SampleOptions
 */

/**
 * Represents a sample, memory-wise.
 * @class
 */
class Sample {
	/**
	 * Returns a `Sample`.
	 * @param {string} id Id of the `Sample` to get.
	 * @returns {Sample}
	 * @throws {ReferenceError} When no `Sample` is found
	 */
	static getSample(id) {
		if (!GodotAudio.samples.has(id)) {
			throw new ReferenceError(`Could not find sample "${id}"`);
		}
		return GodotAudio.samples.get(id);
	}

	/**
	 * Returns a `Sample` or `null`, if it doesn't exist.
	 * @param {string} id Id of the `Sample` to get.
	 * @returns {Sample?}
	 */
	static getSampleOrNull(id) {
		return GodotAudio.samples.get(id) ?? null;
	}

	/**
	 * Creates a `Sample` based on the params. Will register it to the
	 * `GodotAudio.samples` registry.
	 * @param {SampleParams} params Base params
	 * @param {SampleOptions | undefined} options Optional params.
	 * @returns {Sample}
	 */
	static create(params, options = {}) {
		const sample = new GodotAudio.Sample(params, options);
		GodotAudio.samples.set(params.id, sample);
		return sample;
	}

	/**
	 * Deletes a `Sample` based on the id.
	 * @param {string} id `Sample` id to delete
	 * @returns {void}
	 */
	static delete(id) {
		GodotAudio.samples.delete(id);
	}

	/**
	 * `Sample` constructor.
	 * @param {SampleParams} params Base params
	 * @param {SampleOptions | undefined} options Optional params.
	 */
	constructor(params, options = {}) {
		/** @type {string} */
		this.id = params.id;
		/** @type {AudioBuffer} */
		this._audioBuffer = null;
		/** @type {number} */
		this.numberOfChannels = options.numberOfChannels ?? 2;
		/** @type {number} */
		this.sampleRate = options.sampleRate ?? 44100;
		/** @type {LoopMode} */
		this.loopMode = options.loopMode ?? "disabled";
		/** @type {number} */
		this.loopBegin = options.loopBegin ?? 0;
		/** @type {number} */
		this.loopEnd = options.loopEnd ?? 0;

		this.setAudioBuffer(params.audioBuffer);
	}

	/**
	 * Gets the audio buffer of the sample.
	 * @returns {AudioBuffer}
	 */
	getAudioBuffer() {
		return this._duplicateAudioBuffer();
	}

	/**
	 * Sets the audio buffer of the sample.
	 * @param {AudioBuffer} val The audio buffer to set.
	 * @returns {void}
	 */
	setAudioBuffer(val) {
		this._audioBuffer = val;
	}

	/**
	 * Clears the current sample.
	 * @returns {void}
	 */
	clear() {
		this.setAudioBuffer(null);
		GodotAudio.Sample.delete(this.id);
	}

	/**
	 * Returns a duplicate of the stored audio buffer.
	 * @returns {AudioBuffer}
	 */
	_duplicateAudioBuffer() {
		if (this._audioBuffer == null) {
			throw new Error("couldn't duplicate a null audioBuffer");
		}
		/** @type {Array<Float32Array>} */
		const channels = new Array(this._audioBuffer.numberOfChannels);
		for (let i = 0; i < this._audioBuffer.numberOfChannels; i++) {
			const channel = new Float32Array(this._audioBuffer.getChannelData(i));
			channels[i] = channel;
		}
		const buffer = GodotAudio.ctx.createBuffer(
			this.numberOfChannels,
			this._audioBuffer.length,
			this._audioBuffer.sampleRate
		);
		for (let i = 0; i < channels.length; i++) {
			buffer.copyToChannel(channels[i], i, 0);
		}
		return buffer;
	}
}

/**
 * Represents a `SampleNode` linked to a `Bus`.
 * @class
 */
class SampleNodeBus {
	/**
	 * Creates a new `SampleNodeBus`.
	 * @param {Bus} bus The bus related to the new `SampleNodeBus`.
	 * @returns {SampleNodeBus}
	 */
	static create(bus) {
		return new GodotAudio.SampleNodeBus(bus);
	}

	/**
	 * `SampleNodeBus` constructor.
	 * @param {Bus} bus The bus related to the new `SampleNodeBus`.
	 */
	constructor(bus) {
		const NUMBER_OF_WEB_CHANNELS = 6;

		/** @type {Bus} */
		this._bus = bus;

		/** @type {ChannelSplitterNode} */
		this._channelSplitter = GodotAudio.ctx.createChannelSplitter(NUMBER_OF_WEB_CHANNELS);
		/** @type {GainNode} */
		this._l = GodotAudio.ctx.createGain();
		/** @type {GainNode} */
		this._r = GodotAudio.ctx.createGain();
		/** @type {GainNode} */
		this._sl = GodotAudio.ctx.createGain();
		/** @type {GainNode} */
		this._sr = GodotAudio.ctx.createGain();
		/** @type {GainNode} */
		this._c = GodotAudio.ctx.createGain();
		/** @type {GainNode} */
		this._lfe = GodotAudio.ctx.createGain();
		/** @type {ChannelMergerNode} */
		this._channelMerger = GodotAudio.ctx.createChannelMerger(NUMBER_OF_WEB_CHANNELS);

		// WeChat Mini Game doesn't support chained connect() calls
		// Must break them into separate statements
		this._channelSplitter.connect(this._l, GodotAudio.WebChannel.CHANNEL_L);
		this._l.connect(this._channelMerger, GodotAudio.WebChannel.CHANNEL_L, GodotAudio.WebChannel.CHANNEL_L);

		this._channelSplitter.connect(this._r, GodotAudio.WebChannel.CHANNEL_R);
		this._r.connect(this._channelMerger, GodotAudio.WebChannel.CHANNEL_L, GodotAudio.WebChannel.CHANNEL_R);

		this._channelSplitter.connect(this._sl, GodotAudio.WebChannel.CHANNEL_SL);
		this._sl.connect(this._channelMerger, GodotAudio.WebChannel.CHANNEL_L, GodotAudio.WebChannel.CHANNEL_SL);

		this._channelSplitter.connect(this._sr, GodotAudio.WebChannel.CHANNEL_SR);
		this._sr.connect(this._channelMerger, GodotAudio.WebChannel.CHANNEL_L, GodotAudio.WebChannel.CHANNEL_SR);

		this._channelSplitter.connect(this._c, GodotAudio.WebChannel.CHANNEL_C);
		this._c.connect(this._channelMerger, GodotAudio.WebChannel.CHANNEL_L, GodotAudio.WebChannel.CHANNEL_C);

		this._channelSplitter.connect(this._lfe, GodotAudio.WebChannel.CHANNEL_L);
		this._lfe.connect(this._channelMerger, GodotAudio.WebChannel.CHANNEL_L, GodotAudio.WebChannel.CHANNEL_LFE);

		this._channelMerger.connect(this._bus.getInputNode());
	}

	/**
	 * Returns the input node.
	 * @returns {AudioNode}
	 */
	getInputNode() {
		return this._channelSplitter;
	}

	/**
	 * Returns the output node.
	 * @returns {AudioNode}
	 */
	getOutputNode() {
		return this._channelMerger;
	}

	/**
	 * Sets the volume for each (split) channel.
	 * @param {Float32Array} volume Volume array from the engine for each channel.
	 * @returns {void}
	 */
	setVolume(volume) {
		if (volume.length !== GodotAudio.MAX_VOLUME_CHANNELS) {
			throw new Error(`Volume length isn't "${GodotAudio.MAX_VOLUME_CHANNELS}", is ${volume.length} instead`);
		}
		this._l.gain.value = volume[GodotAudio.GodotChannel.CHANNEL_L] ?? 0;
		this._r.gain.value = volume[GodotAudio.GodotChannel.CHANNEL_R] ?? 0;
		this._sl.gain.value = volume[GodotAudio.GodotChannel.CHANNEL_SL] ?? 0;
		this._sr.gain.value = volume[GodotAudio.GodotChannel.CHANNEL_SR] ?? 0;
		this._c.gain.value = volume[GodotAudio.GodotChannel.CHANNEL_C] ?? 0;
		this._lfe.gain.value = volume[GodotAudio.GodotChannel.CHANNEL_LFE] ?? 0;
	}

	/**
	 * Clears the current `SampleNodeBus` instance.
	 * @returns {void}
	 */
	clear() {
		this._bus = null;
		this._channelSplitter.disconnect();
		this._channelSplitter = null;
		this._l.disconnect();
		this._l = null;
		this._r.disconnect();
		this._r = null;
		this._sl.disconnect();
		this._sl = null;
		this._sr.disconnect();
		this._sr = null;
		this._c.disconnect();
		this._c = null;
		this._lfe.disconnect();
		this._lfe = null;
		this._channelMerger.disconnect();
		this._channelMerger = null;
	}
}

/**
 * @typedef {{
 *   id: string
 *   streamObjectId: string
 *   busIndex: number
 * }} SampleNodeParams
 * @typedef {{
 *   offset?: number
 *   playbackRate?: number
 *   startTime?: number
 *   pitchScale?: number
 *   loopMode?: LoopMode
 *   volume?: Float32Array
 *   start?: boolean
 * }} SampleNodeOptions
 */

/**
 * Represents an `AudioNode` of a `Sample`.
 * @class
 */
class SampleNode {
	/**
	 * Returns a `SampleNode`.
	 * @param {string} id Id of the `SampleNode`.
	 * @returns {SampleNode}
	 * @throws {ReferenceError} When no `SampleNode` is not found
	 */
	static getSampleNode(id) {
		if (!GodotAudio.sampleNodes.has(id)) {
			throw new ReferenceError(`Could not find sample node "${id}"`);
		}
		return GodotAudio.sampleNodes.get(id);
	}

	/**
	 * Returns a `SampleNode`, returns null if not found.
	 * @param {string} id Id of the SampleNode.
	 * @returns {SampleNode?}
	 */
	static getSampleNodeOrNull(id) {
		return GodotAudio.sampleNodes.get(id) ?? null;
	}

	/**
	 * Stops a `SampleNode` by id.
	 * @param {string} id Id of the `SampleNode` to stop.
	 * @returns {void}
	 */
	static stopSampleNode(id) {
		const sampleNode = GodotAudio.SampleNode.getSampleNodeOrNull(id);
		if (sampleNode == null) {
			return;
		}
		sampleNode.stop();
	}

	/**
	 * Pauses the `SampleNode` by id.
	 * @param {string} id Id of the `SampleNode` to pause.
	 * @param {boolean} enable State of the pause
	 * @returns {void}
	 */
	static pauseSampleNode(id, enable) {
		const sampleNode = GodotAudio.SampleNode.getSampleNodeOrNull(id);
		if (sampleNode == null) {
			return;
		}
		sampleNode.pause(enable);
	}

	/**
	 * Creates a `SampleNode` based on the params. Will register the `SampleNode` to
	 * the `GodotAudio.sampleNodes` regisery.
	 * @param {SampleNodeParams} params Base params.
	 * @param {SampleNodeOptions | undefined} options Optional params.
	 * @returns {SampleNode}
	 */
	static create(params, options = {}) {
		const sampleNode = new GodotAudio.SampleNode(params, options);
		GodotAudio.sampleNodes.set(params.id, sampleNode);
		return sampleNode;
	}

	/**
	 * Deletes a `SampleNode` based on the id.
	 * @param {string} id Id of the `SampleNode` to delete.
	 * @returns {void}
	 */
	static delete(id) {
		GodotAudio.deleteSampleNode(id);
	}

	/**
	 * @param {SampleNodeParams} params Base params
	 * @param {SampleNodeOptions | undefined} options Optional params.
	 */
	constructor(params, options = {}) {
		/** @type {string} */
		this.id = params.id;
		/** @type {string} */
		this.streamObjectId = params.streamObjectId;
		/** @type {number} */
		this.offset = options.offset ?? 0;
		/** @type {number} */
		this._playbackPosition = options.offset;
		/** @type {number} */
		this.startTime = options.startTime ?? 0;
		/** @type {boolean} */
		this.isPaused = false;
		/** @type {boolean} */
		this.isStarted = false;
		/** @type {boolean} */
		this.isCleared = false;
		/** @type {boolean} */
		this.isCanceled = false;
		/** @type {number} */
		this.pauseTime = 0;
		/** @type {number} */
		this._playbackRate = 44100;
		/** @type {LoopMode} */
		this.loopMode = options.loopMode ?? this.getSample().loopMode ?? "disabled";
		/** @type {number} */
		this._pitchScale = options.pitchScale ?? 1;
		/** @type {number} */
		this._sourceStartTime = 0;
		/** @type {Map<Bus, SampleNodeBus>} */
		this._sampleNodeBuses = new Map();
		/** @type {AudioBufferSourceNode | null} */
		this._source = GodotAudio.ctx.createBufferSource();

		this._onended = null;
		/** @type {AudioWorkletNode | null} */
		this._positionWorklet = null;

		this.setPlaybackRate(options.playbackRate ?? 44100);
		this._source.buffer = this.getSample().getAudioBuffer();

		this._addEndedListener();

		const bus = GodotAudio.Bus.getBus(params.busIndex);
		const sampleNodeBus = this.getSampleNodeBus(bus);
		sampleNodeBus.setVolume(options.volume);

		this.connectAudioContext(options.start);
	}

	/**
	 * Gets the playback rate.
	 * @returns {number}
	 */
	getPlaybackRate() {
		return this._playbackRate;
	}

	/**
	 * Gets the playback position.
	 * @returns {number}
	 */
	getPlaybackPosition() {
		return this._playbackPosition;
	}

	/**
	 * Sets the playback rate.
	 * @param {number} val Value to set.
	 * @returns {void}
	 */
	setPlaybackRate(val) {
		this._playbackRate = val;
		this._syncPlaybackRate();
	}

	/**
	 * Gets the pitch scale.
	 * @returns {number}
	 */
	getPitchScale() {
		return this._pitchScale;
	}

	/**
	 * Sets the pitch scale.
	 * @param {number} val Value to set.
	 * @returns {void}
	 */
	setPitchScale(val) {
		this._pitchScale = val;
		this._syncPlaybackRate();
	}

	/**
	 * Returns the linked `Sample`.
	 * @returns {Sample}
	 */
	getSample() {
		return GodotAudio.Sample.getSample(this.streamObjectId);
	}

	/**
	 * Returns the output node.
	 * @returns {AudioNode}
	 */
	getOutputNode() {
		return this._source;
	}

	/**
	 * Starts the `SampleNode`.
	 * @returns {void}
	 */
	start() {
		if (this.isStarted) {
			return;
		}
		this._resetSourceStartTime();
		this._source.start(this.startTime, this.offset);
		this.isStarted = true;
	}

	/**
	 * Stops the `SampleNode`.
	 * @returns {void}
	 */
	stop() {
		this.clear();
	}

	/**
	 * Restarts the `SampleNode`.
	 */
	restart() {
		this.isPaused = false;
		this.pauseTime = 0;
		this._resetSourceStartTime();
		this._restart();
	}

	/**
	 * Pauses the `SampleNode`.
	 * @param {boolean} [enable=true] State of the pause.
	 * @returns {void}
	 */
	pause(enable = true) {
		if (enable) {
			this._pause();
			return;
		}

		this._unpause();
	}

	/**
	 * Connects an AudioNode to the output node of this `SampleNode`.
	 * @param {AudioNode} node AudioNode to connect.
	 * @returns {void}
	 */
	connect(node) {
		return this.getOutputNode().connect(node);
	}

	/**
	 * Sets the volumes of the `SampleNode` for each buses passed in parameters.
	 * @param {Array<Bus>} buses
	 * @param {Float32Array} volumes
	 */
	setVolumes(buses, volumes) {
		for (let busIdx = 0; busIdx < buses.length; busIdx++) {
			const sampleNodeBus = this.getSampleNodeBus(buses[busIdx]);
			sampleNodeBus.setVolume(
				volumes.slice(
					busIdx * GodotAudio.MAX_VOLUME_CHANNELS,
					busIdx * GodotAudio.MAX_VOLUME_CHANNELS + GodotAudio.MAX_VOLUME_CHANNELS
				)
			);
		}
	}

	/**
	 * Returns the SampleNodeBus based on the bus in parameters.
	 * @param {Bus} bus Bus to get the SampleNodeBus from.
	 * @returns {SampleNodeBus}
	 */
	getSampleNodeBus(bus) {
		if (!this._sampleNodeBuses.has(bus)) {
			const sampleNodeBus = GodotAudio.SampleNodeBus.create(bus);
			this._sampleNodeBuses.set(bus, sampleNodeBus);
			this._source.connect(sampleNodeBus.getInputNode());
		}
		return this._sampleNodeBuses.get(bus);
	}

	/**
	 * Sets up and connects the source to the GodotPositionReportingProcessor
	 * If the worklet module is not loaded in, it will be added
	 */
	async connectAudioContext(start) {
		if (start) {
			this._source.start();
		}
	}

	/**
	 * Clears the `SampleNode`.
	 * @returns {void}
	 */
	clear() {
		this.isCanceled = true;
		this.isPaused = false;
		this.pauseTime = 0;
		this.isCleared = true;

		if (this._source != null) {
			this._source.onended = null;
			this._onended = null;
			if (this.isStarted) {
				this._source.stop();
			}
			this._source.disconnect();
			this._source = null;
		}

		for (const sampleNodeBus of this._sampleNodeBuses.values()) {
			sampleNodeBus.clear();
		}
		this._sampleNodeBuses.clear();

		if (this._positionWorklet) {
			this._positionWorklet.disconnect();
			this._positionWorklet.port.onmessage = null;
			GodotAudio.audioPositionWorkletNodes.push(this._positionWorklet);
			this._positionWorklet = null;
		}

		GodotAudio.SampleNode.delete(this.id);
	}

	/**
	 * Resets the source start time
	 * @returns {void}
	 */
	_resetSourceStartTime() {
		this._sourceStartTime = GodotAudio.ctx.currentTime;
	}

	/**
	 * Syncs the `AudioNode` playback rate based on the `SampleNode` playback rate and pitch scale.
	 * @returns {void}
	 */
	_syncPlaybackRate() {
		this._source.playbackRate.value = this.getPlaybackRate() * this.getPitchScale();
	}

	/**
	 * Restarts the `SampleNode`.
	 * Honors `isPaused` and `pauseTime`.
	 * @returns {void}
	 */
	_restart() {
		if (this._source != null) {
			this._source.disconnect();
		}
		this._source = GodotAudio.ctx.createBufferSource();
		this._source.buffer = this.getSample().getAudioBuffer();

		// Make sure that we connect the new source to the sample node bus.
		for (const sampleNodeBus of this._sampleNodeBuses.values()) {
			this.connect(sampleNodeBus.getInputNode());
		}

		this._addEndedListener();
		const pauseTime = this.isPaused ? this.pauseTime : 0;
		if (this._positionWorklet != null) {
			this._positionWorklet.port.postMessage({ type: "clear" });
			this._source.connect(this._positionWorklet);
		}
		this.connectAudioContext();
		this._source.start(this.startTime, this.offset + pauseTime);
		this.isStarted = true;
	}

	/**
	 * Pauses the `SampleNode`.
	 * @returns {void}
	 */
	_pause() {
		if (!this.isStarted) {
			return;
		}
		this.isPaused = true;
		this.pauseTime = (GodotAudio.ctx.currentTime - this._sourceStartTime) / this.getPlaybackRate();
		this._source.stop();
	}

	/**
	 * Unpauses the `SampleNode`.
	 * @returns {void}
	 */
	_unpause() {
		this._restart();
		this.isPaused = false;
		this.pauseTime = 0;
	}

	/**
	 * Adds an "ended" listener to the source node to repeat it if necessary.
	 * @returns {void}
	 */
	_addEndedListener() {
		if (this._onended != null) {
			this._source.onended = null;
		}
		const self = this;

		if (this.isPaused || this.isCleared) {
			return;
		}

		/** @type {SampleNode} */
		// eslint-disable-next-line consistent-this
		this._onended = (_) => {
			if (self.isPaused) {
				return;
			}

			switch (self.getSample().loopMode) {
				case "disabled":
					self.stop();
					break;
				case "forward":
				case "backward":
					self.restart();
					break;
				default:
				// do nothing
			}
		};
		this._source.onended = this._onended;
	}
}

/**
 * Collection of nodes to represents a Godot Engine audio bus.
 * @class
 */
class Bus {
	/**
	 * Returns the number of registered buses.
	 * @returns {number}
	 */
	static getCount() {
		return GodotAudio.buses.length;
	}

	/**
	 * Sets the number of registered buses.
	 * Will delete buses if lower than the current number.
	 * @param {number} val Count of registered buses.
	 * @returns {void}
	 */
	static setCount(val) {
		const buses = GodotAudio.buses;
		if (val === buses.length) {
			return;
		}

		if (val < buses.length) {
			// TODO: what to do with nodes connected to the deleted buses?
			const deletedBuses = buses.slice(val);
			for (let i = 0; i < deletedBuses.length; i++) {
				const deletedBus = deletedBuses[i];
				deletedBus.clear();
			}
			GodotAudio.buses = buses.slice(0, val);
			return;
		}

		for (let i = GodotAudio.buses.length; i < val; i++) {
			GodotAudio.Bus.create();
		}
	}

	/**
	 * Returns a `Bus` based on it's index number.
	 * @param {number} index
	 * @returns {Bus}
	 * @throws {ReferenceError} If the index value is outside the registry.
	 */
	static getBus(index) {
		if (index < 0 || index >= GodotAudio.buses.length) {
			throw new ReferenceError(`invalid bus index "${index}"`);
		}
		return GodotAudio.buses[index];
	}

	/**
	 * Returns a `Bus` based on it's index number. Returns null if it doesn't exist.
	 * @param {number} index
	 * @returns {Bus?}
	 */
	static getBusOrNull(index) {
		if (index < 0 || index >= GodotAudio.buses.length) {
			return null;
		}
		return GodotAudio.buses[index];
	}

	/**
	 * Move a bus from an index to another.
	 * @param {number} fromIndex From index
	 * @param {number} toIndex To index
	 * @returns {void}
	 */
	static move(fromIndex, toIndex) {
		const movedBus = GodotAudio.Bus.getBusOrNull(fromIndex);
		if (movedBus == null) {
			return;
		}
		const buses = GodotAudio.buses.filter((_, i) => i !== fromIndex);
		// Inserts at index.
		buses.splice(toIndex - 1, 0, movedBus);
		GodotAudio.buses = buses;
	}

	/**
	 * Adds a new bus at the specified index.
	 * @param {number} index Index to add a new bus.
	 * @returns {void}
	 */
	static addAt(index) {
		const newBus = GodotAudio.Bus.create();
		if (index !== newBus.getId()) {
			GodotAudio.Bus.move(newBus.getId(), index);
		}
	}

	/**
	 * Creates a `Bus` and registers it.
	 * @returns {Bus}
	 */
	static create() {
		const newBus = new GodotAudio.Bus();
		const isFirstBus = GodotAudio.buses.length === 0;
		GodotAudio.buses.push(newBus);
		if (isFirstBus) {
			newBus.setSend(null);
		} else {
			newBus.setSend(GodotAudio.Bus.getBus(0));
		}
		return newBus;
	}

	/**
	 * `Bus` constructor.
	 */
	constructor() {
		/** @type {Set<SampleNode>} */
		this._sampleNodes = new Set();
		/** @type {boolean} */
		this.isSolo = false;
		/** @type {Bus?} */
		this._send = null;

		/** @type {GainNode} */
		this._gainNode = GodotAudio.ctx.createGain();
		/** @type {GainNode} */
		this._soloNode = GodotAudio.ctx.createGain();
		/** @type {GainNode} */
		this._muteNode = GodotAudio.ctx.createGain();

		this._gainNode.connect(this._soloNode);
		this._soloNode.connect(this._muteNode);
	}

	/**
	 * Returns the current id of the bus (its index).
	 * @returns {number}
	 */
	getId() {
		return GodotAudio.buses.indexOf(this);
	}

	/**
	 * Returns the bus volume db value.
	 * @returns {number}
	 */
	getVolumeDb() {
		return GodotAudio.linear_to_db(this._gainNode.gain.value);
	}

	/**
	 * Sets the bus volume db value.
	 * @param {number} val Value to set
	 * @returns {void}
	 */
	setVolumeDb(val) {
		const linear = GodotAudio.db_to_linear(val);
		if (isFinite(linear)) {
			this._gainNode.gain.value = linear;
		}
	}

	/**
	 * Returns the "send" bus.
	 * If null, this bus sends its contents directly to the output.
	 * If not null, this bus sends its contents to another bus.
	 * @returns {Bus?}
	 */
	getSend() {
		return this._send;
	}

	/**
	 * Sets the "send" bus.
	 * If null, this bus sends its contents directly to the output.
	 * If not null, this bus sends its contents to another bus.
	 *
	 * **Note:** if null, `getId()` must be equal to 0. Otherwise, it will throw.
	 * @param {Bus?} val
	 * @returns {void}
	 * @throws {Error} When val is `null` and `getId()` isn't equal to 0
	 */
	setSend(val) {
		this._send = val;
		if (val == null) {
			if (this.getId() == 0) {
				this.getOutputNode().connect(GodotAudio.ctx.destination);
				return;
			}
			throw new Error(
				`Cannot send to "${val}" without the bus being at index 0 (current index: ${this.getId()})`
			);
		}
		this.connect(val);
	}

	/**
	 * Returns the input node of the bus.
	 * @returns {AudioNode}
	 */
	getInputNode() {
		return this._gainNode;
	}

	/**
	 * Returns the output node of the bus.
	 * @returns {AudioNode}
	 */
	getOutputNode() {
		return this._muteNode;
	}

	/**
	 * Sets the mute status of the bus.
	 * @param {boolean} enable
	 */
	mute(enable) {
		this._muteNode.gain.value = enable ? 0 : 1;
	}

	/**
	 * Sets the solo status of the bus.
	 * @param {boolean} enable
	 */
	solo(enable) {
		if (this.isSolo === enable) {
			return;
		}

		if (enable) {
			if (GodotAudio.busSolo != null && GodotAudio.busSolo !== this) {
				GodotAudio.busSolo._disableSolo();
			}
			this._enableSolo();
			return;
		}

		this._disableSolo();
	}

	/**
	 * Wrapper to simply add a sample node to the bus.
	 * @param {SampleNode} sampleNode `SampleNode` to remove
	 * @returns {void}
	 */
	addSampleNode(sampleNode) {
		this._sampleNodes.add(sampleNode);
		sampleNode.getOutputNode().connect(this.getInputNode());
	}

	/**
	 * Wrapper to simply remove a sample node from the bus.
	 * @param {SampleNode} sampleNode `SampleNode` to remove
	 * @returns {void}
	 */
	removeSampleNode(sampleNode) {
		this._sampleNodes.delete(sampleNode);
		sampleNode.getOutputNode().disconnect();
	}

	/**
	 * Wrapper to simply connect to another bus.
	 * @param {Bus} bus
	 * @returns {void}
	 */
	connect(bus) {
		if (bus == null) {
			throw new Error("cannot connect to null bus");
		}
		this.getOutputNode().disconnect();
		this.getOutputNode().connect(bus.getInputNode());
		return bus;
	}

	/**
	 * Clears the current bus.
	 * @returns {void}
	 */
	clear() {
		GodotAudio.buses = GodotAudio.buses.filter((v) => v !== this);
	}

	_syncSampleNodes() {
		const sampleNodes = Array.from(this._sampleNodes);
		for (let i = 0; i < sampleNodes.length; i++) {
			const sampleNode = sampleNodes[i];
			sampleNode.getOutputNode().disconnect();
			sampleNode.getOutputNode().connect(this.getInputNode());
		}
	}

	/**
	 * Process to enable solo.
	 * @returns {void}
	 */
	_enableSolo() {
		this.isSolo = true;
		GodotAudio.busSolo = this;
		this._soloNode.gain.value = 1;
		const otherBuses = GodotAudio.buses.filter((otherBus) => otherBus !== this);
		for (let i = 0; i < otherBuses.length; i++) {
			const otherBus = otherBuses[i];
			otherBus._soloNode.gain.value = 0;
		}
	}

	/**
	 * Process to disable solo.
	 * @returns {void}
	 */
	_disableSolo() {
		this.isSolo = false;
		GodotAudio.busSolo = null;
		this._soloNode.gain.value = 1;
		const otherBuses = GodotAudio.buses.filter((otherBus) => otherBus !== this);
		for (let i = 0; i < otherBuses.length; i++) {
			const otherBus = otherBuses[i];
			otherBus._soloNode.gain.value = 1;
		}
	}
}

const _GodotAudio = {
	$GodotAudio__deps: ["$GodotRuntime", "$GodotOS"],
	$GodotAudio: {
		/**
		 * Max number of volume channels.
		 */
		MAX_VOLUME_CHANNELS: 8,

		/**
		 * Represents the index of each sound channel relative to the engine.
		 */
		GodotChannel: Object.freeze({
			CHANNEL_L: 0,
			CHANNEL_R: 1,
			CHANNEL_C: 3,
			CHANNEL_LFE: 4,
			CHANNEL_RL: 5,
			CHANNEL_RR: 6,
			CHANNEL_SL: 7,
			CHANNEL_SR: 8,
		}),

		/**
		 * Represents the index of each sound channel relative to the Web Audio API.
		 */
		WebChannel: Object.freeze({
			CHANNEL_L: 0,
			CHANNEL_R: 1,
			CHANNEL_SL: 2,
			CHANNEL_SR: 3,
			CHANNEL_C: 4,
			CHANNEL_LFE: 5,
		}),

		// `Sample` class
		/**
		 * Registry of `Sample`s.
		 * @type {Map<string, Sample>}
		 */
		samples: null,
		Sample,

		// `SampleNodeBus` class
		SampleNodeBus,

		// `SampleNode` class
		/**
		 * Registry of `SampleNode`s.
		 * @type {Map<string, SampleNode>}
		 */
		sampleNodes: null,
		SampleNode,
		deleteSampleNode: (pSampleNodeId) => {
			GodotAudio.sampleNodes.delete(pSampleNodeId);
			if (GodotAudio.sampleFinishedCallback == null) {
				return;
			}
			const sampleNodeIdPtr = GodotRuntime.allocString(pSampleNodeId);
			GodotAudio.sampleFinishedCallback(sampleNodeIdPtr);
			GodotRuntime.free(sampleNodeIdPtr);
		},

		// `Bus` class
		/**
		 * Registry of `Bus`es.
		 * @type {Array<Bus>}
		 */
		buses: null,
		/**
		 * Reference to the current bus in solo mode.
		 * @type {Bus | null}
		 */
		busSolo: null,
		Bus,

		/**
		 * Callback to signal that a sample has finished.
		 * @type {(playbackObjectIdPtr: number) => void | null}
		 */
		sampleFinishedCallback: null,

		/** @type {AudioContext} */
		ctx: null,
		input: null,
		driver: null,
		interval: 0,

		/** @type {Promise} */
		audioPositionWorkletPromise: null,
		/** @type {Array<AudioWorkletNode>} */
		audioPositionWorkletNodes: null,

		/**
		 * Converts linear volume to Db.
		 * @param {number} linear Linear value to convert.
		 * @returns {number}
		 */
		linear_to_db: function (linear) {
			// eslint-disable-next-line no-loss-of-precision
			return Math.log(linear) * 8.6858896380650365530225783783321;
		},
		/**
		 * Converts Db volume to linear.
		 * @param {number} db Db value to convert.
		 * @returns {number}
		 */
		db_to_linear: function (db) {
			// eslint-disable-next-line no-loss-of-precision
			return Math.exp(db * 0.11512925464970228420089957273422);
		},

		init: function (mix_rate, latency, onstatechange, onlatencyupdate) {
			// Initialize classes static values.
			GodotAudio.samples = new Map();
			GodotAudio.sampleNodes = new Map();
			GodotAudio.buses = [];
			GodotAudio.busSolo = null;
			GodotAudio.audioPositionWorkletNodes = [];

			const opts = {};
			// If mix_rate is 0, let the browser choose.
			if (mix_rate) {
				GodotAudio.sampleRate = mix_rate;
				opts["sampleRate"] = mix_rate;
			}
			// Do not specify, leave 'interactive' for good performance.
			// opts['latencyHint'] = latency / 1000;
			const ctx = GODOTSDK.audio.WEBAudio.audioContext;
			GodotAudio.ctx = ctx;
			ctx.onstatechange = function () {
				let state = 0;
				switch (ctx.state) {
					case "suspended":
						state = 0;
						break;
					case "running":
						state = 1;
						break;
					case "closed":
						state = 2;
						break;
					default:
					// Do nothing.
				}
				onstatechange(state);
			};
			ctx.onstatechange(); // Immediately notify state.
			// Update computed latency
			GodotAudio.interval = setInterval(function () {
				let computed_latency = 0;
				if (ctx.baseLatency) {
					computed_latency += GodotAudio.ctx.baseLatency;
				}
				if (ctx.outputLatency) {
					computed_latency += GodotAudio.ctx.outputLatency;
				}
				onlatencyupdate(computed_latency);
			}, 1000);
			GodotOS.atexit(GodotAudio.close_async);

			// const path = GodotConfig.locate_file('godot.audio.position.worklet.js');
			// GodotAudio.audioPositionWorkletPromise = ctx.audioWorklet.addModule(path);

			// Initialize WeChat audio adapter
			GodotAudio.WX.init();

			return ctx.destination.channelCount;
		},

		create_input: function (callback) {
			if (GodotAudio.input) {
				return 0; // Already started.
			}
			function gotMediaInput(stream) {
				try {
					GodotAudio.input = GodotAudio.ctx.createMediaStreamSource(stream);
					callback(GodotAudio.input);
				} catch (e) {
					GodotRuntime.error("Failed creating input.", e);
				}
			}
			if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
				navigator.mediaDevices
					.getUserMedia({
						audio: true,
					})
					.then(gotMediaInput, function (e) {
						GodotRuntime.error("Error getting user media.", e);
					});
			} else {
				if (!navigator.getUserMedia) {
					navigator.getUserMedia = navigator.webkitGetUserMedia || navigator.mozGetUserMedia;
				}
				if (!navigator.getUserMedia) {
					GodotRuntime.error("getUserMedia not available.");
					return 1;
				}
				navigator.getUserMedia(
					{
						audio: true,
					},
					gotMediaInput,
					function (e) {
						GodotRuntime.print(e);
					}
				);
			}
			return 0;
		},

		close_async: function (resolve, reject) {
			const ctx = GodotAudio.ctx;
			GodotAudio.ctx = null;
			// Audio was not initialized.
			if (!ctx) {
				resolve();
				return;
			}
			// Remove latency callback
			if (GodotAudio.interval) {
				clearInterval(GodotAudio.interval);
				GodotAudio.interval = 0;
			}
			// Disconnect input, if it was started.
			if (GodotAudio.input) {
				GodotAudio.input.disconnect();
				GodotAudio.input = null;
			}
			// Disconnect output
			let closed = Promise.resolve();
			if (GodotAudio.driver) {
				closed = GodotAudio.driver.close();
			}
			closed
				.then(function () {
					return ctx.close();
				})
				.then(function () {
					ctx.onstatechange = null;
					resolve();
				})
				.catch(function (e) {
					ctx.onstatechange = null;
					GodotRuntime.error("Error closing AudioContext", e);
					resolve();
				});
		},

		/**
		 * WeChat Mini Game Audio Adapter
		 * Uses InnerAudioContext API for native audio playback
		 */
		WX: {
			DEBUG: false,
			MAX_POOL_SIZE: 16,
			DEFAULT_CACHE_LIMIT_BYTES: 8 * 1024 * 1024,
			DEFAULT_NATIVE_MIN_DURATION_SECONDS: 3,
			nativeStreams: null,
			activePlaybacks: null,
			contextPool: null,
			busVolumes: null,
			busMutes: null,
			subpackageLoads: null,
			manifest: null,
			fs: null,
			cacheDir: "",
			cacheIndexPath: "",
			cacheRecords: null,
			cacheRefs: null,
			cacheLocks: null,
			invalidCacheHashes: null,
			cacheHashStreams: null,
			cacheBytes: 0,
			cacheLimitBytes: 0,
			tempCounter: 0,

			getRoot: function () {
				if (typeof GameGlobal !== "undefined") {
					return GameGlobal;
				}
				if (typeof globalThis !== "undefined") {
					return globalThis;
				}
				return {};
			},

			init: function () {
				if (typeof wx === "undefined") {
					return;
				}

				const configuredLimit = Number(
					GodotAudio.WX.getRoot().__godotMinigameNativeAudioCacheLimitBytes
				);
				GodotAudio.WX.cacheLimitBytes =
					Number.isFinite(configuredLimit) && configuredLimit > 0
						? Math.floor(configuredLimit)
						: GodotAudio.WX.DEFAULT_CACHE_LIMIT_BYTES;
				GodotAudio.WX.nativeStreams = new Map();
				GodotAudio.WX.activePlaybacks = new Map();
				GodotAudio.WX.contextPool = [];
				GodotAudio.WX.busVolumes = new Map();
				GodotAudio.WX.busMutes = new Map();
				GodotAudio.WX.subpackageLoads = new Map();
				GodotAudio.WX.cacheRecords = new Map();
				GodotAudio.WX.cacheRefs = new Map();
				GodotAudio.WX.cacheLocks = new Set();
				GodotAudio.WX.invalidCacheHashes = new Set();
				GodotAudio.WX.cacheHashStreams = new Map();
				GodotAudio.WX.cacheBytes = 0;
				GodotAudio.WX.tempCounter = 0;
				GodotAudio.WX.fs = wx.getFileSystemManager();
				GodotAudio.WX.cacheDir = `${wx.env.USER_DATA_PATH}/godot_native_audio`;
				GodotAudio.WX.cacheIndexPath = `${GodotAudio.WX.cacheDir}/index.json`;
				GodotAudio.WX.manifest =
					GodotAudio.WX.getRoot().__godotMinigameNativeAudioManifest || {};

				GodotAudio.WX.initializeCache();
				GodotAudio.WX.cleanupLegacyAudioFiles();
				GodotAudio.WX.getRoot().GodotAudioDebug = {
					setDebug: (enabled) => {
						GodotAudio.WX.DEBUG = Boolean(enabled);
					},
					getStats: () => ({
						streams: GodotAudio.WX.nativeStreams.size,
						activePlaybacks: GodotAudio.WX.activePlaybacks.size,
						pooledContexts: GodotAudio.WX.contextPool.length,
						cacheBytes: GodotAudio.WX.cacheBytes,
						cacheLimitBytes: GodotAudio.WX.cacheLimitBytes,
						cacheEntries: GodotAudio.WX.cacheRecords.size,
					}),
					listStreams: () => Array.from(GodotAudio.WX.nativeStreams.entries()),
					listCache: () => Array.from(GodotAudio.WX.cacheRecords.values()),
				};
			},

			log: function (message) {
				if (GodotAudio.WX.DEBUG) {
					console.log(`[GodotAudioWX] ${message}`);
				}
			},

			error: function (message, error) {
				console.error(`[GodotAudioWX] ${message}`, error || "");
			},

			getNativeMinDuration: function () {
				const configured = Number(
					GodotAudio.WX.getRoot().__godotMinigameNativeAudioMinDurationSeconds
				);
				return Number.isFinite(configured) && configured >= 0
					? configured
					: GodotAudio.WX.DEFAULT_NATIVE_MIN_DURATION_SECONDS;
			},

			fileExists: function (path) {
				try {
					GodotAudio.WX.fs.statSync(path);
					return true;
				} catch (e) {
					return false;
				}
			},

			directoryExists: function (path) {
				try {
					const stat = GodotAudio.WX.fs.statSync(path);
					return typeof stat.isDirectory !== "function" || stat.isDirectory();
				} catch (e) {
					return false;
				}
			},

			safeUnlink: function (path) {
				try {
					if (GodotAudio.WX.fileExists(path)) {
						GodotAudio.WX.fs.unlinkSync(path);
					}
				} catch (e) {
					GodotAudio.WX.error(`Failed to remove ${path}`, e);
				}
			},

			cleanupLegacyAudioFiles: function () {
				try {
					GodotAudio.WX.fs.readdirSync(wx.env.USER_DATA_PATH).forEach((file) => {
						if (file.startsWith("godot_audio_") && file.endsWith(".wav")) {
							GodotAudio.WX.safeUnlink(`${wx.env.USER_DATA_PATH}/${file}`);
						}
					});
				} catch (e) {
					GodotAudio.WX.error("Failed to clean legacy audio files", e);
				}
			},

			initializeCache: function () {
				if (!GodotAudio.WX.directoryExists(GodotAudio.WX.cacheDir)) {
					try {
						GodotAudio.WX.fs.mkdirSync(GodotAudio.WX.cacheDir, true);
					} catch (e) {
						if (!GodotAudio.WX.directoryExists(GodotAudio.WX.cacheDir)) {
							GodotAudio.WX.error("Failed to create native audio cache", e);
							return;
						}
					}
				}

				const backupPath = `${GodotAudio.WX.cacheIndexPath}.bak`;
				if (
					!GodotAudio.WX.fileExists(GodotAudio.WX.cacheIndexPath) &&
					GodotAudio.WX.fileExists(backupPath)
				) {
					try {
						GodotAudio.WX.fs.renameSync(backupPath, GodotAudio.WX.cacheIndexPath);
					} catch (e) {
						GodotAudio.WX.error("Failed to restore audio cache index", e);
					}
				}

				let indexedEntries = {};
				try {
					if (GodotAudio.WX.fileExists(GodotAudio.WX.cacheIndexPath)) {
						const parsed = JSON.parse(
							GodotAudio.WX.fs.readFileSync(GodotAudio.WX.cacheIndexPath, "utf8")
						);
						indexedEntries =
							parsed && parsed.entries && typeof parsed.entries === "object"
								? parsed.entries
								: {};
					}
				} catch (e) {
					GodotAudio.WX.error("Audio cache index is invalid; rebuilding it", e);
				}

				let files = [];
				try {
					files = GodotAudio.WX.fs.readdirSync(GodotAudio.WX.cacheDir);
				} catch (e) {
					GodotAudio.WX.error("Failed to list native audio cache", e);
				}
				const liveFiles = new Set();
				files.forEach((file) => {
					if (file.endsWith(".tmp") || file === "index.json.bak") {
						GodotAudio.WX.safeUnlink(`${GodotAudio.WX.cacheDir}/${file}`);
					} else if (file !== "index.json") {
						liveFiles.add(file);
					}
				});

				Object.keys(indexedEntries).forEach((hash) => {
					const entry = indexedEntries[hash];
					if (!/^[0-9a-f]{64}$/.test(hash) || !entry || typeof entry.file !== "string") {
						return;
					}
					const path = `${GodotAudio.WX.cacheDir}/${entry.file}`;
					if (!liveFiles.has(entry.file)) {
						return;
					}
					try {
						const stat = GodotAudio.WX.fs.statSync(path);
						if (Number(entry.size) !== Number(stat.size)) {
							GodotAudio.WX.safeUnlink(path);
							liveFiles.delete(entry.file);
							return;
						}
						const codec = entry.file.includes(".") ? entry.file.split(".").pop() : "bin";
						GodotAudio.WX.cacheRecords.set(hash, {
							hash,
							file: entry.file,
							path,
							size: Number(stat.size),
							lastAccess: Number(entry.lastAccess) || 0,
							codec: String(entry.codec || codec),
						});
						GodotAudio.WX.cacheBytes += Number(stat.size);
						liveFiles.delete(entry.file);
					} catch (e) {
						GodotAudio.WX.safeUnlink(path);
					}
				});

				liveFiles.forEach((file) => {
					const match = /^([0-9a-f]{64})\.([a-z0-9]+)$/.exec(file);
					const path = `${GodotAudio.WX.cacheDir}/${file}`;
					if (!match) {
						GodotAudio.WX.safeUnlink(path);
						return;
					}
					try {
						const stat = GodotAudio.WX.fs.statSync(path);
						GodotAudio.WX.cacheRecords.set(match[1], {
							hash: match[1],
							file,
							path,
							size: Number(stat.size),
							lastAccess: 0,
							codec: match[2],
						});
						GodotAudio.WX.cacheBytes += Number(stat.size);
					} catch (e) {
						GodotAudio.WX.safeUnlink(path);
					}
				});

				GodotAudio.WX.evictFor(0, "");
				GodotAudio.WX.persistCacheIndex();
			},

			persistCacheIndex: function () {
				const entries = {};
				GodotAudio.WX.cacheRecords.forEach((entry, hash) => {
					entries[hash] = {
						file: entry.file,
						size: entry.size,
						lastAccess: entry.lastAccess,
						codec: entry.codec,
					};
				});
				const tempPath = `${GodotAudio.WX.cacheIndexPath}.${Date.now()}.${GodotAudio.WX.tempCounter++}.tmp`;
				const backupPath = `${GodotAudio.WX.cacheIndexPath}.bak`;
				try {
					GodotAudio.WX.fs.writeFileSync(
						tempPath,
						JSON.stringify({ version: 1, entries }),
						"utf8"
					);
					GodotAudio.WX.safeUnlink(backupPath);
					if (GodotAudio.WX.fileExists(GodotAudio.WX.cacheIndexPath)) {
						GodotAudio.WX.fs.renameSync(GodotAudio.WX.cacheIndexPath, backupPath);
					}
					GodotAudio.WX.fs.renameSync(tempPath, GodotAudio.WX.cacheIndexPath);
					GodotAudio.WX.safeUnlink(backupPath);
				} catch (e) {
					GodotAudio.WX.safeUnlink(tempPath);
					if (
						!GodotAudio.WX.fileExists(GodotAudio.WX.cacheIndexPath) &&
						GodotAudio.WX.fileExists(backupPath)
					) {
						try {
							GodotAudio.WX.fs.renameSync(backupPath, GodotAudio.WX.cacheIndexPath);
						} catch (restoreError) {
							GodotAudio.WX.error("Failed to restore audio cache index", restoreError);
						}
					}
					GodotAudio.WX.error("Failed to persist audio cache index", e);
				}
			},

			removeCacheRecord: function (hash) {
				const entry = GodotAudio.WX.cacheRecords.get(hash);
				if (!entry) {
					GodotAudio.WX.invalidCacheHashes.delete(hash);
					return;
				}
				GodotAudio.WX.safeUnlink(entry.path);
				GodotAudio.WX.cacheRecords.delete(hash);
				GodotAudio.WX.invalidCacheHashes.delete(hash);
				GodotAudio.WX.cacheBytes = Math.max(0, GodotAudio.WX.cacheBytes - entry.size);
				const streamIds = GodotAudio.WX.cacheHashStreams.get(hash);
				if (streamIds) {
					streamIds.forEach((streamId) => GodotAudio.WX.nativeStreams.delete(streamId));
					GodotAudio.WX.cacheHashStreams.delete(hash);
				}
			},

			invalidateCacheRecord: function (hash) {
				if (!GodotAudio.WX.cacheRecords.has(hash)) {
					GodotAudio.WX.invalidCacheHashes.delete(hash);
					return;
				}
				if ((GodotAudio.WX.cacheRefs.get(hash) || 0) > 0) {
					GodotAudio.WX.invalidCacheHashes.add(hash);
					return;
				}
				GodotAudio.WX.removeCacheRecord(hash);
				GodotAudio.WX.persistCacheIndex();
			},

			evictFor: function (incomingSize, protectedHash) {
				if (incomingSize > GodotAudio.WX.cacheLimitBytes) {
					return false;
				}
				const candidates = Array.from(GodotAudio.WX.cacheRecords.values())
					.filter(
						(entry) =>
							entry.hash !== protectedHash &&
							(GodotAudio.WX.cacheRefs.get(entry.hash) || 0) === 0 &&
							!GodotAudio.WX.cacheLocks.has(entry.hash)
					)
					.sort((a, b) => a.lastAccess - b.lastAccess);

				for (const entry of candidates) {
					if (GodotAudio.WX.cacheBytes + incomingSize <= GodotAudio.WX.cacheLimitBytes) {
						break;
					}
					GodotAudio.WX.removeCacheRecord(entry.hash);
				}
				return GodotAudio.WX.cacheBytes + incomingSize <= GodotAudio.WX.cacheLimitBytes;
			},

			materializeCacheFile: function (hash, codec, data) {
				const existing = GodotAudio.WX.cacheRecords.get(hash);
				if (
					existing &&
					!GodotAudio.WX.invalidCacheHashes.has(hash) &&
					GodotAudio.WX.fileExists(existing.path)
				) {
					existing.lastAccess = Date.now();
					GodotAudio.WX.persistCacheIndex();
					return existing.path;
				}
				if (existing) {
					GodotAudio.WX.invalidateCacheRecord(hash);
					if (GodotAudio.WX.cacheRecords.has(hash)) {
						return "";
					}
				}

				const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
				if (!GodotAudio.WX.evictFor(bytes.byteLength, hash)) {
					GodotAudio.WX.error(
						`Native audio needs ${bytes.byteLength} bytes, exceeding the ${GodotAudio.WX.cacheLimitBytes}-byte cache limit. Increase it explicitly or export this file into a package.`
					);
					return "";
				}

				const safeCodec = String(codec || "bin")
					.toLowerCase()
					.replace(/[^a-z0-9]/g, "");
				const file = `${hash}.${safeCodec}`;
				const targetPath = `${GodotAudio.WX.cacheDir}/${file}`;
				const tempPath = `${GodotAudio.WX.cacheDir}/.${hash}.${Date.now()}.${GodotAudio.WX.tempCounter++}.tmp`;
				GodotAudio.WX.cacheLocks.add(hash);
				try {
					const buffer = bytes.buffer.slice(
						bytes.byteOffset,
						bytes.byteOffset + bytes.byteLength
					);
					GodotAudio.WX.fs.writeFileSync(tempPath, buffer, "binary");
					const stat = GodotAudio.WX.fs.statSync(tempPath);
					if (Number(stat.size) !== bytes.byteLength) {
						throw new Error(`short write: expected ${bytes.byteLength}, got ${stat.size}`);
					}
					if (GodotAudio.WX.fileExists(targetPath)) {
						GodotAudio.WX.safeUnlink(tempPath);
					} else {
						GodotAudio.WX.fs.renameSync(tempPath, targetPath);
					}
					const targetStat = GodotAudio.WX.fs.statSync(targetPath);
					const entry = {
						hash,
						file,
						path: targetPath,
						size: Number(targetStat.size),
						lastAccess: Date.now(),
						codec: safeCodec,
					};
					GodotAudio.WX.cacheRecords.set(hash, entry);
					GodotAudio.WX.cacheBytes += entry.size;
					GodotAudio.WX.persistCacheIndex();
					return targetPath;
				} catch (e) {
					GodotAudio.WX.safeUnlink(tempPath);
					GodotAudio.WX.error(`Failed to cache native audio ${hash}`, e);
					return "";
				} finally {
					GodotAudio.WX.cacheLocks.delete(hash);
				}
			},

			trackCacheStream: function (hash, streamObjectId) {
				let streamIds = GodotAudio.WX.cacheHashStreams.get(hash);
				if (!streamIds) {
					streamIds = new Set();
					GodotAudio.WX.cacheHashStreams.set(hash, streamIds);
				}
				streamIds.add(streamObjectId);
			},

			acquireCache: function (hash) {
				const entry = GodotAudio.WX.cacheRecords.get(hash);
				if (!entry || !GodotAudio.WX.fileExists(entry.path)) {
					GodotAudio.WX.removeCacheRecord(hash);
					GodotAudio.WX.persistCacheIndex();
					return false;
				}
				if (GodotAudio.WX.invalidCacheHashes.has(hash)) {
					GodotAudio.WX.invalidateCacheRecord(hash);
					return false;
				}
				GodotAudio.WX.cacheRefs.set(hash, (GodotAudio.WX.cacheRefs.get(hash) || 0) + 1);
				entry.lastAccess = Date.now();
				GodotAudio.WX.persistCacheIndex();
				return true;
			},

			releaseCache: function (hash) {
				const refs = GodotAudio.WX.cacheRefs.get(hash) || 0;
				if (refs <= 1) {
					GodotAudio.WX.cacheRefs.delete(hash);
					if (GodotAudio.WX.invalidCacheHashes.has(hash)) {
						GodotAudio.WX.removeCacheRecord(hash);
						GodotAudio.WX.persistCacheIndex();
					}
				} else {
					GodotAudio.WX.cacheRefs.set(hash, refs - 1);
				}
			},

			resolveManifestAsset: function (sourcePath, sourceUid, contentHash) {
				const manifest = GodotAudio.WX.manifest || {};
				const aliases =
					manifest.aliases && typeof manifest.aliases === "object" ? manifest.aliases : {};
				const assets =
					manifest.assets && typeof manifest.assets === "object" ? manifest.assets : {};
				const candidates = [contentHash, aliases[sourceUid], aliases[sourcePath]].filter(Boolean);
				for (const hash of candidates) {
					const asset = assets[hash];
					if (asset && typeof asset.src === "string" && asset.src.length > 0) {
						return {
							kind: "package",
							hash,
							path: asset.src,
							subpackage: String(asset.subpackage || ""),
							codec: String(asset.codec || ""),
						};
					}
				}
				return null;
			},

			encodeWAV: function (leftChannel, rightChannel, sampleRate) {
				const length = leftChannel.length + rightChannel.length;
				const buffer = new ArrayBuffer(44 + length * 2);
				const view = new DataView(buffer);
				const writeString = (offset, value) => {
					for (let i = 0; i < value.length; i++) {
						view.setUint8(offset + i, value.charCodeAt(i));
					}
				};
				writeString(0, "RIFF");
				view.setUint32(4, 36 + length * 2, true);
				writeString(8, "WAVE");
				writeString(12, "fmt ");
				view.setUint32(16, 16, true);
				view.setUint16(20, 1, true);
				view.setUint16(22, 2, true);
				view.setUint32(24, sampleRate, true);
				view.setUint32(28, sampleRate * 4, true);
				view.setUint16(32, 4, true);
				view.setUint16(34, 16, true);
				writeString(36, "data");
				view.setUint32(40, length * 2, true);
				let offset = 44;
				for (let i = 0; i < leftChannel.length; i++) {
					view.setInt16(offset, Math.max(-1, Math.min(1, leftChannel[i])) * 0x7fff, true);
					offset += 2;
					view.setInt16(offset, Math.max(-1, Math.min(1, rightChannel[i])) * 0x7fff, true);
					offset += 2;
				}
				return buffer;
			},

			registerNativeStream: function (
				streamObjectId,
				sourcePath,
				sourceUid,
				contentHash,
				dataPtr,
				dataSize,
				codec,
				loopMode,
				framesTotal,
				sampleRate
			) {
				if (GodotAudio.WX.nativeStreams.has(streamObjectId)) {
					return;
				}

				const packaged = GodotAudio.WX.resolveManifestAsset(
					sourcePath,
					sourceUid,
					contentHash
				);
				if (packaged) {
					packaged.loopMode = loopMode;
					GodotAudio.WX.nativeStreams.set(streamObjectId, packaged);
					return;
				}

				if (!dataPtr || dataSize <= 0 || !/^[0-9a-f]{64}$/.test(contentHash)) {
					GodotAudio.WX.error(
						`No packaged source or valid cache content for ${sourceUid || sourcePath || streamObjectId}`
					);
					return;
				}

				let audioBytes;
				let outputCodec = String(codec || "").toLowerCase();
				if (outputCodec === "pcm_f32_planar") {
					const expectedWavSize = 44 + framesTotal * 4;
					if (expectedWavSize > GodotAudio.WX.cacheLimitBytes) {
						GodotAudio.WX.error(
							`Decoded WAV fallback needs ${expectedWavSize} bytes, exceeding the ${GodotAudio.WX.cacheLimitBytes}-byte native audio cache limit. Export this audio into a package or increase the limit explicitly.`
						);
						return;
					}
					const left = new Float32Array(
						GodotRuntime.heapSub(HEAPF32, dataPtr, framesTotal)
					);
					const right = new Float32Array(
						GodotRuntime.heapSub(HEAPF32, dataPtr + framesTotal * 4, framesTotal)
					);
					audioBytes = new Uint8Array(
						GodotAudio.WX.encodeWAV(left, right, sampleRate)
					);
					outputCodec = "wav";
				} else {
					audioBytes = new Uint8Array(
						GodotRuntime.heapSlice(HEAPU8, dataPtr, dataSize)
					);
				}

				const path = GodotAudio.WX.materializeCacheFile(
					contentHash,
					outputCodec,
					audioBytes
				);
				if (!path) {
					return;
				}
				GodotAudio.WX.nativeStreams.set(streamObjectId, {
					kind: "cache",
					hash: contentHash,
					path,
					codec: outputCodec,
					loopMode,
				});
				GodotAudio.WX.trackCacheStream(contentHash, streamObjectId);
			},

			isStreamRegistered: function (streamObjectId) {
				const streamInfo =
					GodotAudio.WX.nativeStreams && GodotAudio.WX.nativeStreams.get(streamObjectId);
				if (!streamInfo) {
					return false;
				}
				if (streamInfo.kind === "cache" && !GodotAudio.WX.fileExists(streamInfo.path)) {
					GodotAudio.WX.nativeStreams.delete(streamObjectId);
					return false;
				}
				return true;
			},

			unregisterStream: function (streamObjectId) {
				const streamInfo =
					GodotAudio.WX.nativeStreams && GodotAudio.WX.nativeStreams.get(streamObjectId);
				if (!streamInfo) {
					return false;
				}
				GodotAudio.WX.nativeStreams.delete(streamObjectId);
				if (streamInfo.kind === "cache") {
					const streamIds = GodotAudio.WX.cacheHashStreams.get(streamInfo.hash);
					if (streamIds) {
						streamIds.delete(streamObjectId);
						if (streamIds.size === 0) {
							GodotAudio.WX.cacheHashStreams.delete(streamInfo.hash);
						}
					}
				}
				return true;
			},

			ensureSubpackage: function (name) {
				if (!name) {
					return Promise.resolve();
				}
				const existing = GodotAudio.WX.subpackageLoads.get(name);
				if (existing) {
					return existing;
				}
				const loading = new Promise((resolve, reject) => {
					if (typeof wx.loadSubpackage !== "function") {
						reject(new Error("wx.loadSubpackage is unavailable"));
						return;
					}
					wx.loadSubpackage({ name, success: resolve, fail: reject });
				});
				GodotAudio.WX.subpackageLoads.set(name, loading);
				loading.catch(() => GodotAudio.WX.subpackageLoads.delete(name));
				return loading;
			},

			dbToLinear: function (db) {
				return Math.exp(db * 0.11512925464970228);
			},

			calculateFinalVolume: function (baseVolume, busIndex) {
				if (GodotAudio.WX.busMutes.get(busIndex) || false) {
					return 0;
				}
				const busVolumeDb = GodotAudio.WX.busVolumes.get(busIndex) || 0;
				return Math.max(
					0,
					Math.min(1, baseVolume * GodotAudio.WX.dbToLinear(busVolumeDb))
				);
			},

			getContext: function (desiredSrc) {
				if (desiredSrc) {
					const matchingIndex = GodotAudio.WX.contextPool.findIndex(
						(ctx) => ctx.src === desiredSrc
					);
					if (matchingIndex !== -1) {
						const ctx = GodotAudio.WX.contextPool[matchingIndex];
						GodotAudio.WX.contextPool.splice(matchingIndex, 1);
						return ctx;
					}
				}
				return wx.createInnerAudioContext();
			},

			resetContext: function (ctx) {
				ctx.offCanplay();
				ctx.offPlay();
				ctx.offPause();
				ctx.offStop();
				ctx.offEnded();
				ctx.offTimeUpdate();
				ctx.offError();
				ctx.offWaiting();
				ctx.offSeeking();
				ctx.offSeeked();
				ctx.autoplay = false;
				ctx.loop = false;
				ctx.volume = 1;
				ctx.playbackRate = 1;
				ctx.startTime = 0;
			},

			destroyContext: function (ctx) {
				if (!ctx) {
					return;
				}
				try {
					GodotAudio.WX.resetContext(ctx);
					ctx.stop();
				} catch (e) {
					// Ignore teardown errors from already released contexts.
				}
				if (typeof ctx.destroy === "function") {
					ctx.destroy();
				}
			},

			releaseContext: function (ctx) {
				if (!ctx) {
					return;
				}
				GodotAudio.WX.resetContext(ctx);
				if (GodotAudio.WX.contextPool.length >= GodotAudio.WX.MAX_POOL_SIZE) {
					GodotAudio.WX.destroyContext(ctx);
					return;
				}
				GodotAudio.WX.contextPool.push(ctx);
			},

			notifyFinished: function (playbackObjectId) {
				if (!GodotAudio.sampleFinishedCallback) {
					return;
				}
				const playbackIdPtr = GodotRuntime.allocString(playbackObjectId);
				GodotAudio.sampleFinishedCallback(playbackIdPtr);
				GodotRuntime.free(playbackIdPtr);
			},

			cleanupPlayback: function (playbackObjectId, ctx, destroy) {
				const playback = GodotAudio.WX.activePlaybacks.get(playbackObjectId);
				if (!playback || (ctx && playback.ctx !== ctx)) {
					return false;
				}
				GodotAudio.WX.activePlaybacks.delete(playbackObjectId);
				playback.cancelled = true;
				if (playback.hashRef) {
					GodotAudio.WX.releaseCache(playback.streamInfo.hash);
					playback.hashRef = false;
				}
				if (playback.ctx) {
					if (destroy) {
						GodotAudio.WX.destroyContext(playback.ctx);
					} else {
						GodotAudio.WX.releaseContext(playback.ctx);
					}
				}
				return true;
			},

			startSample: function (
				playbackObjectId,
				streamObjectId,
				busIndex,
				offset,
				pitchScale,
				volumePtr
			) {
				const streamInfo = GodotAudio.WX.nativeStreams.get(streamObjectId);
				if (!streamInfo) {
					GodotAudio.WX.error(`Native stream ${streamObjectId} is not registered`);
					return;
				}
				GodotAudio.WX.stopSample(playbackObjectId);
				const volume = GodotRuntime.heapSub(HEAPF32, volumePtr, 8);
				const playback = {
					ctx: null,
					streamInfo,
					busIndex,
					baseVolume: Math.max(volume[0], volume[1]),
					cancelled: false,
					hashRef: false,
				};
				if (streamInfo.kind === "cache") {
					if (!GodotAudio.WX.acquireCache(streamInfo.hash)) {
						GodotAudio.WX.notifyFinished(playbackObjectId);
						return;
					}
					playback.hashRef = true;
				}
				GodotAudio.WX.activePlaybacks.set(playbackObjectId, playback);

				const beginPlayback = () => {
					if (
						playback.cancelled ||
						GodotAudio.WX.activePlaybacks.get(playbackObjectId) !== playback
					) {
						return;
					}
					const ctx = GodotAudio.WX.getContext(streamInfo.path);
					playback.ctx = ctx;
					GodotAudio.WX.resetContext(ctx);
					if (ctx.src !== streamInfo.path) {
						ctx.src = streamInfo.path;
					}
					ctx.volume = GodotAudio.WX.calculateFinalVolume(
						playback.baseVolume,
						busIndex
					);
					ctx.playbackRate = Math.max(0.5, Math.min(2, pitchScale));
					ctx.loop = streamInfo.loopMode === "forward";
					ctx.startTime = offset > 0 ? offset : 0;
					ctx.onEnded(() => {
						if (GodotAudio.WX.cleanupPlayback(playbackObjectId, ctx, false)) {
							GodotAudio.WX.notifyFinished(playbackObjectId);
						}
					});
					ctx.onStop(() => {
						if (GodotAudio.WX.cleanupPlayback(playbackObjectId, ctx, false)) {
							GodotAudio.WX.notifyFinished(playbackObjectId);
						}
					});
					ctx.onError((error) => {
						GodotAudio.WX.error(`Playback error for ${playbackObjectId}`, error);
						const cleaned = GodotAudio.WX.cleanupPlayback(playbackObjectId, ctx, true);
						if (cleaned && streamInfo.kind === "cache") {
							GodotAudio.WX.invalidateCacheRecord(streamInfo.hash);
						}
						if (cleaned) {
							GodotAudio.WX.notifyFinished(playbackObjectId);
						}
					});
					try {
						ctx.play();
					} catch (error) {
						GodotAudio.WX.error(`Playback start failed for ${playbackObjectId}`, error);
						const cleaned = GodotAudio.WX.cleanupPlayback(playbackObjectId, ctx, true);
						if (cleaned && streamInfo.kind === "cache") {
							GodotAudio.WX.invalidateCacheRecord(streamInfo.hash);
						}
						if (cleaned) {
							GodotAudio.WX.notifyFinished(playbackObjectId);
						}
					}
				};

				GodotAudio.WX.ensureSubpackage(streamInfo.subpackage)
					.then(beginPlayback)
					.catch((error) => {
						GodotAudio.WX.error(
							`Failed to load audio subpackage ${streamInfo.subpackage}`,
							error
						);
						if (GodotAudio.WX.cleanupPlayback(playbackObjectId, null, false)) {
							GodotAudio.WX.notifyFinished(playbackObjectId);
						}
					});
			},

			stopSample: function (playbackObjectId) {
				const playback = GodotAudio.WX.activePlaybacks.get(playbackObjectId);
				if (!playback) {
					return false;
				}
				GodotAudio.WX.activePlaybacks.delete(playbackObjectId);
				playback.cancelled = true;
				if (playback.hashRef) {
					GodotAudio.WX.releaseCache(playback.streamInfo.hash);
					playback.hashRef = false;
				}
				if (playback.ctx) {
					playback.ctx.stop();
					GodotAudio.WX.releaseContext(playback.ctx);
				}
				return true;
			},

			setPause: function (playbackObjectId, paused) {
				const playback = GodotAudio.WX.activePlaybacks.get(playbackObjectId);
				if (!playback) {
					return false;
				}
				if (playback.ctx) {
					if (paused) {
						playback.ctx.pause();
					} else {
						playback.ctx.play();
					}
				}
				return true;
			},

			isActive: function (playbackObjectId) {
				return GodotAudio.WX.activePlaybacks.has(playbackObjectId);
			},

			getPosition: function (playbackObjectId) {
				const playback = GodotAudio.WX.activePlaybacks.get(playbackObjectId);
				return playback && playback.ctx ? playback.ctx.currentTime : 0;
			},

			updatePitchScale: function (playbackObjectId, pitchScale) {
				const playback = GodotAudio.WX.activePlaybacks.get(playbackObjectId);
				if (!playback) {
					return false;
				}
				if (playback.ctx) {
					playback.ctx.playbackRate = Math.max(0.5, Math.min(2, pitchScale));
				}
				return true;
			},

			updateVolume: function (playbackObjectId, volumePtr) {
				const playback = GodotAudio.WX.activePlaybacks.get(playbackObjectId);
				if (!playback) {
					return false;
				}
				const volume = GodotRuntime.heapSub(HEAPF32, volumePtr, 8);
				playback.baseVolume = Math.max(volume[0], volume[1]);
				if (playback.ctx) {
					playback.ctx.volume = GodotAudio.WX.calculateFinalVolume(
						playback.baseVolume,
						playback.busIndex
					);
				}
				return true;
			},

			setBusVolume: function (busIndex, volumeDb) {
				GodotAudio.WX.busVolumes.set(busIndex, volumeDb);
				GodotAudio.WX.activePlaybacks.forEach((playback) => {
					if (playback.busIndex === busIndex && playback.ctx) {
						playback.ctx.volume = GodotAudio.WX.calculateFinalVolume(
							playback.baseVolume,
							busIndex
						);
					}
				});
			},

			setBusMute: function (busIndex, enabled) {
				GodotAudio.WX.busMutes.set(busIndex, enabled);
				GodotAudio.WX.activePlaybacks.forEach((playback) => {
					if (playback.busIndex === busIndex && playback.ctx) {
						playback.ctx.volume = GodotAudio.WX.calculateFinalVolume(
							playback.baseVolume,
							busIndex
						);
					}
				});
			},
		},

		/**
		 * Triggered when a sample node needs to start.
		 * @param {string} playbackObjectId The unique id of the sample playback
		 * @param {string} streamObjectId The unique id of the stream
		 * @param {number} busIndex Index of the bus currently binded to the sample playback
		 * @param {SampleNodeOptions | undefined} startOptions Optional params.
		 * @returns {void}
		 */
		start_sample: function (playbackObjectId, streamObjectId, busIndex, startOptions) {
			GodotAudio.SampleNode.stopSampleNode(playbackObjectId);
			GodotAudio.SampleNode.create(
				{
					busIndex,
					id: playbackObjectId,
					streamObjectId,
				},
				startOptions
			);
		},

		/**
		 * Triggered when a sample node needs to be stopped.
		 * @param {string} playbackObjectId Id of the sample playback
		 * @returns {void}
		 */
		stop_sample: function (playbackObjectId) {
			GodotAudio.SampleNode.stopSampleNode(playbackObjectId);
		},

		/**
		 * Triggered when a sample node needs to be paused or unpaused.
		 * @param {string} playbackObjectId Id of the sample playback
		 * @param {boolean} pause State of the pause
		 * @returns {void}
		 */
		sample_set_pause: function (playbackObjectId, pause) {
			GodotAudio.SampleNode.pauseSampleNode(playbackObjectId, pause);
		},

		/**
		 * Triggered when a sample node needs its pitch scale to be updated.
		 * @param {string} playbackObjectId Id of the sample playback
		 * @param {number} pitchScale Pitch scale of the sample playback
		 * @returns {void}
		 */
		update_sample_pitch_scale: function (playbackObjectId, pitchScale) {
			const sampleNode = GodotAudio.SampleNode.getSampleNodeOrNull(playbackObjectId);
			if (sampleNode == null) {
				return;
			}
			sampleNode.setPitchScale(pitchScale);
		},

		/**
		 * Triggered when a sample node volumes need to be updated.
		 * @param {string} playbackObjectId Id of the sample playback
		 * @param {Array<number>} busIndexes Indexes of the buses that need to be updated
		 * @param {Float32Array} volumes Array of the volumes
		 * @returns {void}
		 */
		sample_set_volumes_linear: function (playbackObjectId, busIndexes, volumes) {
			const sampleNode = GodotAudio.SampleNode.getSampleNodeOrNull(playbackObjectId);
			if (sampleNode == null) {
				return;
			}
			const buses = busIndexes.map((busIndex) => GodotAudio.Bus.getBus(busIndex));
			sampleNode.setVolumes(buses, volumes);
		},

		/**
		 * Triggered when the bus count changes.
		 * @param {number} count Number of buses
		 * @returns {void}
		 */
		set_sample_bus_count: function (count) {
			GodotAudio.Bus.setCount(count);
		},

		/**
		 * Triggered when a bus needs to be removed.
		 * @param {number} index Bus index
		 * @returns {void}
		 */
		remove_sample_bus: function (index) {
			const bus = GodotAudio.Bus.getBusOrNull(index);
			if (bus == null) {
				return;
			}
			bus.clear();
		},

		/**
		 * Triggered when a bus needs to be at the desired position.
		 * @param {number} atPos Position to add the bus
		 * @returns {void}
		 */
		add_sample_bus: function (atPos) {
			GodotAudio.Bus.addAt(atPos);
		},

		/**
		 * Triggered when a bus needs to be moved.
		 * @param {number} busIndex Index of the bus to move
		 * @param {number} toPos Index of the new position of the bus
		 * @returns {void}
		 */
		move_sample_bus: function (busIndex, toPos) {
			GodotAudio.Bus.move(busIndex, toPos);
		},

		/**
		 * Triggered when the "send" value of a bus changes.
		 * @param {number} busIndex Index of the bus to update the "send" value
		 * @param {number} sendIndex Index of the bus that is the new "send"
		 * @returns {void}
		 */
		set_sample_bus_send: function (busIndex, sendIndex) {
			const bus = GodotAudio.Bus.getBusOrNull(busIndex);
			if (bus == null) {
				// Cannot send from an invalid bus.
				return;
			}
			let targetBus = GodotAudio.Bus.getBusOrNull(sendIndex);
			if (targetBus == null) {
				// Send to master.
				targetBus = GodotAudio.Bus.getBus(0);
			}
			bus.setSend(targetBus);
		},

		/**
		 * Triggered when a bus needs its volume db to be updated.
		 * @param {number} busIndex Index of the bus to update its volume db
		 * @param {number} volumeDb Volume of the bus
		 * @returns {void}
		 */
		set_sample_bus_volume_db: function (busIndex, volumeDb) {
			const bus = GodotAudio.Bus.getBusOrNull(busIndex);
			if (bus == null) {
				return;
			}
			bus.setVolumeDb(volumeDb);
		},

		/**
		 * Triggered when a bus needs to update its solo status
		 * @param {number} busIndex Index of the bus to update its solo status
		 * @param {boolean} enable Status of the solo
		 * @returns {void}
		 */
		set_sample_bus_solo: function (busIndex, enable) {
			const bus = GodotAudio.Bus.getBusOrNull(busIndex);
			if (bus == null) {
				return;
			}
			bus.solo(enable);
		},

		/**
		 * Triggered when a bus needs to update its mute status
		 * @param {number} busIndex Index of the bus to update its mute status
		 * @param {boolean} enable Status of the mute
		 * @returns {void}
		 */
		set_sample_bus_mute: function (busIndex, enable) {
			const bus = GodotAudio.Bus.getBusOrNull(busIndex);
			if (bus == null) {
				return;
			}
			bus.mute(enable);
		},
	},

	godot_audio_is_available__sig: "i",
	godot_audio_is_available__proxy: "sync",
	godot_audio_is_available: function () {
		// if (!(window.AudioContext || window.webkitAudioContext)) {
		// 	return 0;
		// }
		return 1;
	},

	godot_audio_has_worklet__proxy: "sync",
	godot_audio_has_worklet__sig: "i",
	godot_audio_has_worklet: function () {
		// WeChat Mini Game does not support AudioWorklet.
		return 0;
	},

	godot_audio_has_script_processor__proxy: "sync",
	godot_audio_has_script_processor__sig: "i",
	godot_audio_has_script_processor: function () {
		// return GodotAudio.ctx && GodotAudio.ctx.createScriptProcessor ? 1 : 0;
		return 1;
	},

	godot_audio_init__proxy: "sync",
	godot_audio_init__sig: "iiiii",
	godot_audio_init: function (p_mix_rate, p_latency, p_state_change, p_latency_update) {
		const statechange = GodotRuntime.get_func(p_state_change);
		const latencyupdate = GodotRuntime.get_func(p_latency_update);
		const mix_rate = GodotRuntime.getHeapValue(p_mix_rate, "i32");
		const channels = GodotAudio.init(mix_rate, p_latency, statechange, latencyupdate);
		GodotRuntime.setHeapValue(p_mix_rate, GodotAudio.ctx.sampleRate, "i32");
		return channels;
	},

	godot_audio_resume__proxy: "sync",
	godot_audio_resume__sig: "v",
	godot_audio_resume: function () {
		if (GodotAudio.ctx && GodotAudio.ctx.state !== "running") {
			GodotAudio.ctx.resume();
		}
	},

	godot_audio_input_start__proxy: "sync",
	godot_audio_input_start__sig: "i",
	godot_audio_input_start: function () {
		return GodotAudio.create_input(function (input) {
			input.connect(GodotAudio.driver.get_node());
		});
	},

	godot_audio_input_stop__proxy: "sync",
	godot_audio_input_stop__sig: "v",
	godot_audio_input_stop: function () {
		if (GodotAudio.input) {
			const tracks = GodotAudio.input["mediaStream"]["getTracks"]();
			for (let i = 0; i < tracks.length; i++) {
				tracks[i]["stop"]();
			}
			GodotAudio.input.disconnect();
			GodotAudio.input = null;
		}
	},

	godot_audio_wechat_is_available__proxy: "sync",
	godot_audio_wechat_is_available__sig: "i",
	godot_audio_wechat_is_available: function () {
		return Number(typeof wx !== "undefined");
	},

	godot_audio_wechat_get_native_audio_min_duration__proxy: "sync",
	godot_audio_wechat_get_native_audio_min_duration__sig: "d",
	godot_audio_wechat_get_native_audio_min_duration: function () {
		return typeof wx !== "undefined"
			? GodotAudio.WX.getNativeMinDuration()
			: Number.POSITIVE_INFINITY;
	},

	godot_audio_wechat_can_cache_pcm__proxy: "sync",
	godot_audio_wechat_can_cache_pcm__sig: "ii",
	godot_audio_wechat_can_cache_pcm: function (framesTotal) {
		return Number(
			typeof wx !== "undefined" &&
				44 + framesTotal * 4 <= GodotAudio.WX.cacheLimitBytes
		);
	},

	godot_audio_sample_stream_is_registered__proxy: "sync",
	godot_audio_sample_stream_is_registered__sig: "ii",
	/**
	 * Returns if the sample stream is registered
	 * @param {number} streamObjectIdStrPtr Pointer of the streamObjectId
	 * @returns {number}
	 */
	godot_audio_sample_stream_is_registered: function (streamObjectIdStrPtr) {
		const streamObjectId = GodotRuntime.parseString(streamObjectIdStrPtr);
		if (typeof wx !== "undefined" && GodotAudio.WX.isStreamRegistered(streamObjectId)) {
			return 1;
		}
		return Number(GodotAudio.Sample.getSampleOrNull(streamObjectId) != null);
	},

	godot_audio_sample_register_native_stream__proxy: "sync",
	godot_audio_sample_register_native_stream__sig: "viiiiiiiiii",
	godot_audio_sample_register_native_stream: function (
		streamObjectIdStrPtr,
		sourcePathStrPtr,
		sourceUidStrPtr,
		contentHashStrPtr,
		dataPtr,
		dataSize,
		codecStrPtr,
		loopModeStrPtr,
		framesTotal,
		sampleRate
	) {
		if (typeof wx === "undefined") {
			return;
		}
		GodotAudio.WX.registerNativeStream(
			GodotRuntime.parseString(streamObjectIdStrPtr),
			GodotRuntime.parseString(sourcePathStrPtr),
			GodotRuntime.parseString(sourceUidStrPtr),
			GodotRuntime.parseString(contentHashStrPtr),
			dataPtr,
			dataSize,
			GodotRuntime.parseString(codecStrPtr),
			GodotRuntime.parseString(loopModeStrPtr),
			framesTotal,
			sampleRate
		);
	},

	godot_audio_sample_register_stream__proxy: "sync",
	godot_audio_sample_register_stream__sig: "viiiiiii",
	/**
	 * Registers a stream.
	 * @param {number} streamObjectIdStrPtr StreamObjectId pointer
	 * @param {number} framesPtr Frames pointer
	 * @param {number} framesTotal Frames total value
	 * @param {number} loopModeStrPtr Loop mode pointer
	 * @param {number} loopBegin Loop begin value
	 * @param {number} loopEnd Loop end value
	 * @returns {void}
	 */
	godot_audio_sample_register_stream: function (
		streamObjectIdStrPtr,
		framesPtr,
		framesTotal,
		loopModeStrPtr,
		loopBegin,
		loopEnd
	) {
		const streamObjectId = GodotRuntime.parseString(streamObjectIdStrPtr);
		const loopMode = GodotRuntime.parseString(loopModeStrPtr);

		// Short samples use Web Audio on every web runtime, including WeChat.
		const BYTES_PER_FLOAT32 = 4;
		const numberOfChannels = 2;
		const sampleRate = GodotAudio.ctx.sampleRate;

		/** @type {Float32Array} */
		const subLeft = GodotRuntime.heapSub(HEAPF32, framesPtr, framesTotal);
		/** @type {Float32Array} */
		const subRight = GodotRuntime.heapSub(HEAPF32, framesPtr + framesTotal * BYTES_PER_FLOAT32, framesTotal);

		const audioBuffer = GodotAudio.ctx.createBuffer(numberOfChannels, framesTotal, sampleRate);
		audioBuffer.copyToChannel(new Float32Array(subLeft), 0, 0);
		audioBuffer.copyToChannel(new Float32Array(subRight), 1, 0);

		GodotAudio.Sample.create(
			{
				id: streamObjectId,
				audioBuffer,
			},
			{
				loopBegin,
				loopEnd,
				loopMode,
				numberOfChannels,
				sampleRate,
			}
		);
	},

	godot_audio_sample_unregister_stream__proxy: "sync",
	godot_audio_sample_unregister_stream__sig: "vi",
	/**
	 * Unregisters a stream.
	 * @param {number} streamObjectIdStrPtr StreamObjectId pointer
	 * @returns {void}
	 */
	godot_audio_sample_unregister_stream: function (streamObjectIdStrPtr) {
		const streamObjectId = GodotRuntime.parseString(streamObjectIdStrPtr);

		if (typeof wx !== "undefined" && GodotAudio.WX.unregisterStream(streamObjectId)) {
			return;
		}

		// Fallback to Web Audio API
		const sample = GodotAudio.Sample.getSampleOrNull(streamObjectId);
		if (sample != null) {
			sample.clear();
		}
	},

	godot_audio_sample_start__proxy: "sync",
	godot_audio_sample_start__sig: "viiiifi",
	/**
	 * Starts a sample.
	 * @param {number} playbackObjectIdStrPtr Playback object id pointer
	 * @param {number} streamObjectIdStrPtr Stream object id pointer
	 * @param {number} busIndex Bus index
	 * @param {number} offset Sample offset
	 * @param {number} pitchScale Pitch scale
	 * @param {number} volumePtr Volume pointer
	 * @returns {void}
	 */
	godot_audio_sample_start: function (
		playbackObjectIdStrPtr,
		streamObjectIdStrPtr,
		busIndex,
		offset,
		pitchScale,
		volumePtr
	) {
		/** @type {string} */
		const playbackObjectId = GodotRuntime.parseString(playbackObjectIdStrPtr);
		/** @type {string} */
		const streamObjectId = GodotRuntime.parseString(streamObjectIdStrPtr);

		if (typeof wx !== "undefined" && GodotAudio.WX.isStreamRegistered(streamObjectId)) {
			GodotAudio.WX.startSample(playbackObjectId, streamObjectId, busIndex, offset, pitchScale, volumePtr);
			return;
		}

		// Fallback to Web Audio API
		/** @type {Float32Array} */
		const volume = GodotRuntime.heapSub(HEAPF32, volumePtr, 8);
		/** @type {SampleNodeOptions} */
		const startOptions = {
			offset,
			volume,
			playbackRate: 1,
			pitchScale,
			start: true,
		};
		GodotAudio.start_sample(playbackObjectId, streamObjectId, busIndex, startOptions);
	},

	godot_audio_sample_stop__proxy: "sync",
	godot_audio_sample_stop__sig: "vi",
	/**
	 * Stops a sample from playing.
	 * @param {number} playbackObjectIdStrPtr Playback object id pointer
	 * @returns {void}
	 */
	godot_audio_sample_stop: function (playbackObjectIdStrPtr) {
		const playbackObjectId = GodotRuntime.parseString(playbackObjectIdStrPtr);

		if (typeof wx !== "undefined" && GodotAudio.WX.stopSample(playbackObjectId)) {
			return;
		}

		// Fallback to Web Audio API
		GodotAudio.stop_sample(playbackObjectId);
	},

	godot_audio_sample_set_pause__proxy: "sync",
	godot_audio_sample_set_pause__sig: "vii",
	/**
	 * Sets the pause state of a sample.
	 * @param {number} playbackObjectIdStrPtr Playback object id pointer
	 * @param {number} pause Pause state
	 */
	godot_audio_sample_set_pause: function (playbackObjectIdStrPtr, pause) {
		const playbackObjectId = GodotRuntime.parseString(playbackObjectIdStrPtr);

		if (typeof wx !== "undefined" && GodotAudio.WX.setPause(playbackObjectId, Boolean(pause))) {
			return;
		}

		// Fallback to Web Audio API
		GodotAudio.sample_set_pause(playbackObjectId, Boolean(pause));
	},

	godot_audio_sample_is_active__proxy: "sync",
	godot_audio_sample_is_active__sig: "ii",
	/**
	 * Returns if the sample is active.
	 * @param {number} playbackObjectIdStrPtr Playback object id pointer
	 * @returns {number}
	 */
	godot_audio_sample_is_active: function (playbackObjectIdStrPtr) {
		const playbackObjectId = GodotRuntime.parseString(playbackObjectIdStrPtr);

		if (typeof wx !== "undefined" && GodotAudio.WX.isActive(playbackObjectId)) {
			return Number(GodotAudio.WX.isActive(playbackObjectId));
		}

		// Fallback to Web Audio API
		return Number(GodotAudio.sampleNodes.has(playbackObjectId));
	},

	godot_audio_get_sample_playback_position__proxy: "sync",
	godot_audio_get_sample_playback_position__sig: "di",
	/**
	 * Returns the position of the playback position.
	 * @param {number} playbackObjectIdStrPtr Playback object id pointer
	 * @returns {number}
	 */
	godot_audio_get_sample_playback_position: function (playbackObjectIdStrPtr) {
		const playbackObjectId = GodotRuntime.parseString(playbackObjectIdStrPtr);

		if (typeof wx !== "undefined" && GodotAudio.WX.isActive(playbackObjectId)) {
			return GodotAudio.WX.getPosition(playbackObjectId);
		}

		// Fallback to Web Audio API
		const sampleNode = GodotAudio.SampleNode.getSampleNodeOrNull(playbackObjectId);
		if (sampleNode == null) {
			return 0;
		}
		return sampleNode.getPlaybackPosition();
	},

	godot_audio_sample_update_pitch_scale__proxy: "sync",
	godot_audio_sample_update_pitch_scale__sig: "vii",
	/**
	 * Updates the pitch scale of a sample.
	 * @param {number} playbackObjectIdStrPtr Playback object id pointer
	 * @param {number} pitchScale Pitch scale value
	 * @returns {void}
	 */
	godot_audio_sample_update_pitch_scale: function (playbackObjectIdStrPtr, pitchScale) {
		const playbackObjectId = GodotRuntime.parseString(playbackObjectIdStrPtr);

		if (
			typeof wx !== "undefined" &&
			GodotAudio.WX.updatePitchScale(playbackObjectId, pitchScale)
		) {
			return;
		}

		// Fallback to Web Audio API
		GodotAudio.update_sample_pitch_scale(playbackObjectId, pitchScale);
	},

	godot_audio_sample_set_volumes_linear__proxy: "sync",
	godot_audio_sample_set_volumes_linear__sig: "vii",
	/**
	 * Sets the volumes linear of each mentioned bus for the sample.
	 * @param {number} playbackObjectIdStrPtr Playback object id pointer
	 * @param {number} busesPtr Buses array pointer
	 * @param {number} busesSize Buses array size
	 * @param {number} volumesPtr Volumes array pointer
	 * @param {number} volumesSize Volumes array size
	 * @returns {void}
	 */
	godot_audio_sample_set_volumes_linear: function (
		playbackObjectIdStrPtr,
		busesPtr,
		busesSize,
		volumesPtr,
		volumesSize
	) {
		/** @type {string} */
		const playbackObjectId = GodotRuntime.parseString(playbackObjectIdStrPtr);

		if (typeof wx !== "undefined" && GodotAudio.WX.updateVolume(playbackObjectId, volumesPtr)) {
			return;
		}

		// Fallback to Web Audio API
		/** @type {Uint32Array} */
		const buses = GodotRuntime.heapSub(HEAP32, busesPtr, busesSize);
		/** @type {Float32Array} */
		const volumes = GodotRuntime.heapSub(HEAPF32, volumesPtr, volumesSize);

		GodotAudio.sample_set_volumes_linear(playbackObjectId, Array.from(buses), volumes);
	},

	godot_audio_sample_bus_set_count__proxy: "sync",
	godot_audio_sample_bus_set_count__sig: "vi",
	/**
	 * Sets the bus count.
	 * @param {number} count Bus count
	 * @returns {void}
	 */
	godot_audio_sample_bus_set_count: function (count) {
		GodotAudio.set_sample_bus_count(count);
	},

	godot_audio_sample_bus_remove__proxy: "sync",
	godot_audio_sample_bus_remove__sig: "vi",
	/**
	 * Removes a bus.
	 * @param {number} index Index of the bus to remove
	 * @returns {void}
	 */
	godot_audio_sample_bus_remove: function (index) {
		GodotAudio.remove_sample_bus(index);
	},

	godot_audio_sample_bus_add__proxy: "sync",
	godot_audio_sample_bus_add__sig: "vi",
	/**
	 * Adds a bus at the defined position.
	 * @param {number} atPos Position to add the bus
	 * @returns {void}
	 */
	godot_audio_sample_bus_add: function (atPos) {
		GodotAudio.add_sample_bus(atPos);
	},

	godot_audio_sample_bus_move__proxy: "sync",
	godot_audio_sample_bus_move__sig: "vii",
	/**
	 * Moves the bus from a position to another.
	 * @param {number} fromPos Position of the bus to move
	 * @param {number} toPos Final position of the bus
	 * @returns {void}
	 */
	godot_audio_sample_bus_move: function (fromPos, toPos) {
		GodotAudio.move_sample_bus(fromPos, toPos);
	},

	godot_audio_sample_bus_set_send__proxy: "sync",
	godot_audio_sample_bus_set_send__sig: "vii",
	/**
	 * Sets the "send" of a bus.
	 * @param {number} bus Position of the bus to set the send
	 * @param {number} sendIndex Position of the "send" bus
	 * @returns {void}
	 */
	godot_audio_sample_bus_set_send: function (bus, sendIndex) {
		GodotAudio.set_sample_bus_send(bus, sendIndex);
	},

	godot_audio_sample_bus_set_volume_db__proxy: "sync",
	godot_audio_sample_bus_set_volume_db__sig: "vii",
	/**
	 * Sets the volume db of a bus.
	 * @param {number} bus Position of the bus to set the volume db
	 * @param {number} volumeDb Volume db to set
	 * @returns {void}
	 */
	godot_audio_sample_bus_set_volume_db: function (bus, volumeDb) {
		if (typeof wx !== "undefined") {
			GodotAudio.WX.setBusVolume(bus, volumeDb);
		}
		GodotAudio.set_sample_bus_volume_db(bus, volumeDb);
	},

	godot_audio_sample_bus_set_solo__proxy: "sync",
	godot_audio_sample_bus_set_solo__sig: "vii",
	/**
	 * Sets the state of solo for a bus
	 * @param {number} bus Position of the bus to set the solo state
	 * @param {number} enable State of the solo
	 * @returns {void}
	 */
	godot_audio_sample_bus_set_solo: function (bus, enable) {
		GodotAudio.set_sample_bus_solo(bus, Boolean(enable));
	},

	godot_audio_sample_bus_set_mute__proxy: "sync",
	godot_audio_sample_bus_set_mute__sig: "vii",
	/**
	 * Sets the state of mute for a bus
	 * @param {number} bus Position of the bus to set the mute state
	 * @param {number} enable State of the mute
	 * @returns {void}
	 */
	godot_audio_sample_bus_set_mute: function (bus, enable) {
		if (typeof wx !== "undefined") {
			GodotAudio.WX.setBusMute(bus, Boolean(enable));
		}
		GodotAudio.set_sample_bus_mute(bus, Boolean(enable));
	},

	godot_audio_sample_set_finished_callback__proxy: "sync",
	godot_audio_sample_set_finished_callback__sig: "vi",
	/**
	 * Sets the finished callback
	 * @param {Number} callbackPtr Finished callback pointer
	 * @returns {void}
	 */
	godot_audio_sample_set_finished_callback: function (callbackPtr) {
		GodotAudio.sampleFinishedCallback = GodotRuntime.get_func(callbackPtr);
	},
};

autoAddDeps(_GodotAudio, "$GodotAudio");
mergeInto(LibraryManager.library, _GodotAudio);

/**
 * The AudioWorklet API driver, used when threads are available.
 */
const GodotAudioWorklet = {
	$GodotAudioWorklet__deps: ["$GodotAudio", "$GodotConfig"],
	$GodotAudioWorklet: {
		promise: null,
		worklet: null,
		ring_buffer: null,

		create: function (channels) {
			// const path = GodotConfig.locate_file('godot.audio.worklet.js');
			// GodotAudioWorklet.promise = GodotAudio.ctx.audioWorklet
			// 	.addModule(path)
			// 	.then(function () {
			// 		GodotAudioWorklet.worklet = new AudioWorkletNode(
			// 			GodotAudio.ctx,
			// 			'godot-processor',
			// 			{
			// 				outputChannelCount: [channels],
			// 			}
			// 		);
			// 		return Promise.resolve();
			// 	});
			// GodotAudio.driver = GodotAudioWorklet;
		},

		start: function (in_buf, out_buf, state) {
			GodotAudioWorklet.promise.then(function () {
				const node = GodotAudioWorklet.worklet;
				node.connect(GodotAudio.ctx.destination);
				node.port.postMessage({
					cmd: "start",
					data: [state, in_buf, out_buf],
				});
				node.port.onmessage = function (event) {
					GodotRuntime.error(event.data);
				};
			});
		},

		start_no_threads: function (p_out_buf, p_out_size, out_callback, p_in_buf, p_in_size, in_callback) {
			function RingBuffer() {
				let wpos = 0;
				let rpos = 0;
				let pending_samples = 0;
				const wbuf = new Float32Array(p_out_size);

				function send(port) {
					if (pending_samples === 0) {
						return;
					}
					const buffer = GodotRuntime.heapSub(HEAPF32, p_out_buf, p_out_size);
					const size = buffer.length;
					const tot_sent = pending_samples;
					out_callback(wpos, pending_samples);
					if (wpos + pending_samples >= size) {
						const high = size - wpos;
						wbuf.set(buffer.subarray(wpos, size));
						pending_samples -= high;
						wpos = 0;
					}
					if (pending_samples > 0) {
						wbuf.set(buffer.subarray(wpos, wpos + pending_samples), tot_sent - pending_samples);
					}
					port.postMessage({
						cmd: "chunk",
						data: wbuf.subarray(0, tot_sent),
					});
					wpos += pending_samples;
					pending_samples = 0;
				}
				this.receive = function (recv_buf) {
					const buffer = GodotRuntime.heapSub(HEAPF32, p_in_buf, p_in_size);
					const from = rpos;
					let to_write = recv_buf.length;
					let high = 0;
					if (rpos + to_write >= p_in_size) {
						high = p_in_size - rpos;
						buffer.set(recv_buf.subarray(0, high), rpos);
						to_write -= high;
						rpos = 0;
					}
					if (to_write) {
						buffer.set(recv_buf.subarray(high, to_write), rpos);
					}
					in_callback(from, recv_buf.length);
					rpos += to_write;
				};
				this.consumed = function (size, port) {
					pending_samples += size;
					send(port);
				};
			}
			GodotAudioWorklet.ring_buffer = new RingBuffer();
			GodotAudioWorklet.promise.then(function () {
				const node = GodotAudioWorklet.worklet;
				const buffer = GodotRuntime.heapSlice(HEAPF32, p_out_buf, p_out_size);
				node.connect(GodotAudio.ctx.destination);
				node.port.postMessage({
					cmd: "start_nothreads",
					data: [buffer, p_in_size],
				});
				node.port.onmessage = function (event) {
					if (!GodotAudioWorklet.worklet) {
						return;
					}
					if (event.data["cmd"] === "read") {
						const read = event.data["data"];
						GodotAudioWorklet.ring_buffer.consumed(read, GodotAudioWorklet.worklet.port);
					} else if (event.data["cmd"] === "input") {
						const buf = event.data["data"];
						if (buf.length > p_in_size) {
							GodotRuntime.error("Input chunk is too big");
							return;
						}
						GodotAudioWorklet.ring_buffer.receive(buf);
					} else {
						GodotRuntime.error(event.data);
					}
				};
			});
		},

		get_node: function () {
			return GodotAudioWorklet.worklet;
		},

		close: function () {
			return new Promise(function (resolve, reject) {
				if (GodotAudioWorklet.promise === null) {
					return;
				}
				const p = GodotAudioWorklet.promise;
				p.then(function () {
					GodotAudioWorklet.worklet.port.postMessage({
						cmd: "stop",
						data: null,
					});
					GodotAudioWorklet.worklet.disconnect();
					GodotAudioWorklet.worklet.port.onmessage = null;
					GodotAudioWorklet.worklet = null;
					GodotAudioWorklet.promise = null;
					resolve();
				}).catch(function (err) {
					// Aborted?
					GodotRuntime.error(err);
				});
			});
		},
	},

	godot_audio_worklet_create__proxy: "sync",
	godot_audio_worklet_create__sig: "ii",
	godot_audio_worklet_create: function (channels) {
		// try {
		// 	GodotAudioWorklet.create(channels);
		// } catch (e) {
		// 	GodotRuntime.error('Error starting AudioDriverWorklet', e);
		// 	return 1;
		// }
		return 0;
	},

	godot_audio_worklet_start__proxy: "sync",
	godot_audio_worklet_start__sig: "viiiii",
	godot_audio_worklet_start: function (p_in_buf, p_in_size, p_out_buf, p_out_size, p_state) {
		const out_buffer = GodotRuntime.heapSub(HEAPF32, p_out_buf, p_out_size);
		const in_buffer = GodotRuntime.heapSub(HEAPF32, p_in_buf, p_in_size);
		const state = GodotRuntime.heapSub(HEAP32, p_state, 4);
		GodotAudioWorklet.start(in_buffer, out_buffer, state);
	},

	godot_audio_worklet_start_no_threads__proxy: "sync",
	godot_audio_worklet_start_no_threads__sig: "viiiiii",
	godot_audio_worklet_start_no_threads: function (
		p_out_buf,
		p_out_size,
		p_out_callback,
		p_in_buf,
		p_in_size,
		p_in_callback
	) {
		const out_callback = GodotRuntime.get_func(p_out_callback);
		const in_callback = GodotRuntime.get_func(p_in_callback);
		GodotAudioWorklet.start_no_threads(p_out_buf, p_out_size, out_callback, p_in_buf, p_in_size, in_callback);
	},

	godot_audio_worklet_state_wait__sig: "iiii",
	godot_audio_worklet_state_wait: function (p_state, p_idx, p_expected, p_timeout) {
		Atomics.wait(HEAP32, (p_state >> 2) + p_idx, p_expected, p_timeout);
		return Atomics.load(HEAP32, (p_state >> 2) + p_idx);
	},

	godot_audio_worklet_state_add__sig: "iiii",
	godot_audio_worklet_state_add: function (p_state, p_idx, p_value) {
		return Atomics.add(HEAP32, (p_state >> 2) + p_idx, p_value);
	},

	godot_audio_worklet_state_get__sig: "iii",
	godot_audio_worklet_state_get: function (p_state, p_idx) {
		return Atomics.load(HEAP32, (p_state >> 2) + p_idx);
	},
};

autoAddDeps(GodotAudioWorklet, "$GodotAudioWorklet");
mergeInto(LibraryManager.library, GodotAudioWorklet);

/*
 * The ScriptProcessorNode API, used as a fallback if AudioWorklet is not available.
 */
const GodotAudioScript = {
	$GodotAudioScript__deps: ["$GodotAudio"],
	$GodotAudioScript: {
		script: null,

		create: function (buffer_length, channel_count) {
			GodotAudioScript.script = GodotAudio.ctx.createScriptProcessor(buffer_length, 2, channel_count);
			GodotAudio.driver = GodotAudioScript;
			return GodotAudioScript.script.bufferSize;
		},

		start: function (p_in_buf, p_in_size, p_out_buf, p_out_size, onprocess) {
			GodotAudioScript.script.onaudioprocess = function (event) {
				// Read input
				const inb = GodotRuntime.heapSub(HEAPF32, p_in_buf, p_in_size);
				const input = event.inputBuffer;
				if (GodotAudio.input) {
					const inlen = input.getChannelData(0).length;
					for (let ch = 0; ch < 2; ch++) {
						const data = input.getChannelData(ch);
						for (let s = 0; s < inlen; s++) {
							inb[s * 2 + ch] = data[s];
						}
					}
				}

				// Let Godot process the input/output.
				onprocess();

				// Write the output.
				const outb = GodotRuntime.heapSub(HEAPF32, p_out_buf, p_out_size);
				const output = event.outputBuffer;
				const channels = output.numberOfChannels;
				for (let ch = 0; ch < channels; ch++) {
					const data = output.getChannelData(ch);
					// Loop through samples and assign computed values.
					for (let sample = 0; sample < data.length; sample++) {
						data[sample] = outb[sample * channels + ch];
					}
				}
			};

			GodotAudioScript.script.connect(GodotAudio.ctx.destination);
		},

		get_node: function () {
			return GodotAudioScript.script;
		},

		close: function () {
			return new Promise(function (resolve, reject) {
				if (GodotAudioScript.script) {
					GodotAudioScript.script.disconnect();
					GodotAudioScript.script.onaudioprocess = null;
					GodotAudioScript.script = null;
				}
				resolve();
			});
		},
	},

	godot_audio_script_create__proxy: "sync",
	godot_audio_script_create__sig: "iii",
	godot_audio_script_create: function (buffer_length, channel_count) {
		const buf_len = GodotRuntime.getHeapValue(buffer_length, "i32");
		try {
			const out_len = GodotAudioScript.create(buf_len, channel_count);
			GodotRuntime.setHeapValue(buffer_length, out_len, "i32");
		} catch (e) {
			GodotRuntime.error("Error starting AudioDriverScriptProcessor", e);
			return 1;
		}
		return 0;
	},

	godot_audio_script_start__proxy: "sync",
	godot_audio_script_start__sig: "viiiii",
	godot_audio_script_start: function (p_in_buf, p_in_size, p_out_buf, p_out_size, p_cb) {
		const onprocess = GodotRuntime.get_func(p_cb);
		GodotAudioScript.start(p_in_buf, p_in_size, p_out_buf, p_out_size, onprocess);
	},
};

autoAddDeps(GodotAudioScript, "$GodotAudioScript");
mergeInto(LibraryManager.library, GodotAudioScript);
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 323kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 323kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 323kUpdated Claude CodeCodexVerifiedInstall