@rimelabs/sdk 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/stt/queue.d.ts

@@ -0,0 +1,16 @@
+import type { TranscriptionUpdate } from "./types.js";
+/** Bounded, atomic transcript events; failure wakes producers and consumers. */
+export declare class TranscriptQueue {
+    private readonly limit;
+    private items;
+    private closed;
+    private error;
+    private waiters;
+    constructor(limit: number);
+    private wait;
+    private wake;
+    put(value: TranscriptionUpdate): Promise<void>;
+    get(): Promise<IteratorResult<TranscriptionUpdate>>;
+    finish(): void;
+    fail(error: Error): void;
+}

package/dist/stt/queue.js

@@ -0,0 +1,45 @@
+/** Bounded, atomic transcript events; failure wakes producers and consumers. */
+export class TranscriptQueue {
+    limit;
+    items = [];
+    closed = false;
+    error = null;
+    waiters = new Set();
+    constructor(limit) {
+        this.limit = limit;
+    }
+    wait() {
+        return new Promise((resolve) => this.waiters.add(resolve));
+    }
+    wake() {
+        for (const resolve of this.waiters)
+            resolve();
+        this.waiters.clear();
+    }
+    async put(value) {
+        while (!this.closed && this.items.length >= this.limit)
+            await this.wait();
+        if (!this.closed) {
+            this.items.push(value);
+            this.wake();
+        }
+    }
+    async get() {
+        while (!this.closed && !this.items.length)
+            await this.wait();
+        if (this.error)
+            throw this.error;
+        const value = this.items.shift();
+        this.wake();
+        return value ? { done: false, value } : { done: true, value: undefined };
+    }
+    finish() {
+        this.closed = true;
+        this.wake();
+    }
+    fail(error) {
+        this.error ??= error;
+        this.items = [];
+        this.finish();
+    }
+}

package/dist/stt/stream.d.ts

@@ -0,0 +1,48 @@
+import type * as grpc from "@grpc/grpc-js";
+import type { AudioSource, TranscriptionOptions, TranscriptionUpdate } from "./types.js";
+interface StreamOwner {
+    prepare(signal: AbortSignal): Promise<{
+        client: grpc.Client;
+        metadata: grpc.Metadata;
+    }>;
+    checkOpen(): void;
+    forget(stream: TranscriptStream): void;
+}
+/** Lazy, single-consumer stream. Source exhaustion commits input; return/cancel aborts it. */
+export declare class TranscriptStream implements AsyncIterableIterator<TranscriptionUpdate> {
+    private readonly owner;
+    private source;
+    private readonly options;
+    private readonly controller;
+    private readonly queue;
+    private readonly timers;
+    private worker;
+    private workerFinished;
+    private call;
+    private failure;
+    private reading;
+    private finished;
+    private inputDone;
+    private accepted;
+    private readonly acceptance;
+    private admission;
+    private completion;
+    private readonly externalAbort;
+    constructor(owner: StreamOwner, source: AudioSource | null, options: TranscriptionOptions);
+    /** Server request identity, available once response headers arrive. */
+    get requestId(): string | null;
+    private deadline;
+    private start;
+    private fail;
+    private produce;
+    private read;
+    private run;
+    [Symbol.asyncIterator](): this;
+    next(): Promise<IteratorResult<TranscriptionUpdate>>;
+    private cleanup;
+    /** Cancel unfinished work and release owned resources; safe to repeat. */
+    cancel(): Promise<void>;
+    return(): Promise<IteratorResult<TranscriptionUpdate>>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export {};

package/dist/stt/stream.js

@@ -0,0 +1,224 @@
+import { abortable, scope } from "../cancellation.js";
+import { RimeError, RimeInputError, RimeCancelledError, RimeTimeoutError, RimeStreamError, } from "../errors.js";
+import { InputAudio } from "./audio.js";
+import { TranscriptQueue } from "./queue.js";
+import { TranscriptState } from "./protocol.js";
+import { TranscriptionCall } from "./transport.js";
+import { policy } from "./policy.js";
+/** Lazy, single-consumer stream. Source exhaustion commits input; return/cancel aborts it. */
+export class TranscriptStream {
+    owner;
+    source;
+    options;
+    controller = new AbortController();
+    queue = new TranscriptQueue(policy.queuedUpdates);
+    timers = new Set();
+    worker = null;
+    workerFinished = false;
+    call = null;
+    failure = null;
+    reading = false;
+    finished = false;
+    inputDone = false;
+    accepted;
+    acceptance = new Promise((resolve) => {
+        this.accepted = resolve;
+    });
+    admission = null;
+    completion = null;
+    externalAbort = () => this.fail(new RimeCancelledError("Transcription cancelled"));
+    constructor(owner, source, options) {
+        this.owner = owner;
+        this.source = source;
+        this.options = options;
+    }
+    /** Server request identity, available once response headers arrive. */
+    get requestId() {
+        return this.call?.requestId ?? null;
+    }
+    deadline(seconds, message) {
+        const timer = scope([], seconds, new RimeTimeoutError(message));
+        timer.signal.addEventListener("abort", () => this.fail(timer.signal.reason), { once: true });
+        if (timer.signal.aborted)
+            this.fail(timer.signal.reason);
+        this.timers.add(timer);
+        return timer;
+    }
+    start() {
+        if (this.failure)
+            throw this.failure;
+        if (this.finished || this.worker)
+            return;
+        this.owner.checkOpen();
+        if (this.options.signal?.aborted) {
+            this.externalAbort();
+            throw this.failure;
+        }
+        this.options.signal?.addEventListener("abort", this.externalAbort, {
+            once: true,
+        });
+        if (this.options.timeout != null)
+            this.deadline(this.options.timeout, "Overall transcription deadline expired");
+        this.worker = this.run();
+    }
+    fail(error) {
+        if (this.failure || this.finished)
+            return;
+        if (error.requestId === null && this.requestId !== null)
+            error = new error.constructor(error.message, this.requestId, { cause: error.cause });
+        this.failure = error;
+        this.queue.fail(error);
+        for (const timer of this.timers)
+            timer.dispose();
+        this.controller.abort(error);
+        this.call?.cancel();
+        this.options.signal?.removeEventListener("abort", this.externalAbort);
+        if (!this.worker || this.workerFinished) {
+            this.source = null;
+            this.owner.forget(this);
+        }
+    }
+    async produce() {
+        const signal = this.controller.signal;
+        await abortable(this.acceptance, signal);
+        const audio = new InputAudio(this.options.inputFormat);
+        let iterator;
+        try {
+            try {
+                iterator = this.source[Symbol.asyncIterator]();
+            }
+            catch (error) {
+                throw new RimeInputError("The audio source failed", this.requestId, {
+                    cause: error,
+                });
+            }
+            for (;;) {
+                let result;
+                try {
+                    result = await abortable(iterator.next(), signal);
+                }
+                catch (error) {
+                    if (signal.aborted)
+                        throw signal.reason;
+                    throw new RimeInputError("The audio source failed", this.requestId, {
+                        cause: error,
+                    });
+                }
+                if (result.done)
+                    break;
+                for (const part of audio.feed(result.value))
+                    await this.call.writeAudio(part);
+            }
+            audio.finish();
+            this.inputDone = true;
+            this.completion = this.deadline(policy.completionTimeout, "Transcription completion timed out");
+            this.call.finishInput();
+        }
+        finally {
+            if (iterator?.return) {
+                const cleanup = scope([], policy.cleanupTimeout, new RimeTimeoutError("Audio source cleanup timed out"));
+                try {
+                    await abortable(Promise.resolve().then(() => iterator.return()), cleanup.signal);
+                }
+                catch {
+                    /* Caller-owned source cleanup cannot replace the operation outcome. */
+                }
+                finally {
+                    cleanup.dispose();
+                }
+            }
+        }
+    }
+    async read() {
+        const state = new TranscriptState(policy.transcriptBytes, this.options.outputContract);
+        for await (const message of this.call.responses()) {
+            const update = state.accept(message, this.inputDone);
+            if (state.language !== null) {
+                this.admission?.dispose();
+                this.accepted();
+            }
+            if (update)
+                await this.queue.put(update);
+        }
+        return state.finish();
+    }
+    async run() {
+        let tasks = [];
+        try {
+            const prepared = await this.owner.prepare(this.controller.signal);
+            this.controller.signal.throwIfAborted();
+            this.call = new TranscriptionCall(prepared.client, prepared.metadata, this.controller.signal);
+            this.admission = this.deadline(policy.acceptanceTimeout, "Transcription acceptance timed out");
+            await this.call.start(this.options.language, this.options.mode ?? "written", this.options.contextTerms ?? [], this.options.outputContract);
+            const producer = this.produce(), reader = this.read();
+            tasks = [producer, reader];
+            const [, final] = await Promise.all([producer, reader]);
+            this.completion?.dispose();
+            await this.queue.put(final);
+            this.queue.finish();
+        }
+        catch (error) {
+            this.fail(error instanceof RimeError
+                ? error
+                : new RimeStreamError("Transcription failed", this.requestId, {
+                    cause: error,
+                }));
+        }
+        finally {
+            if (this.failure)
+                this.controller.abort(this.failure);
+            this.call?.cancel();
+            await Promise.allSettled(tasks);
+            this.source = null;
+            this.workerFinished = true;
+            if (this.failure)
+                this.owner.forget(this);
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    async next() {
+        if (this.reading)
+            throw new RimeInputError("TranscriptStream permits only one concurrent reader");
+        this.reading = true;
+        try {
+            this.start();
+            if (this.finished)
+                return { done: true, value: undefined };
+            const result = await this.queue.get();
+            if (this.failure)
+                throw this.failure;
+            if (!result.done && result.value.kind === "final") {
+                await this.cleanup();
+                if (this.failure)
+                    throw this.failure;
+                this.finished = true;
+            }
+            return result;
+        }
+        finally {
+            this.reading = false;
+        }
+    }
+    async cleanup() {
+        await this.worker;
+        for (const timer of this.timers)
+            timer.dispose();
+        this.options.signal?.removeEventListener("abort", this.externalAbort);
+        this.owner.forget(this);
+    }
+    /** Cancel unfinished work and release owned resources; safe to repeat. */
+    async cancel() {
+        this.fail(new RimeCancelledError("Transcription cancelled"));
+        await this.cleanup();
+        this.source = null;
+    }
+    async return() {
+        await this.cancel();
+        return { done: true, value: undefined };
+    }
+    async [Symbol.asyncDispose]() {
+        await this.cancel();
+    }
+}

package/dist/stt/transport.d.ts

@@ -0,0 +1,15 @@
+import * as grpc from "@grpc/grpc-js";
+import * as schema from "@rimelabs/api";
+import { BidiCall } from "../grpc.js";
+import type { TranscriptionMode, TranscribeOptions, Transcription } from "./types.js";
+export declare const MAX_WAV_BYTES: number;
+export declare function requireSchema(): void;
+export declare const transport: {
+    makeClient: (target: string) => grpc.Client;
+};
+export declare function transcribe(client: grpc.Client, auth: grpc.Metadata, audio: Uint8Array, options: TranscribeOptions, signal: AbortSignal): Promise<Transcription>;
+export declare class TranscriptionCall extends BidiCall<schema.StreamingTranscriptionRequest, schema.StreamingTranscriptionResponse> {
+    constructor(client: grpc.Client, auth: grpc.Metadata, signal: AbortSignal);
+    start(language: string, mode: TranscriptionMode, contextTerms: readonly string[], outputContract?: import("./types.js").TranscriptionOutputContract): Promise<void>;
+    writeAudio(audio: Uint8Array): Promise<void>;
+}

package/dist/stt/transport.js

@@ -0,0 +1,94 @@
+import * as grpc from "@grpc/grpc-js";
+import { create } from "@bufbuild/protobuf";
+import * as schema from "@rimelabs/api";
+import { BidiCall, serializer, deserializer, requestId, nativeError, } from "../grpc.js";
+import { abortable, scope } from "../cancellation.js";
+import { RimeInputError, RimeStreamError, RimeResourceLimitError, RimeTimeoutError, RimeCancelledError, } from "../errors.js";
+import { policy } from "./policy.js";
+export const MAX_WAV_BYTES = 16 * 1024 * 1024;
+export function requireSchema() {
+    if (!schema.SpeechToText)
+        throw new RimeInputError("STT requires @rimelabs/api with SpeechToText definitions");
+}
+export const transport = {
+    makeClient: (target) => new grpc.Client(target, grpc.credentials.createSsl(), {
+        "grpc.enable_retries": 0,
+        "grpc.max_receive_message_length": policy.receiveBytes,
+        "grpc.max_send_message_length": MAX_WAV_BYTES + 65536,
+    }),
+};
+export async function transcribe(client, auth, audio, options, signal) {
+    const method = schema.SpeechToText.method.transcribe;
+    const deadline = scope([signal], policy.completionTimeout, new RimeTimeoutError("Transcription request timed out"));
+    let call;
+    let id = null;
+    try {
+        deadline.signal.throwIfAborted();
+        const result = await abortable(new Promise((resolve, reject) => {
+            call = client.makeUnaryRequest(`/${schema.SpeechToText.typeName}/${method.name}`, serializer(method.input), deserializer(method.output), create(method.input, {
+                audio,
+                options: {
+                    language: options.language,
+                    mode: options.mode === "verbatim"
+                        ? schema.TranscriptionMode.VERBATIM
+                        : schema.TranscriptionMode.WRITTEN,
+                    contextTerms: [...(options.contextTerms ?? [])],
+                },
+            }), auth, (error, response) => (error ? reject(error) : resolve(response)));
+            call.on("metadata", (headers) => {
+                id = requestId(headers);
+            });
+            call.on("status", (status) => {
+                id ??= requestId(status.metadata);
+            });
+        }), deadline.signal);
+        if (!result.language?.tag || !result.language.source)
+            throw new RimeStreamError("The service did not confirm a resolved language", id);
+        if (Buffer.byteLength(result.text) > policy.transcriptBytes)
+            throw new RimeResourceLimitError("The transcript exceeds the SDK text limit", id);
+        return { text: result.text, language: result.language.tag, requestId: id };
+    }
+    catch (error) {
+        if (deadline.signal.aborted) {
+            const reason = deadline.signal.reason;
+            if (reason instanceof RimeTimeoutError)
+                throw new RimeTimeoutError(reason.message, id);
+            throw new RimeCancelledError("Transcription cancelled", id);
+        }
+        throw nativeError(error, id);
+    }
+    finally {
+        call?.cancel();
+        deadline.dispose();
+    }
+}
+export class TranscriptionCall extends BidiCall {
+    constructor(client, auth, signal) {
+        requireSchema();
+        const service = schema.SpeechToText;
+        const method = service.method.transcribeStreaming;
+        super(client.makeBidiStreamRequest(`/${service.typeName}/${method.name}`, serializer(method.input), deserializer(method.output), auth), signal);
+    }
+    start(language, mode, contextTerms, outputContract = "revised_hypotheses") {
+        return this.write(create(schema.StreamingTranscriptionRequestSchema, {
+            payload: {
+                case: "config",
+                value: {
+                    language,
+                    mode: mode === "verbatim"
+                        ? schema.TranscriptionMode.VERBATIM
+                        : schema.TranscriptionMode.WRITTEN,
+                    contextTerms: [...contextTerms],
+                    outputContract: outputContract === "append_fragments"
+                        ? schema.StreamingOutputContract.APPEND_FRAGMENTS
+                        : schema.StreamingOutputContract.REVISED_HYPOTHESES,
+                },
+            },
+        }));
+    }
+    writeAudio(audio) {
+        return this.write(create(schema.StreamingTranscriptionRequestSchema, {
+            payload: { case: "audio", value: audio },
+        }));
+    }
+}

package/dist/stt/types.d.ts

@@ -0,0 +1,51 @@
+import type { PCMFormat } from "../pcm.js";
+/** Formatting intent, for example "flight 247" or "flight two four seven". */
+export type TranscriptionMode = "written" | "verbatim";
+/** One caller-ended utterance of headerless signed PCM16 little-endian audio. */
+export type AudioSource = AsyncIterable<Uint8Array>;
+/** Select replacement hypotheses (default) or permanent append fragments. */
+export type TranscriptionOutputContract = "revised_hypotheses" | "append_fragments";
+export interface TranscriptionDelta {
+    readonly kind: "delta";
+    /** Append exactly, preserving the server's newline separators. */
+    readonly text: string;
+}
+export interface TranscriptionOptions {
+    /** Defaults to revised_hypotheses. Each stream uses one fixed contract. */
+    outputContract?: TranscriptionOutputContract;
+    /** Required BCP-47 tag, passed unchanged to the service (for example "en"). */
+    language: string;
+    /** Formatting intent; defaults to written and does not guarantee exact tokens. */
+    mode?: TranscriptionMode;
+    /** Recognition hints passed unchanged and in order, for example ["Super-G"]. */
+    contextTerms?: readonly string[];
+    /** Defaults to PCM16 little-endian mono 16 kHz; fixed for the utterance. */
+    inputFormat?: PCMFormat;
+    /** Optional overall deadline in seconds, including source and consumer pauses. */
+    timeout?: number | null;
+    /** Cancels only this utterance, including a pending connection. */
+    signal?: AbortSignal;
+}
+export interface TranscriptionPartial {
+    /** A revisable replacement snapshot. */
+    readonly kind: "partial";
+    /** Complete current text; replace previous text instead of appending it. */
+    readonly text: string;
+}
+export interface TranscriptionFinal {
+    /** Successful protocol and transport completion. */
+    readonly kind: "final";
+    /** Complete final text; silence can produce an empty string. */
+    readonly text: string;
+    /** Canonical BCP-47 tag selected by the service, for example "en". */
+    readonly language: string;
+}
+export type TranscriptionUpdate = TranscriptionPartial | TranscriptionDelta | TranscriptionFinal;
+/** Options for a complete WAV recording. Audio is sent unchanged. */
+export type TranscribeOptions = Omit<TranscriptionOptions, "inputFormat" | "outputContract">;
+/** A successful whole-recording transcription. Silence may produce empty text. */
+export interface Transcription {
+    readonly text: string;
+    readonly language: string;
+    readonly requestId: string | null;
+}

package/dist/stt/types.js

@@ -0,0 +1 @@
+export {};

package/dist/{audio.d.ts → tts/audio.d.ts}

@@ -1,11 +1,20 @@
 export declare class AudioFormat {
     readonly encoding: string;
+    /** Fixed preset rate, or zero when selected per request. See AudioStream.sampleRate. */
     readonly sampleRate: number;
     readonly channels: number;
+    static readonly PCM: Readonly<AudioFormat>;
+    static readonly WAV: Readonly<AudioFormat>;
+    static readonly MP3: Readonly<AudioFormat>;
     static readonly PCM_24000: Readonly<AudioFormat>;
     static readonly MULAW_8000: Readonly<AudioFormat>;
     private constructor();
 }
+export declare function wireFormat(format: AudioFormat): string;
+export declare function resolveAudio(format: AudioFormat | null | undefined, sampleRate: number | null | undefined, timeScaleFactor: number | null | undefined): {
+    format: AudioFormat;
+    sampleRate: number;
+};
 export declare class Converter {
     private profile;
     private tail;

package/dist/{audio.js → tts/audio.js}

@@ -1,16 +1,52 @@
-import { RimeAudioFormatError } from "./errors.js";
+import { RimeAudioFormatError, RimeInputError } from "../errors.js";
 export class AudioFormat {
     encoding;
     sampleRate;
     channels;
+    static PCM = Object.freeze(new AudioFormat("pcm_s16le", 0, 1));
+    static WAV = Object.freeze(new AudioFormat("wav", 0, 1));
+    static MP3 = Object.freeze(new AudioFormat("mp3", 0, 1));
     static PCM_24000 = Object.freeze(new AudioFormat("pcm_s16le", 24000, 1));
     static MULAW_8000 = Object.freeze(new AudioFormat("mulaw", 8000, 1));
-    constructor(encoding, sampleRate, channels) {
+    constructor(encoding, 
+    /** Fixed preset rate, or zero when selected per request. See AudioStream.sampleRate. */
+    sampleRate, channels) {
         this.encoding = encoding;
         this.sampleRate = sampleRate;
         this.channels = channels;
     }
 }
+export function wireFormat(format) {
+    if (format === AudioFormat.WAV)
+        return "audio/wav";
+    if (format === AudioFormat.MP3)
+        return "audio/mpeg";
+    return "audio/pcm";
+}
+export function resolveAudio(format, sampleRate, timeScaleFactor) {
+    format ??= AudioFormat.PCM;
+    if (![
+        AudioFormat.PCM,
+        AudioFormat.PCM_24000,
+        AudioFormat.MULAW_8000,
+        AudioFormat.WAV,
+        AudioFormat.MP3,
+    ].includes(format))
+        throw new RimeAudioFormatError("Select a named AudioFormat");
+    sampleRate ??= format.sampleRate || 24000;
+    if (![8000, 16000, 24000].includes(sampleRate))
+        throw new RimeAudioFormatError("sampleRate must be 8000, 16000, or 24000");
+    if (format.sampleRate && sampleRate !== format.sampleRate)
+        throw new RimeAudioFormatError("sampleRate conflicts with the fixed AudioFormat preset");
+    if (timeScaleFactor != null &&
+        (!Number.isFinite(timeScaleFactor) ||
+            timeScaleFactor < 0.4 ||
+            timeScaleFactor > 2.5))
+        throw new RimeInputError("timeScaleFactor must be a finite number from 0.4 to 2.5");
+    if (format === AudioFormat.PCM && sampleRate === 24000)
+        format = AudioFormat.PCM_24000;
+    return { format, sampleRate };
+}
 const raw = Array.from({ length: 63 }, (_, i) => (i === 31
     ? (2 * 3400) / 24000
     : Math.sin(((2 * Math.PI * 3400) / 24000) * (i - 31)) /
@@ -20,7 +56,8 @@ const total = raw.reduce((a, b) => a + b, 0);
 const coefficients = raw.map((x) => x / total);
 function mulaw(sample) {
     sample = Math.max(-32768, Math.min(32767, sample));
-    const sign = sample < 0 ? 128 : 0, magnitude = Math.min(Math.abs(sample), 32635) + 132;
+    // G.711 uses one's complement for negative PCM before quantization.
+    const sign = sample < 0 ? 128 : 0, magnitude = Math.min(sample < 0 ? ~sample : sample, 32635) + 132;
     const exponent = Math.max(0, Math.floor(Math.log2(magnitude)) - 7);
     return ~(sign | (exponent << 4) | ((magnitude >> (exponent + 3)) & 15)) & 255;
 }
@@ -46,12 +83,15 @@ export class Converter {
         return null;
     }
     process(input, final = false) {
+        if (this.profile === AudioFormat.WAV || this.profile === AudioFormat.MP3)
+            return Buffer.from(input);
         const data = Buffer.concat([this.tail, input]);
         const size = Math.floor(data.length / 2) * 2;
         this.tail = Buffer.from(data.subarray(size));
         if (final && this.tail.length)
             throw new RimeAudioFormatError("Incomplete final PCM sample frame");
-        if (this.profile === AudioFormat.PCM_24000)
+        if (this.profile === AudioFormat.PCM ||
+            this.profile === AudioFormat.PCM_24000)
             return data.subarray(0, size);
         const result = [];
         for (let i = 0; i < size; i += 2) {

package/dist/tts/buffer.d.ts

@@ -0,0 +1,3 @@
+export declare const maxBufferBytes: number;
+/** Validate mono PCM16 WAV and replace unknown streaming chunk lengths. */
+export declare function finalizeWav(data: Buffer, sampleRate: number, requestId: string | null): void;

package/dist/tts/buffer.js

@@ -0,0 +1,53 @@
+import { RimeAudioFormatError } from "../errors.js";
+export const maxBufferBytes = 64 * 1024 * 1024;
+/** Validate mono PCM16 WAV and replace unknown streaming chunk lengths. */
+export function finalizeWav(data, sampleRate, requestId) {
+    const invalid = () => new RimeAudioFormatError("Expected a complete mono PCM16 WAV at the requested sample rate", requestId);
+    if (data.length < 12 ||
+        data.toString("latin1", 0, 4) !== "RIFF" ||
+        data.toString("latin1", 8, 12) !== "WAVE")
+        throw invalid();
+    if (data.length - 8 > 0xffffffff)
+        throw new RimeAudioFormatError("Audio exceeds the WAV size limit", requestId);
+    if (![0xffffffff, data.length - 8].includes(data.readUInt32LE(4)))
+        throw invalid();
+    let offset = 12;
+    let foundFormat = false;
+    let dataSizeOffset;
+    let dataSize = 0;
+    while (offset < data.length) {
+        if (data.length - offset < 8)
+            throw invalid();
+        const name = data.toString("latin1", offset, offset + 4);
+        let size = data.readUInt32LE(offset + 4);
+        const start = offset + 8;
+        if (name === "data" && size === 0xffffffff)
+            size = data.length - start;
+        const end = start + size;
+        if (end > data.length)
+            throw invalid();
+        if (name === "fmt ") {
+            if (foundFormat ||
+                size < 16 ||
+                data.readUInt16LE(start) !== 1 ||
+                data.readUInt16LE(start + 2) !== 1 ||
+                data.readUInt32LE(start + 4) !== sampleRate ||
+                data.readUInt32LE(start + 8) !== sampleRate * 2 ||
+                data.readUInt16LE(start + 12) !== 2 ||
+                data.readUInt16LE(start + 14) !== 16)
+                throw invalid();
+            foundFormat = true;
+        }
+        else if (name === "data") {
+            if (!foundFormat || dataSizeOffset !== undefined || size % 2)
+                throw invalid();
+            dataSizeOffset = offset + 4;
+            dataSize = size;
+        }
+        offset = end + (size % 2);
+    }
+    if (offset !== data.length || dataSizeOffset === undefined)
+        throw invalid();
+    data.writeUInt32LE(data.length - 8, 4);
+    data.writeUInt32LE(dataSize, dataSizeOffset);
+}