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

package/bundled-test-harness/assets/audio-metadata-extractor-test-4xsQqL-0.js

@@ -1,1176 +0,0 @@
-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-Dd8k0DNa.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