@cardstack/boxel-cli 0.13.0-unstable.4 → 0.13.0-unstable.6

package/bundled-test-harness/assets/audio-metadata-extractor-test-8JM6oZXG.js

@@ -0,0 +1,1176 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { lt as setupRenderingTest } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/unit/audio-metadata-extractor-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+function chunkedStream(bytes, chunkSize) {
+	let offset = 0;
+	return new ReadableStream({ pull(controller) {
+		if (offset >= bytes.length) {
+			controller.close();
+			return;
+		}
+		let end = Math.min(offset + chunkSize, bytes.length);
+		controller.enqueue(bytes.slice(offset, end));
+		offset = end;
+	} });
+}
+function ascii(text) {
+	return [...text].map((c) => c.charCodeAt(0));
+}
+function uint32le(value) {
+	return [
+		value & 255,
+		value >>> 8 & 255,
+		value >>> 16 & 255,
+		value >>> 24 & 255
+	];
+}
+function uint32be(value) {
+	return [
+		value >>> 24 & 255,
+		value >>> 16 & 255,
+		value >>> 8 & 255,
+		value & 255
+	];
+}
+function uint16le(value) {
+	return [value & 255, value >>> 8 & 255];
+}
+function riffChunk(id, body) {
+	let pad = body.length % 2 === 1 ? [0] : [];
+	return [
+		...ascii(id),
+		...uint32le(body.length),
+		...body,
+		...pad
+	];
+}
+function buildWav(fmt = {}, infoEntries = []) {
+	let channels = fmt.channels ?? 2;
+	let sampleRate = fmt.sampleRate ?? 44100;
+	let bitsPerSample = fmt.bitsPerSample ?? 16;
+	let byteRate = sampleRate * channels * bitsPerSample / 8;
+	let blockAlign = channels * bitsPerSample / 8;
+	let chunks = [...riffChunk("fmt ", [
+		...uint16le(fmt.formatCode ?? 1),
+		...uint16le(channels),
+		...uint32le(sampleRate),
+		...uint32le(byteRate),
+		...uint16le(blockAlign),
+		...uint16le(bitsPerSample)
+	])];
+	if (infoEntries.length > 0) {
+		let infoBody = [...ascii("INFO")];
+		for (let [id, value] of infoEntries) infoBody.push(...riffChunk(id, [...ascii(value), 0]));
+		chunks.push(...riffChunk("LIST", infoBody));
+	}
+	chunks.push(...riffChunk("data", new Array(64).fill(0)));
+	let payload = [...ascii("WAVE"), ...chunks];
+	return new Uint8Array([
+		...ascii("RIFF"),
+		...uint32le(payload.length),
+		...payload
+	]);
+}
+function buildFlac(streamInfo = {}, comments, seekPoints = 0) {
+	let sampleRate = streamInfo.sampleRate ?? 44100;
+	let channels = streamInfo.channels ?? 2;
+	let bitsPerSample = streamInfo.bitsPerSample ?? 16;
+	let block = new Array(34).fill(0);
+	block[10] = sampleRate >>> 12 & 255;
+	block[11] = sampleRate >>> 4 & 255;
+	block[12] = (sampleRate & 15) << 4 | (channels - 1 & 7) << 1 | bitsPerSample - 1 >>> 4 & 1;
+	block[13] = (bitsPerSample - 1 & 15) << 4 | 4;
+	block[14] = 0;
+	block[15] = 0;
+	block[16] = 172;
+	block[17] = 68;
+	let hasComments = comments !== void 0;
+	let out = [
+		...ascii("fLaC"),
+		hasComments ? 0 : 128,
+		0,
+		0,
+		34,
+		...block
+	];
+	if (seekPoints > 0) {
+		let length = seekPoints * 18;
+		out.push(3, length >>> 16 & 255, length >>> 8 & 255, length & 255, ...new Array(length).fill(0));
+	}
+	if (comments) {
+		let body = vorbisCommentBody(comments);
+		out.push(132, body.length >>> 16 & 255, body.length >>> 8 & 255, body.length & 255, ...body);
+	}
+	return new Uint8Array(out);
+}
+function vorbisCommentBody(entries) {
+	let vendor = ascii("test-vendor");
+	let out = [
+		...uint32le(vendor.length),
+		...vendor,
+		...uint32le(entries.length)
+	];
+	for (let [key, value] of entries) {
+		let entry = ascii(`${key}=${value}`);
+		out.push(...uint32le(entry.length), ...entry);
+	}
+	return out;
+}
+function buildOggPage(payload) {
+	return [
+		...ascii("OggS"),
+		0,
+		2,
+		...new Array(8).fill(0),
+		...uint32le(1),
+		...uint32le(0),
+		...uint32le(0),
+		1,
+		Math.min(payload.length, 255),
+		...payload
+	];
+}
+function buildOggVorbis(channels = 2, sampleRate = 44100, nominalBitrate = 128e3, comments) {
+	let out = buildOggPage([
+		1,
+		...ascii("vorbis"),
+		...uint32le(0),
+		channels,
+		...uint32le(sampleRate),
+		...uint32le(0),
+		...uint32le(nominalBitrate),
+		...uint32le(0),
+		0,
+		1
+	]);
+	if (comments) out.push(...buildOggPage([
+		3,
+		...ascii("vorbis"),
+		...vorbisCommentBody(comments)
+	]));
+	return new Uint8Array(out);
+}
+function buildOggOpus(channels = 2, comments) {
+	let out = buildOggPage([
+		...ascii("OpusHead"),
+		1,
+		channels,
+		...uint16le(312),
+		...uint32le(48e3),
+		...uint16le(0),
+		0
+	]);
+	if (comments) out.push(...buildOggPage([...ascii("OpusTags"), ...vorbisCommentBody(comments)]));
+	return new Uint8Array(out);
+}
+function syncsafe(value) {
+	return [
+		value >>> 21 & 127,
+		value >>> 14 & 127,
+		value >>> 7 & 127,
+		value & 127
+	];
+}
+function buildId3v2(frames, majorVersion = 3) {
+	let body = [];
+	let append = (values) => {
+		for (let value of values) body.push(value);
+	};
+	for (let [id, payload] of frames) {
+		append(ascii(id));
+		append(majorVersion >= 4 ? syncsafe(payload.length) : uint32be(payload.length));
+		append([0, 0]);
+		append(payload);
+	}
+	body.push(0, 0, 0, 0);
+	return new Uint8Array([
+		...ascii("ID3"),
+		majorVersion,
+		0,
+		0,
+		...syncsafe(body.length),
+		...body
+	]);
+}
+function latin1Frame(text) {
+	return [
+		0,
+		...ascii(text),
+		0
+	];
+}
+function buildMp3Frame(options = {}) {
+	let header = [
+		255,
+		251,
+		144,
+		64
+	];
+	let body = [];
+	if (options.withXing) body.push(...new Array(32).fill(0), ...ascii("Xing"), ...uint32be(1), ...uint32be(1e3));
+	return [
+		...header,
+		...body,
+		...new Array(64).fill(0)
+	];
+}
+(0, import_qunit.module)("Unit | audio metadata extractors", function(hooks) {
+	setupRenderingTest(hooks);
+	let loader;
+	let extractWavEncoding;
+	let extractWavTags;
+	let extractWavFromStream;
+	let extractFlacEncoding;
+	let extractFlacTags;
+	let FLAC_METADATA_WINDOW_BYTES;
+	let extractOggEncoding;
+	let extractOggTags;
+	let extractMp3Encoding;
+	let extractMp3Envelope;
+	let extractMp3EnvelopeFromStream;
+	let StreamingEnvelope;
+	let parseId3v2Tags;
+	let parseVorbisComments;
+	let analyzeDecodedAudio;
+	let decodeSkipReason;
+	let predictedDecodedBytes;
+	let extractAudioWaveform;
+	let audioAttributes;
+	let extractMidiMetadata;
+	hooks.beforeEach(async function() {
+		loader = getService("loader-service").loader;
+		({extractWavEncoding, extractWavTags, extractWavFromStream} = await loader.import("@cardstack/base/wav-meta-extractor"));
+		({extractFlacEncoding, extractFlacTags, FLAC_METADATA_WINDOW_BYTES} = await loader.import("@cardstack/base/flac-meta-extractor"));
+		({extractOggEncoding, extractOggTags} = await loader.import("@cardstack/base/ogg-meta-extractor"));
+		({extractMp3Encoding, extractMp3Envelope, extractMp3EnvelopeFromStream} = await loader.import("@cardstack/base/mp3-meta-extractor"));
+		({StreamingEnvelope} = await loader.import("@cardstack/base/streaming-envelope"));
+		({parseId3v2Tags} = await loader.import("@cardstack/base/id3v2-parser"));
+		({parseVorbisComments} = await loader.import("@cardstack/base/vorbis-comment-parser"));
+		({analyzeDecodedAudio, decodeSkipReason, predictedDecodedBytes, extractAudioWaveform} = await loader.import("@cardstack/base/audio-waveform"));
+		({audioAttributes} = await loader.import("@cardstack/base/audio-file-def"));
+		({extractMidiMetadata} = await loader.import("@cardstack/base/midi-meta-extractor"));
+	});
+	(0, import_qunit.module)("WAV", function() {
+		(0, import_qunit.test)("reads the sample layout the fmt chunk states outright", function(assert) {
+			let encoding = extractWavEncoding(buildWav({
+				channels: 2,
+				sampleRate: 48e3,
+				bitsPerSample: 24
+			}));
+			assert.strictEqual(encoding?.container, "WAV");
+			assert.strictEqual(encoding?.audioCodec, "PCM");
+			assert.strictEqual(encoding?.sampleRateHz, 48e3);
+			assert.strictEqual(encoding?.bitDepth, 24);
+			assert.strictEqual(encoding?.channels, 2);
+			assert.strictEqual(encoding?.channelMode, "stereo");
+			assert.false(encoding?.isVariableBitrate, "PCM is constant-rate by definition");
+			assert.strictEqual(encoding?.bitrateBps, 48e3 * 2 * 3 * 8);
+		});
+		(0, import_qunit.test)("names the float and companded format codes", function(assert) {
+			assert.strictEqual(extractWavEncoding(buildWav({ formatCode: 3 }))?.audioCodec, "IEEE float");
+			assert.strictEqual(extractWavEncoding(buildWav({ formatCode: 7 }))?.audioCodec, "μ-law");
+		});
+		(0, import_qunit.test)("leaves an unrecognized format code unnamed rather than guessing", function(assert) {
+			let encoding = extractWavEncoding(buildWav({ formatCode: 4660 }));
+			assert.strictEqual(encoding?.audioCodec, void 0);
+			assert.strictEqual(encoding?.sampleRateHz, 44100, "the layout still reads even when the codec does not");
+		});
+		(0, import_qunit.test)("reads a mono file as mono", function(assert) {
+			assert.strictEqual(extractWavEncoding(buildWav({ channels: 1 }))?.channelMode, "mono");
+		});
+		(0, import_qunit.test)("reads LIST-INFO tags", function(assert) {
+			let tags = extractWavTags(buildWav({}, [
+				["INAM", "Field Recording"],
+				["IART", "A Recordist"],
+				["ICRD", "2021-07-04"],
+				["IGNR", "Ambient"]
+			]));
+			assert.strictEqual(tags?.trackTitle, "Field Recording");
+			assert.strictEqual(tags?.artist, "A Recordist");
+			assert.strictEqual(tags?.year, 2021, "a full date yields just its leading year");
+			assert.strictEqual(tags?.genre, "Ambient");
+			assert.deepEqual(tags?.scheme, "riff-info");
+		});
+		(0, import_qunit.test)("a WAV with no LIST chunk produces no tags at all", function(assert) {
+			assert.strictEqual(extractWavTags(buildWav()), void 0, "a tag block carrying only its scheme is not worth an index row");
+		});
+		(0, import_qunit.test)("a truncated file yields nothing rather than throwing", function(assert) {
+			let short = buildWav().subarray(0, 20);
+			assert.strictEqual(extractWavEncoding(short), void 0);
+			assert.strictEqual(extractWavTags(short), void 0);
+		});
+	});
+	(0, import_qunit.module)("FLAC", function() {
+		(0, import_qunit.test)("reads the sample layout from STREAMINFO", function(assert) {
+			let encoding = extractFlacEncoding(buildFlac({
+				sampleRate: 96e3,
+				channels: 2,
+				bitsPerSample: 24
+			}));
+			assert.strictEqual(encoding?.container, "FLAC");
+			assert.strictEqual(encoding?.audioCodec, "FLAC");
+			assert.strictEqual(encoding?.sampleRateHz, 96e3);
+			assert.strictEqual(encoding?.bitDepth, 24);
+			assert.strictEqual(encoding?.channels, 2);
+			assert.true(encoding?.isVariableBitrate, "lossless compression has no constant rate to report");
+			assert.strictEqual(encoding?.bitrateBps, void 0, "FLAC never states a bitrate, so none is invented");
+		});
+		(0, import_qunit.test)("reads a 16-bit mono stream", function(assert) {
+			let encoding = extractFlacEncoding(buildFlac({
+				sampleRate: 22050,
+				channels: 1,
+				bitsPerSample: 16
+			}));
+			assert.strictEqual(encoding?.sampleRateHz, 22050);
+			assert.strictEqual(encoding?.channels, 1);
+			assert.strictEqual(encoding?.bitDepth, 16);
+			assert.strictEqual(encoding?.channelMode, "mono");
+		});
+		(0, import_qunit.test)("reads Vorbis comments from the metadata block", function(assert) {
+			let tags = extractFlacTags(buildFlac({}, [
+				["TITLE", "Nocturne"],
+				["ARTIST", "A Pianist"],
+				["ALBUM", "Night Pieces"],
+				["DATE", "1994"],
+				["TRACKNUMBER", "3"]
+			]));
+			assert.strictEqual(tags?.trackTitle, "Nocturne");
+			assert.strictEqual(tags?.artist, "A Pianist");
+			assert.strictEqual(tags?.album, "Night Pieces");
+			assert.strictEqual(tags?.year, 1994);
+			assert.strictEqual(tags?.track, "3");
+			assert.strictEqual(tags?.scheme, "vorbis-comment");
+		});
+		(0, import_qunit.test)("finds tags behind a seek table, which the old window truncated", function(assert) {
+			let bytes = buildFlac({}, [["TITLE", "Behind A Seek Table"], ["ARTIST", "A Pianist"]], 1e3);
+			assert.true(bytes.length > 18e3, "the fixture really does push the comment block deep");
+			let windowed = bytes.subarray(0, FLAC_METADATA_WINDOW_BYTES);
+			assert.strictEqual(extractFlacTags(windowed)?.trackTitle, "Behind A Seek Table", "the window reaches the comment block");
+			assert.strictEqual(extractFlacTags(bytes.subarray(0, 256)), void 0, "and the old 256-byte window demonstrably did not");
+		});
+		(0, import_qunit.test)("a FLAC with no comment block produces no tags", function(assert) {
+			assert.strictEqual(extractFlacTags(buildFlac()), void 0);
+		});
+		(0, import_qunit.test)("a non-FLAC buffer yields nothing rather than throwing", function(assert) {
+			let notFlac = new Uint8Array(64).fill(65);
+			assert.strictEqual(extractFlacEncoding(notFlac), void 0);
+			assert.strictEqual(extractFlacTags(notFlac), void 0);
+		});
+	});
+	(0, import_qunit.module)("Ogg", function() {
+		(0, import_qunit.test)("reads the Vorbis identification header", function(assert) {
+			let encoding = extractOggEncoding(buildOggVorbis(2, 44100, 16e4));
+			assert.strictEqual(encoding?.container, "Ogg");
+			assert.strictEqual(encoding?.audioCodec, "Vorbis");
+			assert.strictEqual(encoding?.sampleRateHz, 44100);
+			assert.strictEqual(encoding?.bitrateBps, 16e4);
+			assert.strictEqual(encoding?.channels, 2);
+		});
+		(0, import_qunit.test)("an undeclared nominal bitrate is omitted, not reported as zero", function(assert) {
+			assert.strictEqual(extractOggEncoding(buildOggVorbis(2, 44100, 0))?.bitrateBps, void 0);
+		});
+		(0, import_qunit.test)("Opus reports the 48 kHz rate it actually decodes to", function(assert) {
+			let encoding = extractOggEncoding(buildOggOpus(2));
+			assert.strictEqual(encoding?.audioCodec, "Opus");
+			assert.strictEqual(encoding?.sampleRateHz, 48e3, "Opus always decodes to 48 kHz whatever it was captured at");
+			assert.strictEqual(encoding?.channels, 2);
+		});
+		(0, import_qunit.test)("reads Vorbis comments from a following page", function(assert) {
+			let tags = extractOggTags(buildOggVorbis(2, 44100, 128e3, [["TITLE", "Tape Loop"], ["ARTIST", "A Composer"]]));
+			assert.strictEqual(tags?.trackTitle, "Tape Loop");
+			assert.strictEqual(tags?.artist, "A Composer");
+		});
+		(0, import_qunit.test)("reads OpusTags", function(assert) {
+			let tags = extractOggTags(buildOggOpus(1, [["TITLE", "Voice Memo"]]));
+			assert.strictEqual(tags?.trackTitle, "Voice Memo");
+		});
+		(0, import_qunit.test)("a non-Ogg buffer yields nothing", function(assert) {
+			assert.strictEqual(extractOggEncoding(new Uint8Array(64).fill(65)), void 0);
+		});
+	});
+	(0, import_qunit.module)("MP3", function() {
+		(0, import_qunit.test)("reads the frame header and reports a constant rate as constant", function(assert) {
+			let encoding = extractMp3Encoding(new Uint8Array(buildMp3Frame()));
+			assert.strictEqual(encoding?.container, "MPEG");
+			assert.strictEqual(encoding?.audioCodec, "MP3 (MPEG Layer III)");
+			assert.strictEqual(encoding?.sampleRateHz, 44100);
+			assert.strictEqual(encoding?.bitrateBps, 128e3);
+			assert.strictEqual(encoding?.channels, 2);
+			assert.strictEqual(encoding?.channelMode, "joint-stereo");
+			assert.false(encoding?.isVariableBitrate, "no Xing header means the encoder wrote a constant rate");
+		});
+		(0, import_qunit.test)("a Xing header marks the bitrate as variable", function(assert) {
+			assert.true(extractMp3Encoding(new Uint8Array(buildMp3Frame({ withXing: true })))?.isVariableBitrate);
+		});
+		(0, import_qunit.test)("never reports a bit depth, which MP3 has no concept of", function(assert) {
+			assert.strictEqual(extractMp3Encoding(new Uint8Array(buildMp3Frame()))?.bitDepth, void 0);
+		});
+		(0, import_qunit.test)("finds the frame past a leading ID3v2 tag", function(assert) {
+			let tag = buildId3v2([["TIT2", latin1Frame("Something")]]);
+			let bytes = new Uint8Array([...tag, ...buildMp3Frame()]);
+			assert.strictEqual(extractMp3Encoding(bytes)?.sampleRateHz, 44100);
+		});
+		(0, import_qunit.test)("a buffer with no frame sync yields nothing rather than throwing", function(assert) {
+			assert.strictEqual(extractMp3Encoding(new Uint8Array(128).fill(65)), void 0);
+		});
+	});
+	(0, import_qunit.module)("ID3v2", function() {
+		(0, import_qunit.test)("reads the common v2.3 text frames", function(assert) {
+			let tags = parseId3v2Tags(buildId3v2([
+				["TIT2", latin1Frame("Blue Monday")],
+				["TPE1", latin1Frame("A Band")],
+				["TALB", latin1Frame("Power")],
+				["TRCK", latin1Frame("4/12")],
+				["TYER", latin1Frame("1983")],
+				["TCON", latin1Frame("Synthpop")]
+			]));
+			assert.strictEqual(tags?.trackTitle, "Blue Monday");
+			assert.strictEqual(tags?.artist, "A Band");
+			assert.strictEqual(tags?.album, "Power");
+			assert.strictEqual(tags?.track, "4/12", "a track number keeps its total rather than being coerced to a number");
+			assert.strictEqual(tags?.year, 1983);
+			assert.strictEqual(tags?.genre, "Synthpop");
+			assert.strictEqual(tags?.scheme, "id3v2");
+		});
+		(0, import_qunit.test)("accepts the v2.4 recording-date frame", function(assert) {
+			let tags = parseId3v2Tags(buildId3v2([["TDRC", latin1Frame("2008-05-13")]], 4));
+			assert.strictEqual(tags?.year, 2008);
+		});
+		(0, import_qunit.test)("decodes a UTF-16 frame with a byte-order mark", function(assert) {
+			let text = "Ünicode";
+			let payload = [
+				1,
+				255,
+				254
+			];
+			for (let index = 0; index < 7; index++) {
+				let code = text.charCodeAt(index);
+				payload.push(code & 255, code >>> 8 & 255);
+			}
+			payload.push(0, 0);
+			let tags = parseId3v2Tags(buildId3v2([["TIT2", payload]]));
+			assert.strictEqual(tags?.trackTitle, text, "a UTF-16 tag reads in full rather than stopping at its first NUL byte");
+		});
+		(0, import_qunit.test)("a COMM frame skips its language code and description", function(assert) {
+			let payload = [
+				0,
+				...ascii("eng"),
+				...ascii("short"),
+				0,
+				...ascii("the actual comment"),
+				0
+			];
+			assert.strictEqual(parseId3v2Tags(buildId3v2([["COMM", payload]]))?.comment, "the actual comment");
+		});
+		(0, import_qunit.test)("a file with no ID3v2 tag yields nothing", function(assert) {
+			assert.strictEqual(parseId3v2Tags(new Uint8Array(buildMp3Frame())), void 0);
+		});
+		(0, import_qunit.test)("an empty tag produces no attribute despite being well-formed", function(assert) {
+			assert.strictEqual(parseId3v2Tags(buildId3v2([])), void 0);
+		});
+	});
+	(0, import_qunit.module)("Vorbis comments", function() {
+		(0, import_qunit.test)("is case-insensitive about field names", function(assert) {
+			let body = new Uint8Array(vorbisCommentBody([["title", "lowercase key"], ["Artist", "Mixed Case Key"]]));
+			let parsed = parseVorbisComments(body, 0);
+			assert.strictEqual(parsed?.tags?.trackTitle, "lowercase key");
+			assert.strictEqual(parsed?.tags?.artist, "Mixed Case Key");
+		});
+		(0, import_qunit.test)("keeps the first of a repeated key rather than joining them", function(assert) {
+			let body = new Uint8Array(vorbisCommentBody([["ARTIST", "First Artist"], ["ARTIST", "Second Artist"]]));
+			assert.strictEqual(parseVorbisComments(body, 0)?.tags?.artist, "First Artist", "joining two ARTIST values would invent a credit the file never stated");
+		});
+		(0, import_qunit.test)("reports the vendor string", function(assert) {
+			let body = new Uint8Array(vorbisCommentBody([["TITLE", "x"]]));
+			assert.strictEqual(parseVorbisComments(body, 0)?.vendor, "test-vendor");
+		});
+		(0, import_qunit.test)("ignores keys it has no field for", function(assert) {
+			let body = new Uint8Array(vorbisCommentBody([["REPLAYGAIN_TRACK_GAIN", "-6.5 dB"]]));
+			assert.strictEqual(parseVorbisComments(body, 0)?.tags, void 0, "application-specific keys do not become fields nobody declared");
+		});
+		(0, import_qunit.test)("a truncated block yields nothing rather than throwing", function(assert) {
+			let body = new Uint8Array(vorbisCommentBody([["TITLE", "Truncated"]]));
+			assert.strictEqual(parseVorbisComments(body.subarray(0, 6), 0), void 0);
+		});
+		(0, import_qunit.test)("an implausible entry count is refused", function(assert) {
+			let body = new Uint8Array(vorbisCommentBody([["TITLE", "x"]]));
+			let vendorLength = new DataView(body.buffer).getUint32(0, true);
+			new DataView(body.buffer).setUint32(4 + vendorLength, 1e5, true);
+			assert.strictEqual(parseVorbisComments(body, 0), void 0);
+		});
+	});
+	(0, import_qunit.module)("waveform reduction", function() {
+		function fakeAudio(channels, sampleRate = 44100) {
+			let length = channels[0]?.length ?? 0;
+			return {
+				duration: length / sampleRate,
+				sampleRate,
+				numberOfChannels: channels.length,
+				length,
+				getChannelData: (index) => channels[index] ?? new Float32Array()
+			};
+		}
+		(0, import_qunit.test)("resamples across the whole signal, not just its opening", function(assert) {
+			let samples = new Float32Array(1e3);
+			samples.fill(0, 0, 900);
+			samples.fill(1, 900, 1e3);
+			let result = analyzeDecodedAudio(fakeAudio([samples]), 10);
+			let bars = JSON.parse(result.barsJson);
+			assert.strictEqual(bars.length, 10);
+			assert.strictEqual(bars[0], 0, "the silent opening reads as silent");
+			assert.strictEqual(bars[9], 1, "the loud ending is represented, so the envelope is the shape of the whole track");
+		});
+		(0, import_qunit.test)("every channel contributes, so panned content is not misread", function(assert) {
+			let left = new Float32Array(100);
+			let right = new Float32Array(100).fill(1);
+			let result = analyzeDecodedAudio(fakeAudio([left, right]), 4);
+			let bars = JSON.parse(result.barsJson);
+			assert.true(bars.every((bar) => bar > 0), "a hard-panned track is not reported as silent");
+		});
+		(0, import_qunit.test)("reports RMS per bar rather than peak, so quiet stays quiet", function(assert) {
+			let quiet = new Float32Array(100).fill(.1);
+			let result = analyzeDecodedAudio(fakeAudio([quiet]), 4);
+			let bars = JSON.parse(result.barsJson);
+			assert.true(bars.every((bar) => Math.abs(bar - .1) < .001), "a bar tracks loudness rather than saturating to the peak");
+		});
+		(0, import_qunit.test)("reports the overall peak separately from the envelope", function(assert) {
+			let samples = new Float32Array(100).fill(.2);
+			samples[50] = -.95;
+			let result = analyzeDecodedAudio(fakeAudio([samples]), 4);
+			assert.strictEqual(result.peakAmplitude, .95, "peak is a magnitude, so a negative sample still counts");
+			assert.true(result.rmsAmplitude < .4, "RMS is not dragged to the peak");
+		});
+		(0, import_qunit.test)("the bar count is fixed regardless of duration", function(assert) {
+			let short = analyzeDecodedAudio(fakeAudio([new Float32Array(200).fill(.5)]), 32);
+			let long = analyzeDecodedAudio(fakeAudio([new Float32Array(2e5).fill(.5)]), 32);
+			assert.strictEqual(short.barCount, 32);
+			assert.strictEqual(long.barCount, 32, "a long recording costs no more stored payload than a short one");
+		});
+		(0, import_qunit.test)("a buffer with fewer samples than bars still produces a bar each", function(assert) {
+			let result = analyzeDecodedAudio(fakeAudio([new Float32Array(3).fill(.5)]), 8);
+			let bars = JSON.parse(result.barsJson);
+			assert.strictEqual(bars.length, 8, "no window is left empty");
+		});
+		(0, import_qunit.test)("an empty buffer is reported as an empty envelope, not a failure", function(assert) {
+			let result = analyzeDecodedAudio(fakeAudio([new Float32Array(0)]), 8);
+			assert.strictEqual(result.decodeStatus, "ok");
+			assert.strictEqual(result.barsJson, "[]");
+			assert.strictEqual(result.barCount, 0);
+		});
+	});
+	(0, import_qunit.module)("attribute assembly", function() {
+		(0, import_qunit.test)("wraps rates as quantities and schemes as coded values", function(assert) {
+			let attributes = audioAttributes({
+				container: "FLAC",
+				audioCodec: "FLAC",
+				sampleRateHz: 44100,
+				bitrateBps: 9e5,
+				bitDepth: 16,
+				channels: 2,
+				channelMode: "stereo",
+				isVariableBitrate: true
+			}, {
+				scheme: "vorbis-comment",
+				trackTitle: "Nocturne"
+			});
+			assert.deepEqual(attributes.encoding?.sampleRate, {
+				value: 44100,
+				unit: "Hz"
+			});
+			assert.deepEqual(attributes.encoding?.bitrate, {
+				value: 9e5,
+				unit: "bps"
+			});
+			assert.deepEqual(attributes.encoding?.channelMode, {
+				code: "stereo",
+				scheme: "channel-mode"
+			});
+			assert.deepEqual(attributes.tags?.scheme, {
+				code: "vorbis-comment",
+				scheme: "tag-scheme"
+			});
+			assert.strictEqual(attributes.tags?.trackTitle, "Nocturne");
+		});
+		(0, import_qunit.test)("a file that revealed nothing adds no attributes at all", function(assert) {
+			assert.deepEqual(audioAttributes(void 0, void 0), {});
+		});
+		(0, import_qunit.test)("a skipped decode is still persisted, because it is not the same as absent", function(assert) {
+			let attributes = audioAttributes(void 0, void 0, {
+				decodeStatus: "skipped",
+				decodeError: "too big"
+			});
+			assert.strictEqual(attributes.waveform?.decodeStatus, "skipped");
+		});
+		(0, import_qunit.test)("a false variable-bitrate flag survives assembly", function(assert) {
+			let attributes = audioAttributes({ isVariableBitrate: false }, void 0);
+			assert.false(attributes.encoding?.isVariableBitrate, "knowing a stream is constant-rate is a fact worth persisting");
+		});
+	});
+	(0, import_qunit.module)("MIDI", function() {
+		function vlq(value) {
+			let out = [value & 127];
+			let rest = value >>> 7;
+			while (rest > 0) {
+				out.unshift(rest & 127 | 128);
+				rest >>>= 7;
+			}
+			return out;
+		}
+		function trackChunk(events) {
+			let body = [
+				...events,
+				0,
+				255,
+				47,
+				0
+			];
+			return [
+				...ascii("MTrk"),
+				...uint32be(body.length),
+				...body
+			];
+		}
+		function buildMidi(tracks, options = {}) {
+			let chunks = tracks.flatMap((events) => trackChunk(events));
+			return new Uint8Array([
+				...ascii("MThd"),
+				...uint32be(6),
+				...uint16le(0).reverse(),
+				...uint16le(0).reverse(),
+				...uint16le(0).reverse(),
+				...chunks
+			]).map((byte, index) => {
+				let format = options.format ?? 1;
+				let division = options.division ?? 480;
+				if (index === 8) return format >>> 8 & 255;
+				if (index === 9) return format & 255;
+				if (index === 10) return tracks.length >>> 8 & 255;
+				if (index === 11) return tracks.length & 255;
+				if (index === 12) return division >>> 8 & 255;
+				if (index === 13) return division & 255;
+				return byte;
+			});
+		}
+		function note(channel, pitch, velocity = 64, deltaOn = 0, deltaOff = 480) {
+			return [
+				...vlq(deltaOn),
+				144 | channel,
+				pitch,
+				velocity,
+				...vlq(deltaOff),
+				128 | channel,
+				pitch,
+				0
+			];
+		}
+		function tempoEvent(bpm, delta = 0) {
+			let microseconds = Math.round(6e7 / bpm);
+			return [
+				...vlq(delta),
+				255,
+				81,
+				3,
+				microseconds >>> 16 & 255,
+				microseconds >>> 8 & 255,
+				microseconds & 255
+			];
+		}
+		(0, import_qunit.test)("reads the header and counts the notes that actually sound", function(assert) {
+			let midi = extractMidiMetadata(buildMidi([[
+				...note(0, 60),
+				...note(0, 64),
+				...note(0, 67)
+			]], {
+				format: 0,
+				division: 480
+			}));
+			assert.strictEqual(midi.format, 0);
+			assert.strictEqual(midi.ppq, 480);
+			assert.strictEqual(midi.noteCount, 3);
+			assert.strictEqual(midi.fileTrackCount, 1);
+			assert.strictEqual(midi.trackCount, 1);
+		});
+		(0, import_qunit.test)("a note-on with zero velocity is a note-off, not a second note", function(assert) {
+			let events = [
+				...vlq(0),
+				144,
+				60,
+				64,
+				...vlq(480),
+				144,
+				60,
+				0
+			];
+			assert.strictEqual(extractMidiMetadata(buildMidi([events])).noteCount, 1);
+		});
+		(0, import_qunit.test)("distinguishes tracks that sound from tracks the header declares", function(assert) {
+			let midi = extractMidiMetadata(buildMidi([tempoEvent(120), [...note(0, 60)]]));
+			assert.strictEqual(midi.fileTrackCount, 2);
+			assert.strictEqual(midi.trackCount, 1, "the conductor track declares no notes so it does not count as sounding");
+		});
+		(0, import_qunit.test)("derives duration by walking the tempo map, not by averaging", function(assert) {
+			let midi = extractMidiMetadata(buildMidi([[...tempoEvent(120), ...note(0, 60, 64, 0, 480)]], { division: 480 }));
+			assert.strictEqual(midi.durationSeconds, .5);
+		});
+		(0, import_qunit.test)("a tempo change partway through changes the derived duration", function(assert) {
+			let events = [
+				...tempoEvent(120),
+				...note(0, 60, 64, 0, 480),
+				...tempoEvent(240),
+				...note(0, 62, 64, 0, 480)
+			];
+			let midi = extractMidiMetadata(buildMidi([events], { division: 480 }));
+			assert.strictEqual(midi.durationSeconds, .75, "a piece that speeds up is not reported at its opening tempo");
+			assert.strictEqual(midi.tempoMap?.length, 2);
+			assert.true(midi.tempoMap?.[0]?.startsWith("120 BPM"));
+			assert.true(midi.tempoMap?.[1]?.startsWith("240 BPM"));
+		});
+		(0, import_qunit.test)("reads time and key signatures", function(assert) {
+			let events = [
+				...vlq(0),
+				255,
+				88,
+				4,
+				6,
+				3,
+				24,
+				8,
+				...vlq(0),
+				255,
+				89,
+				2,
+				253,
+				1,
+				...note(0, 60)
+			];
+			let midi = extractMidiMetadata(buildMidi([events]));
+			assert.deepEqual(midi.timeSignatures, ["6/8"]);
+			assert.deepEqual(midi.keySignatures, ["C minor"], "a signed accidental count and a minor flag name the key");
+		});
+		(0, import_qunit.test)("reports the pitch range in note names", function(assert) {
+			let midi = extractMidiMetadata(buildMidi([[...note(0, 60), ...note(0, 72)]]));
+			assert.strictEqual(midi.pitchRange, "C4–C5", "MIDI note 60 is middle C, conventionally written C4");
+		});
+		(0, import_qunit.test)("percussion is flagged and kept out of the pitch range", function(assert) {
+			let midi = extractMidiMetadata(buildMidi([[
+				...note(0, 60),
+				...note(9, 35),
+				...note(9, 81)
+			]]));
+			assert.true(midi.hasPercussion);
+			assert.strictEqual(midi.pitchRange, "C4–C4");
+		});
+		(0, import_qunit.test)("collects program changes excluding the percussion channel", function(assert) {
+			let events = [
+				...vlq(0),
+				192,
+				40,
+				...vlq(0),
+				201,
+				16,
+				...note(0, 60)
+			];
+			let midi = extractMidiMetadata(buildMidi([events]));
+			assert.deepEqual(midi.programs, [40]);
+		});
+		(0, import_qunit.test)("reports channels as the numbers a musician uses, counting from one", function(assert) {
+			let midi = extractMidiMetadata(buildMidi([[...note(0, 60), ...note(3, 64)]]));
+			assert.deepEqual(midi.channels, [1, 4]);
+		});
+		(0, import_qunit.test)("follows running status, which real files rely on", function(assert) {
+			let events = [
+				...vlq(0),
+				144,
+				60,
+				64,
+				...vlq(10),
+				62,
+				64,
+				...vlq(10),
+				64,
+				64
+			];
+			assert.strictEqual(extractMidiMetadata(buildMidi([events])).noteCount, 3);
+		});
+		(0, import_qunit.test)("skips a SysEx event without desynchronizing the walk", function(assert) {
+			let events = [
+				...vlq(0),
+				240,
+				4,
+				126,
+				127,
+				9,
+				1,
+				...note(0, 60)
+			];
+			assert.strictEqual(extractMidiMetadata(buildMidi([events])).noteCount, 1);
+		});
+		(0, import_qunit.test)("a SMPTE-timed file reads its notes but declares no ppq", function(assert) {
+			let midi = extractMidiMetadata(buildMidi([[...note(0, 60)]], { division: 59176 }));
+			assert.strictEqual(midi.ppq, void 0);
+			assert.strictEqual(midi.durationSeconds, void 0);
+			assert.strictEqual(midi.noteCount, 1);
+		});
+		(0, import_qunit.test)("a non-MIDI file is reported as a content mismatch", function(assert) {
+			assert.throws(() => extractMidiMetadata(new Uint8Array(64).fill(65)), /MThd/, "the extractor falls back to the base FileDef rather than inventing metadata");
+		});
+		(0, import_qunit.test)("a truncated track yields the events it did read", function(assert) {
+			let full = buildMidi([[...note(0, 60), ...note(0, 64)]]);
+			let truncated = full.subarray(0, full.length - 6);
+			let midi = extractMidiMetadata(truncated);
+			assert.true(midi.noteCount >= 1, "a partial track still reports what was readable rather than throwing");
+		});
+	});
+	(0, import_qunit.module)("streaming envelope", function() {
+		(0, import_qunit.test)("holds its bar count however many units arrive", function(assert) {
+			for (let units of [
+				4,
+				100,
+				1e4
+			]) {
+				let envelope = new StreamingEnvelope(16);
+				for (let index = 0; index < units; index++) envelope.push(.25, 1);
+				assert.strictEqual(envelope.bars().length, 16, `${units} units still reduce to 16 bars`);
+			}
+		});
+		(0, import_qunit.test)("places signal by position, not by arrival order", function(assert) {
+			let envelope = new StreamingEnvelope(8);
+			for (let index = 0; index < 3e3; index++) envelope.push(0, 1);
+			for (let index = 0; index < 1e3; index++) envelope.push(1, 1);
+			let bars = envelope.bars();
+			assert.strictEqual(bars[0], 0, "the silent opening reads as silent");
+			assert.strictEqual(bars[7], 1, "the loud ending reaches the final bar rather than being folded away");
+		});
+		(0, import_qunit.test)("survives many folds without losing the shape", function(assert) {
+			let envelope = new StreamingEnvelope(4);
+			let total = 1e5;
+			for (let index = 0; index < total; index++) envelope.push(index < total / 2 ? 0 : 1, 1);
+			let bars = envelope.bars();
+			assert.strictEqual(bars[0], 0);
+			assert.strictEqual(bars[1], 0);
+			assert.strictEqual(bars[3], 1, "the second half is still loud after folding");
+		});
+		(0, import_qunit.test)("reports the peak it was told about", function(assert) {
+			let envelope = new StreamingEnvelope(4);
+			envelope.push(.01, 1, .1);
+			envelope.push(.81, 1, .9);
+			envelope.push(.04, 1, .2);
+			assert.strictEqual(envelope.peak, .9);
+		});
+		(0, import_qunit.test)("an accumulator nothing was pushed to is empty, not zero-filled", function(assert) {
+			let envelope = new StreamingEnvelope(8);
+			assert.true(envelope.isEmpty);
+			assert.deepEqual(envelope.bars(), []);
+		});
+	});
+	(0, import_qunit.module)("MP3 envelope from side info", function() {
+		function frameWithGain(gain) {
+			let header = [
+				255,
+				251,
+				144,
+				64
+			];
+			let body = new Array(413).fill(0);
+			let base = 20;
+			for (let block = 0; block < 4; block++) {
+				let bitOffset = base + block * 59 + 21;
+				for (let bit = 0; bit < 8; bit++) {
+					let value = gain >> 7 - bit & 1;
+					let absolute = bitOffset + bit;
+					let byteIndex = absolute >> 3;
+					if (value) body[byteIndex] |= 1 << 7 - (absolute & 7);
+				}
+			}
+			return [...header, ...body];
+		}
+		(0, import_qunit.test)("reads a gain out of every granule of every frame", function(assert) {
+			let bytes = new Uint8Array([
+				...frameWithGain(200),
+				...frameWithGain(200),
+				...frameWithGain(200),
+				...frameWithGain(200)
+			]);
+			let envelope = extractMp3Envelope(bytes, 8);
+			assert.strictEqual(envelope?.granuleCount, 16, "four frames yield sixteen granule gains");
+			assert.strictEqual(envelope?.frameCount, 4);
+			assert.strictEqual(envelope?.sampleRateHz, 44100);
+		});
+		(0, import_qunit.test)("a louder passage produces taller bars than a quieter one", function(assert) {
+			let quiet = Array.from({ length: 8 }, () => frameWithGain(150)).flat();
+			let loud = Array.from({ length: 8 }, () => frameWithGain(210)).flat();
+			let bars = extractMp3Envelope(new Uint8Array([...quiet, ...loud]), 4).bars;
+			assert.true(bars[0] < bars[3], "the quiet opening reads lower than the loud ending");
+			assert.strictEqual(bars[3], 1, "bars are normalized to the loudest bar, so the loudest reaches 1");
+		});
+		(0, import_qunit.test)("a single transient still leaves the loudest bar at full scale", function(assert) {
+			let frames = Array.from({ length: 16 }, (_, index) => frameWithGain(index === 12 ? 230 : 170)).flat();
+			let bars = extractMp3Envelope(new Uint8Array(frames), 4).bars;
+			assert.strictEqual(Math.max(...bars), 1, "the loudest bar reaches full scale");
+			assert.true(bars[3] > bars[0], "the bar holding the transient is the tallest");
+		});
+		(0, import_qunit.test)("derives a duration from granule count without needing a Xing header", function(assert) {
+			let bytes = new Uint8Array(Array.from({ length: 4 }, () => frameWithGain(180)).flat());
+			let envelope = extractMp3Envelope(bytes, 8);
+			assert.strictEqual(envelope?.durationSeconds, Math.round(16 * 576 * 1e3 / 44100) / 1e3);
+		});
+		(0, import_qunit.test)("skips a leading ID3v2 tag", function(assert) {
+			let tag = buildId3v2([["TIT2", latin1Frame("Tagged")]]);
+			let bytes = new Uint8Array([
+				...tag,
+				...frameWithGain(190),
+				...frameWithGain(190)
+			]);
+			assert.strictEqual(extractMp3Envelope(bytes, 4)?.granuleCount, 8);
+		});
+		(0, import_qunit.test)("resynchronizes past a corrupt frame rather than stopping", function(assert) {
+			let bytes = new Uint8Array([
+				...frameWithGain(190),
+				...new Array(64).fill(65),
+				...frameWithGain(190)
+			]);
+			let envelope = extractMp3Envelope(bytes, 4);
+			assert.strictEqual(envelope?.frameCount, 2, "a single corrupt run does not cost the rest of the file");
+		});
+		(0, import_qunit.test)("a file with no frames yields nothing rather than throwing", function(assert) {
+			assert.strictEqual(extractMp3Envelope(new Uint8Array(256).fill(65), 8), void 0);
+		});
+		(0, import_qunit.test)("the streaming scan agrees with the buffered one", async function(assert) {
+			let bytes = new Uint8Array([...Array.from({ length: 6 }, () => frameWithGain(150)).flat(), ...Array.from({ length: 6 }, () => frameWithGain(205)).flat()]);
+			let buffered = extractMp3Envelope(bytes, 8);
+			for (let chunkSize of [
+				13,
+				417,
+				1e3
+			]) {
+				let streamed = await extractMp3EnvelopeFromStream(chunkedStream(bytes, chunkSize), 8);
+				assert.deepEqual(streamed?.bars, buffered?.bars, `chunks of ${chunkSize} bytes produce the same envelope`);
+				assert.strictEqual(streamed?.granuleCount, buffered?.granuleCount);
+				assert.strictEqual(streamed?.frameCount, buffered?.frameCount);
+			}
+		});
+		(0, import_qunit.test)("the streaming scan skips a large ID3v2 tag without buffering it", async function(assert) {
+			let tag = buildId3v2([["APIC", new Array(2e5).fill(0)]]);
+			let bytes = new Uint8Array([
+				...tag,
+				...frameWithGain(190),
+				...frameWithGain(190)
+			]);
+			let streamed = await extractMp3EnvelopeFromStream(chunkedStream(bytes, 4096), 4);
+			assert.strictEqual(streamed?.granuleCount, 8);
+		});
+	});
+	(0, import_qunit.module)("WAV single-pass streaming", function() {
+		function buildWavWithPcm(frames, options = {}) {
+			let sampleRate = options.sampleRate ?? 8e3;
+			let channels = options.channels ?? 1;
+			let bitsPerSample = 16;
+			let byteRate = sampleRate * channels * bitsPerSample / 8;
+			let fmtBody = [
+				...uint16le(1),
+				...uint16le(channels),
+				...uint32le(sampleRate),
+				...uint32le(byteRate),
+				...uint16le(channels * bitsPerSample / 8),
+				...uint16le(bitsPerSample)
+			];
+			let pcm = [];
+			for (let frame of frames) for (let sample of frame) {
+				let value = Math.round(Math.max(-1, Math.min(1, sample)) * 32767);
+				pcm.push(...uint16le(value < 0 ? value + 65536 : value));
+			}
+			let infoChunk = [];
+			if (options.infoEntries?.length) {
+				let infoBody = [...ascii("INFO")];
+				for (let [id, value] of options.infoEntries) infoBody.push(...riffChunk(id, [...ascii(value), 0]));
+				infoChunk = riffChunk("LIST", infoBody);
+			}
+			let chunks = [
+				...riffChunk("fmt ", fmtBody),
+				...options.trailingInfo ? [] : infoChunk,
+				...riffChunk("data", pcm),
+				...options.trailingInfo ? infoChunk : []
+			];
+			let payload = [...ascii("WAVE"), ...chunks];
+			return new Uint8Array([
+				...ascii("RIFF"),
+				...uint32le(payload.length),
+				...payload
+			]);
+		}
+		function silentThenLoud(total) {
+			return Array.from({ length: total }, (_, index) => [index < total / 2 ? 0 : 1]);
+		}
+		(0, import_qunit.test)("derives duration, encoding, and envelope from one pass", async function(assert) {
+			let bytes = buildWavWithPcm(silentThenLoud(8e3), { sampleRate: 8e3 });
+			let result = await extractWavFromStream(bytes, 8);
+			assert.strictEqual(result.duration, 1, "8000 mono frames at 8 kHz is 1 s");
+			assert.strictEqual(result.encoding?.sampleRateHz, 8e3);
+			assert.strictEqual(result.encoding?.bitDepth, 16);
+			assert.strictEqual(result.envelope?.bars.length, 8);
+		});
+		(0, import_qunit.test)("the envelope tracks the real signal", async function(assert) {
+			let bars = (await extractWavFromStream(buildWavWithPcm(silentThenLoud(8e3)), 8)).envelope.bars;
+			assert.strictEqual(bars[0], 0, "the silent half reads as silent");
+			assert.true(bars[7] > .99, "the loud half reaches full scale");
+		});
+		(0, import_qunit.test)("peak and RMS are real amplitudes, needing no normalization", async function(assert) {
+			let frames = Array.from({ length: 4e3 }, () => [.5]);
+			let result = await extractWavFromStream(buildWavWithPcm(frames), 8);
+			assert.true(Math.abs(result.envelope.peak - .5) < .001);
+			assert.true(Math.abs(result.envelope.rms - .5) < .001);
+		});
+		(0, import_qunit.test)("a frame split across stream chunks is not dropped or misread", async function(assert) {
+			let bytes = buildWavWithPcm(silentThenLoud(4e3), { channels: 2 });
+			let whole = await extractWavFromStream(bytes, 8);
+			let chunked = await extractWavFromStream(chunkedStream(bytes, 7), 8);
+			assert.deepEqual(chunked.envelope?.bars, whole.envelope?.bars, "chunking the stream does not change the envelope");
+			assert.strictEqual(chunked.duration, whole.duration);
+		});
+		(0, import_qunit.test)("reads LIST-INFO written before the payload", async function(assert) {
+			let result = await extractWavFromStream(buildWavWithPcm(silentThenLoud(800), { infoEntries: [["INAM", "Leading Tag"]] }), 8);
+			assert.strictEqual(result.tags?.trackTitle, "Leading Tag");
+		});
+		(0, import_qunit.test)("reads LIST-INFO written after the payload", async function(assert) {
+			let result = await extractWavFromStream(buildWavWithPcm(silentThenLoud(800), {
+				infoEntries: [["INAM", "Trailing Tag"]],
+				trailingInfo: true
+			}), 8);
+			assert.strictEqual(result.tags?.trackTitle, "Trailing Tag");
+		});
+		(0, import_qunit.test)("stops folding PCM at the declared data size", async function(assert) {
+			let result = await extractWavFromStream(buildWavWithPcm(Array.from({ length: 800 }, () => [0]), {
+				infoEntries: [["INAM", "x"]],
+				trailingInfo: true
+			}), 4);
+			assert.deepEqual(result.envelope?.bars, [
+				0,
+				0,
+				0,
+				0
+			], "a silent file stays silent despite trailing chunk bytes");
+		});
+		(0, import_qunit.test)("a non-WAVE buffer yields no duration rather than throwing", async function(assert) {
+			let result = await extractWavFromStream(new Uint8Array(256).fill(65), 8);
+			assert.strictEqual(result.duration, void 0);
+			assert.strictEqual(result.envelope, void 0);
+		});
+	});
+	(0, import_qunit.module)("decode budget", function() {
+		const MB = 1024 * 1024;
+		function forEncoded(bitrateBps, sampleRateHz, channels, encodedBytes) {
+			return {
+				durationSeconds: encodedBytes * 8 / bitrateBps,
+				sampleRateHz,
+				channels,
+				contentSize: encodedBytes
+			};
+		}
+		(0, import_qunit.test)("predicts decoded size from what the container already stated", function(assert) {
+			assert.strictEqual(predictedDecodedBytes({
+				durationSeconds: 300,
+				sampleRateHz: 44100,
+				channels: 2
+			}), 300 * 44100 * 2 * 4);
+		});
+		(0, import_qunit.test)("admits an ordinary song", function(assert) {
+			assert.strictEqual(decodeSkipReason({
+				durationSeconds: 240,
+				sampleRateHz: 44100,
+				channels: 2
+			}), void 0);
+		});
+		(0, import_qunit.test)("refuses the low-bitrate Opus case the old ceiling admitted", function(assert) {
+			let budget = forEncoded(64e3, 48e3, 2, 16 * MB);
+			assert.true(budget.contentSize <= 16 * MB, "the file is within what the old encoded ceiling allowed");
+			assert.ok(decodeSkipReason(budget), "but it is refused on the decoded size that actually matters");
+		});
+		(0, import_qunit.test)("still admits FLAC of the same encoded size", function(assert) {
+			let budget = forEncoded(705600, 44100, 2, 16 * MB);
+			assert.strictEqual(decodeSkipReason(budget), void 0);
+		});
+		(0, import_qunit.test)("mono costs half as much, so twice as long is allowed", function(assert) {
+			assert.strictEqual(decodeSkipReason({
+				durationSeconds: 700,
+				sampleRateHz: 44100,
+				channels: 1
+			}), void 0, "a long mono recording still fits");
+			assert.ok(decodeSkipReason({
+				durationSeconds: 700,
+				sampleRateHz: 44100,
+				channels: 2
+			}), "the same duration in stereo does not");
+		});
+		(0, import_qunit.test)("the skip reason names the size that caused it", function(assert) {
+			let reason = decodeSkipReason({
+				durationSeconds: 3600,
+				sampleRateHz: 48e3,
+				channels: 2
+			});
+			assert.true(/\d+ MB/.test(reason ?? ""), "an operator can see how far over it was, not just that it was over");
+		});
+		(0, import_qunit.test)("falls back to encoded size when the container said too little", function(assert) {
+			assert.strictEqual(predictedDecodedBytes({ contentSize: 999 * MB }), void 0, "nothing to predict from");
+			assert.ok(decodeSkipReason({ contentSize: 999 * MB }), "the encoded proxy still catches an enormous file");
+			assert.strictEqual(decodeSkipReason({ contentSize: 4 * MB }), void 0, "and lets a small one through");
+		});
+		(0, import_qunit.test)("a zero or missing sample rate is not treated as a prediction", function(assert) {
+			assert.strictEqual(predictedDecodedBytes({
+				durationSeconds: 300,
+				sampleRateHz: 0,
+				channels: 2
+			}), void 0);
+		});
+	});
+	(0, import_qunit.module)("waveform decode (real Web Audio)", function() {
+		function pcmWav(seconds, sampleRate) {
+			let frameCount = Math.round(seconds * sampleRate);
+			let pcm = [];
+			for (let i = 0; i < frameCount; i++) {
+				let value = i < frameCount / 2 ? 0 : Math.round(.5 * 32767);
+				pcm.push(...uint16le(value));
+			}
+			let fmtBody = [
+				...uint16le(1),
+				...uint16le(1),
+				...uint32le(sampleRate),
+				...uint32le(sampleRate * 2),
+				...uint16le(2),
+				...uint16le(16)
+			];
+			let payload = [
+				...ascii("WAVE"),
+				...riffChunk("fmt ", fmtBody),
+				...riffChunk("data", pcm)
+			];
+			return new Uint8Array([
+				...ascii("RIFF"),
+				...uint32le(payload.length),
+				...payload
+			]);
+		}
+		(0, import_qunit.test)("decodes real bytes through the environment Web Audio implementation", async function(assert) {
+			let result = await extractAudioWaveform(pcmWav(.5, 8e3), {
+				barCount: 8,
+				sampleRateHz: 8e3
+			});
+			assert.strictEqual(result.decodeStatus, "ok", `decode succeeds (${result.decodeError ?? "no error"})`);
+			assert.strictEqual(result.barCount, 8);
+			assert.true(Math.abs((result.durationSeconds ?? 0) - .5) < .05, `duration ~0.5s (got ${result.durationSeconds})`);
+			let bars = JSON.parse(result.barsJson ?? "[]");
+			assert.strictEqual(bars.length, 8);
+			assert.true(bars[7] > bars[0], "the loud half reads louder than the silent half");
+		});
+		(0, import_qunit.test)("a stated rate outside the Web Audio band still decodes", async function(assert) {
+			let result = await extractAudioWaveform(pcmWav(.25, 8e3), {
+				barCount: 4,
+				sampleRateHz: 655350
+			});
+			assert.strictEqual(result.decodeStatus, "ok", `decode succeeds (${result.decodeError ?? "no error"})`);
+		});
+	});
+});
+//#endregion