@humeai/audio-decisions 0.0.1 → 0.2.0

package/dist/esm/audio-helpers/mp3.mjs

@@ -0,0 +1,239 @@
+// Maintained by hand and listed in .fernignore, so SDK regeneration leaves it in place.
+import { hasBytes, uint32BE } from "./bytes.mjs";
+import { UnsupportedAudioError } from "./errors.mjs";
+const CONVERT_COMMAND = "ffmpeg -i input.mp3 -c:a libmp3lame -q:a 2 output.mp3";
+// Keyed by the version bits of a frame header. Version 1 is reserved.
+const SAMPLE_RATES = {
+    3: [44100, 48000, 32000],
+    2: [22050, 24000, 16000],
+    0: [11025, 12000, 8000],
+};
+const MPEG1 = 3;
+// Layer III bitrates in kbit/s. Index 0 is free format.
+const MPEG1_BITRATES = [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320];
+const MPEG2_BITRATES = [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160];
+const LAYER_III = 1;
+const MONO = 3;
+// Samples a layer III decoder outputs before the first sample the encoder was given.
+const DECODER_DELAY = 529;
+// Encoders whose header frame carries a LAME tag, which states the samples added at each end.
+const LAME_TAG_ENCODERS = ["LAME", "Lavf", "Lavc"];
+// Tags that some writers append after the last frame. Nothing after one is audio.
+const TRAILING_TAGS = ["TAG", "APETAGEX", "LYRICSBEGIN", "ID3"];
+const NO_HEADER_FRAME = { leadingSamples: 0, trailingSamples: 0, statedFrames: undefined };
+export function isMp3(data) {
+    return hasBytes(data, 0, "ID3") || hasFrameSync(data, 0);
+}
+export function parseMp3(data) {
+    let offset = skipId3v2(data);
+    const first = readHeader(data, offset);
+    // The first frame can be a Xing, Info or VBRI header, which holds the length of the whole file
+    // instead of audio. Left in a chunk, it would tell players the chunk is that long.
+    const headerFrame = offset + first.length <= data.length ? readHeaderFrame(data, offset, first) : undefined;
+    if (headerFrame !== undefined) {
+        offset += first.length;
+    }
+    const offsets = [];
+    const reservoirBytes = [];
+    const mainDataBytes = [];
+    while (offset + 4 <= data.length && !startsTrailingTag(data, offset)) {
+        const header = tryReadHeader(data, offset);
+        if (typeof header === "string") {
+            // Players skip bytes after the last frame that are neither a frame nor a tag, such as
+            // padding. When frames follow them, the bytes are damage instead.
+            if (framesFollow(data, offset + 1, first)) {
+                throw unsupported(header);
+            }
+            break;
+        }
+        if (header.version !== first.version || header.sampleRate !== first.sampleRate) {
+            throw unsupported(`the sample rate changes at byte ${offset}`);
+        }
+        // A file cut short is read up to its last whole frame.
+        if (offset + header.length > data.length) {
+            break;
+        }
+        offsets.push(offset);
+        reservoirBytes.push(readReservoirBytes(data, offset, header));
+        mainDataBytes.push(header.length - header.sideInfoStart - header.sideInfoSize);
+        offset += header.length;
+    }
+    offsets.push(offset);
+    const frameCount = offsets.length - 1;
+    const { leadingSamples, trailingSamples, statedFrames } = headerFrame !== null && headerFrame !== void 0 ? headerFrame : NO_HEADER_FRAME;
+    const samplesPerFrame = first.version === MPEG1 ? 1152 : 576;
+    return {
+        sampleRate: first.sampleRate,
+        samplesPerFrame,
+        offsets,
+        reservoirBytes,
+        mainDataBytes,
+        leadingSamples,
+        frameCount,
+        // The samples added at the end close the frames the header counts. A file cut short has lost
+        // them, and players then leave nothing out at the end.
+        endSample: frameCount * samplesPerFrame - (statedFrames === frameCount ? trailingSamples : 0),
+    };
+}
+/** Counts the frames that must come before `frame` in a chunk for it to decode exactly. */
+export function framesNeededBefore(mp3, frame) {
+    if (frame === 0) {
+        return 0;
+    }
+    // Each frame's output is blended with the end of the previous frame's, so the previous frame
+    // must decode exactly too, and so needs its own stored audio data.
+    return Math.max(framesHoldingDataOf(mp3, frame), 1 + framesHoldingDataOf(mp3, frame - 1));
+}
+/** Builds an MP3 file holding frames `start` to `end` and none of the source's tags. */
+export function mp3Chunk(data, mp3, start, end) {
+    // Copied rather than sliced, since a Buffer's slice is a view that would keep the whole recording.
+    return new Uint8Array(data.subarray(mp3.offsets[start], mp3.offsets[end]));
+}
+function framesHoldingDataOf(mp3, frame) {
+    let needed = mp3.reservoirBytes[frame];
+    if (needed === 0) {
+        return 0;
+    }
+    let count = 0;
+    while (needed > 0 && count < frame) {
+        count += 1;
+        needed -= mp3.mainDataBytes[frame - count];
+    }
+    // Decoders such as ffmpeg and mpg123 do not keep the audio data of the first frame they read
+    // when they cannot decode it, so the data must start after the chunk's first frame.
+    return Math.min(count + 1, frame);
+}
+function hasFrameSync(data, offset) {
+    return offset + 2 <= data.length && data[offset] === 0xff && (data[offset + 1] & 0xe0) === 0xe0;
+}
+function startsTrailingTag(data, offset) {
+    return TRAILING_TAGS.some((tag) => hasBytes(data, offset, tag));
+}
+function readReservoirBytes(data, offset, header) {
+    // Layer III frames may store audio data in the unused space of the frames before them. The side
+    // information starts with how far back that data begins: 9 bits in MPEG-1 and 8 bits otherwise.
+    const sideInfo = offset + header.sideInfoStart;
+    if (header.version === MPEG1) {
+        return (data[sideInfo] << 1) | (data[sideInfo + 1] >> 7);
+    }
+    return data[sideInfo];
+}
+function skipId3v2(data) {
+    let offset = 0;
+    while (hasBytes(data, offset, "ID3") && offset + 10 <= data.length) {
+        const flags = data[offset + 5];
+        // ID3v2 sizes store 7 bits in each byte.
+        let size = 0;
+        for (let index = offset + 6; index < offset + 10; index++) {
+            size = (size << 7) | (data[index] & 0x7f);
+        }
+        offset += 10 + size + (flags & 0x10 ? 10 : 0);
+    }
+    return offset;
+}
+function readHeader(data, offset) {
+    const header = tryReadHeader(data, offset);
+    if (typeof header === "string") {
+        throw unsupported(header);
+    }
+    return header;
+}
+/** The frame header at `offset`, or the reason there is none. */
+function tryReadHeader(data, offset) {
+    if (offset + 4 > data.length) {
+        return "no MPEG audio frame";
+    }
+    if (!hasFrameSync(data, offset)) {
+        return `no MPEG audio frame at byte ${offset}`;
+    }
+    const b1 = data[offset + 1];
+    const b2 = data[offset + 2];
+    const b3 = data[offset + 3];
+    const version = (b1 >> 3) & 3;
+    const layer = (b1 >> 1) & 3;
+    const bitrateIndex = b2 >> 4;
+    const sampleRateIndex = (b2 >> 2) & 3;
+    const sampleRates = SAMPLE_RATES[version];
+    if (sampleRates === undefined || layer === 0 || bitrateIndex === 15 || sampleRateIndex === 3) {
+        return `invalid frame header at byte ${offset}`;
+    }
+    if (layer !== LAYER_III) {
+        return "MPEG layer I and II audio is not supported";
+    }
+    if (bitrateIndex === 0) {
+        return "free format MP3 files are not supported";
+    }
+    const mpeg1 = version === MPEG1;
+    const sampleRate = sampleRates[sampleRateIndex];
+    const bitrate = (mpeg1 ? MPEG1_BITRATES : MPEG2_BITRATES)[bitrateIndex];
+    const length = Math.floor(((mpeg1 ? 144000 : 72000) * bitrate) / sampleRate) + ((b2 >> 1) & 1);
+    const mono = b3 >> 6 === MONO;
+    const sideInfoSize = mpeg1 ? (mono ? 17 : 32) : mono ? 9 : 17;
+    // A protection bit of 0 means a 16-bit checksum follows the header.
+    const sideInfoStart = b1 & 1 ? 4 : 6;
+    if (length < sideInfoStart + sideInfoSize) {
+        return `invalid frame header at byte ${offset}`;
+    }
+    return { version, sampleRate, length, sideInfoStart, sideInfoSize };
+}
+/**
+ * Reads a Xing, Info or VBRI header frame: the samples added before and after the recording, and
+ * the frame count it states. Undefined when the frame holds audio instead.
+ */
+function readHeaderFrame(data, offset, header) {
+    var _a;
+    // Fields that would run past the end of the frame are absent, not read from the next frame.
+    const frame = data.subarray(offset, offset + header.length);
+    // Encoders place the Xing tag after the side information as if the frame had no checksum.
+    const xing = 4 + header.sideInfoSize;
+    if (!hasBytes(frame, xing, "Xing") && !hasBytes(frame, xing, "Info")) {
+        return hasBytes(frame, 36, "VBRI") ? NO_HEADER_FRAME : undefined;
+    }
+    const flags = (_a = uint32BE(frame, xing + 4)) !== null && _a !== void 0 ? _a : 0;
+    let position = xing + 8;
+    let statedFrames;
+    if (flags & 1) {
+        statedFrames = uint32BE(frame, position);
+        position += 4;
+    }
+    // The byte count, table of contents and quality follow when their flags are set.
+    position += (flags & 2 ? 4 : 0) + (flags & 4 ? 100 : 0) + (flags & 8 ? 4 : 0);
+    if (position + 24 > frame.length || !LAME_TAG_ENCODERS.some((encoder) => hasBytes(frame, position, encoder))) {
+        return { leadingSamples: 0, trailingSamples: 0, statedFrames };
+    }
+    // Two 12-bit counts after the encoder's name and other settings: the samples the encoder added
+    // before the recording, and after it. The decoder's own delay precedes both.
+    const b0 = frame[position + 21];
+    const b1 = frame[position + 22];
+    const b2 = frame[position + 23];
+    const delay = (b0 << 4) | (b1 >> 4);
+    const padding = ((b1 & 0x0f) << 8) | b2;
+    return {
+        leadingSamples: delay + DECODER_DELAY,
+        trailingSamples: Math.max(0, padding - DECODER_DELAY),
+        statedFrames,
+    };
+}
+/** Whether two frames in a row, of the same version and sample rate as `first`, start at or after `offset`. */
+function framesFollow(data, offset, first) {
+    // Requiring two frames in a row keeps bytes that happen to look like a frame header from counting.
+    let position = data.indexOf(0xff, offset);
+    while (position !== -1) {
+        const header = matchingHeader(data, position, first);
+        if (header !== undefined && matchingHeader(data, position + header.length, first) !== undefined) {
+            return true;
+        }
+        position = data.indexOf(0xff, position + 1);
+    }
+    return false;
+}
+function matchingHeader(data, offset, first) {
+    const header = tryReadHeader(data, offset);
+    if (typeof header === "string") {
+        return undefined;
+    }
+    return header.version === first.version && header.sampleRate === first.sampleRate ? header : undefined;
+}
+function unsupported(reason) {
+    return new UnsupportedAudioError(`The audio is not a supported MP3 file (${reason}). Convert it first, for example with: ${CONVERT_COMMAND}`);
+}

package/dist/esm/audio-helpers/results.d.mts

@@ -0,0 +1,74 @@
+import type { DecisionsUpload } from "../api/resources/decisions/client/requests/DecisionsUpload.mjs";
+import type { DecisionsResponse } from "../api/types/DecisionsResponse.mjs";
+import { DecisionsError } from "../errors/DecisionsError.mjs";
+import { type iterAudioChunks } from "./chunks.mjs";
+import type { DownmixOptions } from "./files.mjs";
+interface ChunkPosition {
+    /** Position of the chunk in the recording, starting at 0. */
+    readonly index: number;
+    /**
+     * Where the chunk starts in the recording, in milliseconds. A span's `audioStartMs` and
+     * `audioEndMs` are measured from the start of the chunk, so add this to place the span in the
+     * recording. The first chunk of an MP3 file can start a few tens of milliseconds before 0.
+     */
+    readonly startMs: number;
+    /** Where the chunk ends in the recording, in milliseconds. */
+    readonly endMs: number;
+}
+interface SucceededChunk extends ChunkPosition {
+    readonly status: "succeeded";
+    /** The API's response for the chunk, unchanged. */
+    readonly response: DecisionsResponse;
+    readonly error?: undefined;
+}
+interface FailedChunk extends ChunkPosition {
+    readonly status: "failed";
+    readonly response?: undefined;
+    /**
+     * The error the request threw. When the response's body could not be read, a DecisionsError with
+     * no status code whose `cause` holds the parse error.
+     */
+    readonly error: DecisionsError;
+}
+interface NotAttemptedChunk extends ChunkPosition {
+    /** No request was sent for the chunk, so it was not billed. */
+    readonly status: "not_attempted";
+    readonly response?: undefined;
+    readonly error?: undefined;
+}
+/** The outcome of one chunk's request. Checking `status` narrows it to the chunk's response or error. */
+export type ChunkResult = SucceededChunk | FailedChunk | NotAttemptedChunk;
+export type ChunkStatus = ChunkResult["status"];
+/** The outcome of every chunk's request, in the order of the chunks. */
+export declare class ChunkedDecisionsResult {
+    /** One result for each chunk of the requested range. */
+    readonly chunks: readonly ChunkResult[];
+    /** The `startMs` the job was given, or 0 when it was given none. */
+    readonly startMs: number;
+    /**
+     * @param chunks The results of a job, such as those collected from `iterCreateChunked`, in order.
+     * @param startMs The `startMs` the job was given.
+     * @throws {TypeError} If `startMs` is not a safe integer.
+     */
+    constructor(chunks: Iterable<ChunkResult>, startMs?: number);
+    /** Each chunk's response, or undefined for a chunk without one, in the order of the chunks. */
+    get responses(): (DecisionsResponse | undefined)[];
+    /** Whether every chunk's request succeeded. */
+    get complete(): boolean;
+    /**
+     * The `startMs` to give a new job, with the same `endMs`, so that it sends again the audio from
+     * the chunk that stopped this job to the end. Earlier chunks that failed because their audio could
+     * not be decoded are not sent again. A WAV chunk's `endMs` is rounded to the millisecond, so the
+     * new job can skip or repeat a few samples where it starts. Undefined when no chunk stopped the job.
+     */
+    get resumeMs(): number | undefined;
+}
+type Create = (upload: DecisionsUpload & DownmixOptions) => Promise<DecisionsResponse>;
+/**
+ * Sends each chunk of `upload.file` with `create`, as `iterCreateChunked` describes. The options are
+ * checked by this call, and the file when iteration starts.
+ */
+export declare function sendChunks(create: Create, { request, file, ...options }: DecisionsUpload & iterAudioChunks.Options, signal: AbortSignal | undefined): AsyncGenerator<ChunkResult, void, undefined>;
+/** Collects the results of `iterCreateChunked` for `createChunked`. */
+export declare function collectResults(results: AsyncIterable<ChunkResult>, startMs: number | undefined): Promise<ChunkedDecisionsResult>;
+export {};

package/dist/esm/audio-helpers/results.mjs

@@ -0,0 +1,181 @@
+// Maintained by hand and listed in .fernignore, so SDK regeneration leaves it in place.
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { BadRequestError } from "../api/errors/BadRequestError.mjs";
+import { ParseError } from "../core/schemas/index.mjs";
+import { DecisionsError } from "../errors/DecisionsError.mjs";
+import { checkInteger } from "./checks.mjs";
+import { prepareChunks } from "./chunks.mjs";
+/** The outcome of every chunk's request, in the order of the chunks. */
+export class ChunkedDecisionsResult {
+    /**
+     * @param chunks The results of a job, such as those collected from `iterCreateChunked`, in order.
+     * @param startMs The `startMs` the job was given.
+     * @throws {TypeError} If `startMs` is not a safe integer.
+     */
+    constructor(chunks, startMs) {
+        this.startMs = startMs === undefined ? 0 : checkInteger("startMs", startMs);
+        this.chunks = Object.freeze(Array.from(chunks));
+    }
+    /** Each chunk's response, or undefined for a chunk without one, in the order of the chunks. */
+    get responses() {
+        return this.chunks.map((chunk) => chunk.response);
+    }
+    /** Whether every chunk's request succeeded. */
+    get complete() {
+        return this.chunks.every((chunk) => chunk.status === "succeeded");
+    }
+    /**
+     * The `startMs` to give a new job, with the same `endMs`, so that it sends again the audio from
+     * the chunk that stopped this job to the end. Earlier chunks that failed because their audio could
+     * not be decoded are not sent again. A WAV chunk's `endMs` is rounded to the millisecond, so the
+     * new job can skip or repeat a few samples where it starts. Undefined when no chunk stopped the job.
+     */
+    get resumeMs() {
+        const rule = new StopRule();
+        for (let position = 0; position < this.chunks.length; position++) {
+            rule.record(this.chunks[position]);
+            if (rule.stopped) {
+                // An MP3 chunk's startMs includes frames repeated from before it, so resuming there
+                // would send those again as new audio.
+                return position > 0 ? this.chunks[position - 1].endMs : this.startMs;
+            }
+        }
+        return undefined;
+    }
+}
+/**
+ * Sends each chunk of `upload.file` with `create`, as `iterCreateChunked` describes. The options are
+ * checked by this call, and the file when iteration starts.
+ */
+export function sendChunks(create, _a, signal) {
+    var { request, file } = _a, options = __rest(_a, ["request", "file"]);
+    return send(create, request, prepareChunks(file, options), signal);
+}
+function send(create, request, planRecording, signal) {
+    return __asyncGenerator(this, arguments, function* send_1() {
+        // Planning reads and checks the whole file, so a file that cannot be split is rejected before
+        // any request is sent.
+        const { filename, contentType, chunks } = yield __await(planRecording(signal));
+        const rule = new StopRule();
+        // A chunk's data is copied only when it is sent, so the chunks after a stop cost nothing.
+        for (const chunk of chunks) {
+            const position = { index: chunk.index, startMs: chunk.startMs, endMs: chunk.endMs };
+            let result = Object.assign(Object.assign({}, position), { status: "not_attempted" });
+            if (!rule.stopped) {
+                try {
+                    const response = yield __await(create({
+                        request,
+                        file: { data: chunk.build(), filename, contentType },
+                        // The chunks were mixed down when they were planned.
+                        downmixStrategy: "none",
+                    }));
+                    result = Object.assign(Object.assign({}, position), { status: "succeeded", response });
+                }
+                catch (raised) {
+                    // An abort ends the job rather than failing one chunk. Anything other than a
+                    // DecisionsError did not come from the request, so it is not a chunk's outcome either,
+                    // except a ParseError: the generated client throws one when a response body is not the
+                    // JSON it expects for the status, such as a proxy's HTML error page, and the status is
+                    // lost with it.
+                    if ((signal === null || signal === void 0 ? void 0 : signal.aborted) || !(raised instanceof DecisionsError || raised instanceof ParseError)) {
+                        throw raised;
+                    }
+                    const error = raised instanceof ParseError
+                        ? new DecisionsError({ message: "The API's response could not be read.", cause: raised })
+                        : raised;
+                    result = Object.assign(Object.assign({}, position), { status: "failed", error });
+                }
+            }
+            rule.record(result);
+            yield yield __await(result);
+        }
+    });
+}
+/** Collects the results of `iterCreateChunked` for `createChunked`. */
+export function collectResults(results, startMs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, results_1, results_1_1;
+        var _b, e_1, _c, _d;
+        const collected = [];
+        try {
+            for (_a = true, results_1 = __asyncValues(results); results_1_1 = yield results_1.next(), _b = results_1_1.done, !_b; _a = true) {
+                _d = results_1_1.value;
+                _a = false;
+                const result = _d;
+                collected.push(result);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_a && !_b && (_c = results_1.return)) yield _c.call(results_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return new ChunkedDecisionsResult(collected, startMs);
+    });
+}
+// Sending chunks and finding resumeMs in a finished result must agree on which chunk stopped the job,
+// so both feed the chunks through this in order.
+class StopRule {
+    constructor() {
+        this._stopped = false;
+        this.anySucceeded = false;
+    }
+    get stopped() {
+        return this._stopped;
+    }
+    record(chunk) {
+        // A decode failure can come from one damaged stretch of the recording, but until some chunk has
+        // decoded, the whole file is the likelier cause and every remaining chunk would fail the same
+        // way. Any other error, including codes the API adds later, is assumed to fail every remaining
+        // chunk, so sending them would only spend requests. The generated client has already retried
+        // rate limits and server errors before throwing.
+        const failsAlone = this.anySucceeded &&
+            chunk.error instanceof BadRequestError &&
+            chunk.error.body.code === "audio_decode_failed";
+        if (chunk.status === "failed" && !failsAlone) {
+            this._stopped = true;
+        }
+        this.anySucceeded || (this.anySucceeded = chunk.status === "succeeded");
+    }
+}

package/dist/esm/audio-helpers/wav.d.mts

@@ -0,0 +1,21 @@
+export interface WavAudio {
+    /** The fmt chunk body written into every chunk. */
+    readonly fmt: Uint8Array;
+    readonly channels: number;
+    /** The speaker of each channel, from an extensible header, or 0 when the header names none. */
+    readonly channelMask: number;
+    readonly sampleRate: number;
+    /** Bytes in one sample of one channel. */
+    readonly sampleWidth: number;
+    readonly isFloat: boolean;
+    readonly dataStart: number;
+    readonly sampleCount: number;
+    /** Bytes in one sample of every channel. */
+    readonly frameBytes: number;
+}
+export declare function isWav(data: Uint8Array): boolean;
+export declare function parseWav(data: Uint8Array): WavAudio;
+/** Describes samples that start at offset 0 of their own buffer. */
+export declare function samplesWav({ channels, sampleRate, sampleWidth, isFloat, sampleCount, }: Pick<WavAudio, "channels" | "sampleRate" | "sampleWidth" | "isFloat" | "sampleCount">): WavAudio;
+/** Builds a WAV file holding samples `start` to `end` and none of the source's other chunks. */
+export declare function wavChunk(data: Uint8Array, wav: WavAudio, start: number, end: number): Uint8Array;