@rimelabs/sdk 0.1.0-alpha.1 → 0.1.0-alpha.12

package/dist/auth.js

@@ -1,6 +1,6 @@
-import { policy, abortable } from "./policy.js";
+import { abortable } from "./cancellation.js";
 import { RimeError, RimeAuthenticationError, RimePermissionError, RimeTimeoutError, RimeCancelledError, RimeResourceLimitError, RimeUnavailableError, } from "./errors.js";
-export async function exchangeKey(key, signal, configuration = policy) {
+export async function exchangeKey(key, signal, configuration) {
     try {
         const response = await fetch(configuration.exchangeUrl, {
             method: "POST",
@@ -77,17 +77,25 @@ export class Credentials {
     refreshAt = 0;
     controller = new AbortController();
     closed = false;
-    constructor(key, configuration = policy) {
+    constructor(key, configuration) {
         this.key = key;
         this.configuration = configuration;
     }
+    authorization() {
+        if (this.closed)
+            throw new RimeAuthenticationError("Credentials are closed");
+        return `Bearer ${this.key}`;
+    }
+    realtimeAuthorization() {
+        return this.authorization();
+    }
     async metadata(signal) {
         // TEMPORARY until Themis is ready: replace this body with the call below.
         // return this.themisMetadata(signal);
         if (this.closed)
             throw new RimeAuthenticationError("Credentials are closed");
         signal.throwIfAborted();
-        return `Bearer ${this.key}`;
+        return this.authorization();
     }
     async themisMetadata(signal) {
         if (this.closed)

package/dist/cancellation.d.ts

@@ -0,0 +1,6 @@
+export declare function abortable<T>(promise: PromiseLike<T>, signal: AbortSignal): Promise<T>;
+/** A disposable deadline avoids retaining timers and caller abort listeners. */
+export declare function scope(signals: (AbortSignal | undefined)[], seconds?: number, error?: Error): {
+    signal: AbortSignal;
+    dispose(): void;
+};

package/dist/cancellation.js

@@ -0,0 +1,54 @@
+export function abortable(promise, signal) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            signal.removeEventListener("abort", abort);
+            reject(signal.reason);
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        Promise.resolve(promise).then((value) => {
+            signal.removeEventListener("abort", abort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", abort);
+            reject(error);
+        });
+    });
+}
+/** A disposable deadline avoids retaining timers and caller abort listeners. */
+export function scope(signals, seconds, error) {
+    const controller = new AbortController();
+    const handlers = new Map();
+    for (const signal of new Set(signals)) {
+        if (!signal)
+            continue;
+        const abort = () => controller.abort(signal.reason);
+        if (signal.aborted)
+            abort();
+        else {
+            signal.addEventListener("abort", abort, { once: true });
+            handlers.set(signal, abort);
+        }
+    }
+    let timer;
+    if (seconds !== undefined) {
+        const end = performance.now() + seconds * 1000;
+        const expire = () => {
+            const remaining = end - performance.now();
+            if (remaining <= 0)
+                controller.abort(error);
+            else
+                timer = setTimeout(expire, Math.min(remaining, 2147483647));
+        };
+        expire();
+    }
+    return {
+        signal: controller.signal,
+        dispose() {
+            clearTimeout(timer);
+            for (const [signal, handler] of handlers)
+                signal.removeEventListener("abort", handler);
+        },
+    };
+}

package/dist/client.d.ts

@@ -1,33 +1,36 @@
-import { AudioFormat } from "./audio.js";
-import { AudioStream, type TextSource } from "./stream.js";
+import type { AudioSource, TranscriptionOptions } from "./stt/types.js";
+import type { TranscriptStream } from "./stt/stream.js";
+import { type SynthesisOptions, type DiscoveryOptions, type VoiceListOptions } from "./tts/client.js";
+import { type AudioStream, type TextSource } from "./tts/stream.js";
+import type { RealtimeConnectOptions } from "./realtime/types.js";
+import type { RealtimeSession } from "./realtime/session.js";
+export type { SynthesisOptions, DiscoveryOptions, VoiceListOptions, } from "./tts/client.js";
 export interface RimeOptions {
     apiKey?: string | null;
+    /** Select "coda" (default) or "mistv3" for speech and discovery. */
     model?: string;
     endpoint?: string | null;
     timeout?: number | null;
-}
-export interface SynthesisOptions {
-    voice?: string | null;
-    language?: string;
-    audioFormat?: AudioFormat | null;
-    timeout?: number | null;
-}
-export interface DiscoveryOptions {
-    timeout?: number | null;
-}
-export interface VoiceListOptions extends DiscoveryOptions {
-    language?: string | null;
+    /** Recognition hostname and optional port; defaults to stt.api.rime.ai:443. */
+    sttEndpoint?: string | null;
 }
 export declare class Rime {
-    private readonly deployment;
-    private credentials;
-    private client;
+    private readonly credentials;
+    private readonly ttsClient;
+    private readonly sttClient;
+    readonly stt: {
+        stream: (audio: AudioSource, options: TranscriptionOptions) => TranscriptStream;
+    };
+    private readonly realtimeClient;
+    readonly realtime: {
+        connect: (options: RealtimeConnectOptions) => Promise<RealtimeSession>;
+    };
     private closed;
-    private streams;
-    private discoveryControllers;
     private closing;
-    private defaultTimeout;
     readonly tts: {
+        /** Synthesize complete text and return streaming audio. Do not await this call. */
+        synthesize: (text: string, options?: SynthesisOptions) => AudioStream;
+        /** Supply incremental text and return streaming audio. Do not await this call. */
         stream: (text: TextSource, options?: SynthesisOptions) => AudioStream;
     };
     readonly voices: {
@@ -38,9 +41,6 @@ export declare class Rime {
     };
     constructor(options?: RimeOptions);
     private checkOpen;
-    private prepare;
-    private stream;
-    private discover;
     close(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
 }

package/dist/client.js

@@ -1,18 +1,18 @@
-import { AudioFormat } from "./audio.js";
-import { AudioStream, constructionKey } from "./stream.js";
+import { STT } from "./stt/client.js";
 import { Credentials } from "./auth.js";
-import { policy, resolve, timeout, nonempty, abortable } from "./policy.js";
-import { transport, connect, metadata, discover, } from "./transport.js";
-import { RimeAuthenticationError, RimeInputError, RimeAudioFormatError, RimeCancelledError, RimeTimeoutError, RimeUnavailableError, } from "./errors.js";
+import { RimeAuthenticationError, RimeInputError } from "./errors.js";
+import { TTS, } from "./tts/client.js";
+import { resolve, timeout } from "./tts/policy.js";
+import { Realtime } from "./realtime/client.js";
 export class Rime {
-    deployment;
     credentials;
-    client = null;
+    ttsClient;
+    sttClient;
+    stt;
+    realtimeClient;
+    realtime;
     closed = false;
-    streams = new Set();
-    discoveryControllers = new Set();
     closing = null;
-    defaultTimeout;
     tts;
     voices;
     languages;
@@ -22,99 +22,46 @@ export class Rime {
             : options.apiKey;
         if (typeof key !== "string" || !key.trim())
             throw new RimeAuthenticationError("Provide apiKey or set RIME_API_KEY");
-        this.defaultTimeout = timeout(options.timeout);
-        this.deployment = resolve(options.model ?? "coda", options.endpoint);
-        this.credentials = new Credentials(key, this.deployment);
-        this.tts = { stream: (text, options = {}) => this.stream(text, options) };
-        this.voices = {
-            list: async (options = {}) => {
-                if (options.language !== undefined && options.language !== null)
-                    nonempty(options.language, "language");
-                return this.discover("voices", options.language, options.timeout);
-            },
+        const defaultTimeout = timeout(options.timeout);
+        const deployment = resolve(options.model ?? "coda", options.endpoint);
+        this.credentials = new Credentials(key, deployment);
+        this.sttClient = new STT(this.credentials, options.sttEndpoint, () => this.checkOpen());
+        this.stt = {
+            stream: (audio, options) => this.sttClient.stream(audio, options),
         };
-        this.languages = {
-            list: (options = {}) => this.discover("languages", undefined, options.timeout),
+        this.realtimeClient = new Realtime(this.credentials, () => this.checkOpen());
+        this.realtime = {
+            connect: (options) => this.realtimeClient.connect(options),
         };
+        this.ttsClient = new TTS(this.credentials, deployment, defaultTimeout, () => this.checkOpen());
+        this.tts = {
+            synthesize: (text, options) => this.ttsClient.synthesize(text, options),
+            stream: (text, options) => this.ttsClient.stream(text, options),
+        };
+        this.voices = this.ttsClient.voices;
+        this.languages = this.ttsClient.languages;
     }
     checkOpen() {
         if (this.closed)
             throw new RimeInputError("The Rime client is closed");
     }
-    async prepare(signal) {
-        this.checkOpen();
-        const auth = await this.credentials.metadata(signal);
-        this.checkOpen();
-        this.client ??= transport.makeClient(this.deployment.target);
-        await connect(this.client, signal);
-        return { client: this.client, metadata: metadata(auth) };
-    }
-    stream(text, options) {
-        this.checkOpen();
-        if (typeof text === "string") {
-            if (!text.trim())
-                throw new RimeInputError("Text must contain non-whitespace characters");
-        }
-        else if (!text || typeof text[Symbol.asyncIterator] !== "function")
-            throw new RimeInputError("text must be a string or an async iterable of strings");
-        const voice = options.voice === undefined || options.voice === null
-            ? "clementine"
-            : nonempty(options.voice, "voice");
-        const language = nonempty(options.language ?? "en", "language");
-        const format = options.audioFormat ?? AudioFormat.PCM_24000;
-        if (format !== AudioFormat.PCM_24000 && format !== AudioFormat.MULAW_8000)
-            throw new RimeAudioFormatError("Select a named AudioFormat profile");
-        const audio = new AudioStream(constructionKey, {
-            prepare: (s) => this.prepare(s),
-            checkOpen: () => this.checkOpen(),
-            forget: (s) => this.streams.delete(s),
-        }, text, voice, language, format, timeout(options.timeout, this.defaultTimeout));
-        this.streams.add(audio);
-        return audio;
-    }
-    async discover(kind, language, override) {
-        this.checkOpen();
-        const budget = Math.min(timeout(override, this.defaultTimeout) ?? Infinity, policy.discoveryTimeout);
-        const controller = new AbortController();
-        let requestId = null;
-        this.discoveryControllers.add(controller);
-        const timer = setTimeout(() => controller.abort(new RimeTimeoutError("Discovery deadline expired")), budget * 1000);
-        try {
-            const prepared = await this.prepare(controller.signal);
-            for (let attempt = 0;; attempt++) {
-                requestId = null;
-                try {
-                    return await discover(prepared, kind, language, controller.signal);
-                }
-                catch (error) {
-                    if (!(error instanceof RimeUnavailableError) || attempt === 2)
-                        throw error;
-                    requestId = error.requestId;
-                    await abortable(new Promise((resolve) => setTimeout(resolve, 50 * 2 ** attempt)), controller.signal);
-                }
-            }
-        }
-        catch (error) {
-            if (error instanceof RimeTimeoutError && requestId !== null)
-                throw new RimeTimeoutError(error.message, requestId, {
-                    cause: error.cause,
-                });
-            throw error;
-        }
-        finally {
-            clearTimeout(timer);
-            this.discoveryControllers.delete(controller);
-        }
-    }
     async close() {
         if (!this.closing) {
             this.closed = true;
             this.closing = (async () => {
-                for (const controller of this.discoveryControllers)
-                    controller.abort(new RimeCancelledError("Client closed during discovery"));
-                await Promise.all([...this.streams].map((stream) => stream.cancel()));
-                await this.credentials.close();
-                this.client?.close();
+                try {
+                    const results = await Promise.allSettled([
+                        this.ttsClient.close(),
+                        this.sttClient.close(),
+                        this.realtimeClient.close(),
+                    ]);
+                    for (const result of results)
+                        if (result.status === "rejected")
+                            throw result.reason;
+                }
+                finally {
+                    await this.credentials.close();
+                }
             })();
         }
         await this.closing;

package/dist/grpc.d.ts

@@ -0,0 +1,27 @@
+import * as grpc from "@grpc/grpc-js";
+import { type DescMessage, type MessageShape } from "@bufbuild/protobuf";
+import * as errors from "./errors.js";
+export declare function rpcError(code: number, requestId?: string | null): errors.RimeError;
+export declare function serializer<D extends DescMessage>(desc: D): (message: MessageShape<D>) => Buffer<ArrayBuffer>;
+export declare function deserializer<D extends DescMessage>(desc: D): (data: Buffer) => MessageShape<D>;
+export declare function requestId(metadata?: grpc.Metadata): string | null;
+export declare function nativeError(error: unknown, id: string | null): errors.RimeError;
+export declare class BidiCall<Input, Output> {
+    private readonly call;
+    private signal;
+    private readonly metadataPromise;
+    private readonly statusPromise;
+    private status;
+    private id;
+    constructor(call: grpc.ClientDuplexStream<Input, Output>, signal: AbortSignal);
+    get requestId(): string | null;
+    get done(): boolean;
+    cancel(): void;
+    private error;
+    write(message: Input): Promise<void>;
+    finishInput(): void;
+    headers(): Promise<grpc.Metadata>;
+    responses(): AsyncGenerator<Output>;
+}
+export declare function connect(client: grpc.Client, signal: AbortSignal, seconds: number): Promise<void>;
+export declare function metadata(value: string): grpc.Metadata;

package/dist/{transport.js → grpc.js}

@@ -1,7 +1,6 @@
+import { abortable } from "./cancellation.js";
 import * as grpc from "@grpc/grpc-js";
-import { create, fromBinary, toBinary, } from "@bufbuild/protobuf";
-import * as schema from "@rimelabs/api";
-import { policy, abortable } from "./policy.js";
+import { fromBinary, toBinary, } from "@bufbuild/protobuf";
 import * as errors from "./errors.js";
 export function rpcError(code, requestId = null) {
     const classes = {
@@ -16,53 +15,16 @@ export function rpcError(code, requestId = null) {
     const ErrorType = classes[code] ?? errors.RimeStreamError;
     return new ErrorType(`Rime operation failed: ${grpc.status[code] ?? "UNKNOWN"}`, requestId);
 }
-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": policy.sentenceBytes + 65536,
-    }),
-};
-function serializer(desc) {
+export function serializer(desc) {
     return (message) => Buffer.from(toBinary(desc, message));
 }
-function deserializer(desc) {
+export function deserializer(desc) {
     return (data) => fromBinary(desc, data);
 }
-export async function connect(client, signal) {
-    await abortable(new Promise((resolve, reject) => client.waitForReady(Date.now() + policy.connectionTimeout * 1000, (error) => error
-        ? reject(new errors.RimeTimeoutError("Connection establishment timed out"))
-        : resolve())), signal);
-}
-export function metadata(value) {
-    const result = new grpc.Metadata();
-    result.set("authorization", value);
-    return result;
-}
-function openStream(client, auth) {
-    return client.makeBidiStreamRequest("/rime.TextToSpeech/SynthesizeStreaming", serializer(schema.StreamingSynthesisRequestSchema), deserializer(schema.SynthesisResponseStreamSchema), auth);
-}
-function header(voice, language) {
-    return create(schema.StreamingSynthesisRequestSchema, {
-        payload: {
-            case: "header",
-            value: create(schema.SynthesisRequestSchema, {
-                speaker: voice,
-                language,
-                audioParameters: { audioFormat: "audio/pcm", samplingRate: 24000 },
-            }),
-        },
-    });
-}
-function textMessage(text) {
-    return create(schema.StreamingSynthesisRequestSchema, {
-        payload: { case: "textChunk", value: text },
-    });
-}
-function requestId(metadata) {
+export function requestId(metadata) {
     return metadata?.get("x-request-id")[0]?.toString() ?? null;
 }
-function nativeError(error, id) {
+export function nativeError(error, id) {
     if (error instanceof errors.RimeError)
         return error;
     if (error &&
@@ -72,56 +34,20 @@ function nativeError(error, id) {
         const metadata = "metadata" in error ? error.metadata : null;
         return rpcError(error.code, id ?? (metadata instanceof grpc.Metadata ? requestId(metadata) : null));
     }
-    return new errors.RimeStreamError("Coda transport failed", id, {
+    return new errors.RimeStreamError("Rime transport failed", id, {
         cause: error,
     });
 }
-async function unary(prepared, name, input, output, request, signal) {
-    let call;
-    let id = null;
-    try {
-        signal.throwIfAborted();
-        const operation = new Promise((resolve, reject) => {
-            call = prepared.client.makeUnaryRequest("/rime.TextToSpeech/" + name, serializer(input), deserializer(output), request, prepared.metadata, (error, result) => (error ? reject(error) : resolve(result)));
-            call.once("metadata", (metadata) => {
-                id = requestId(metadata);
-            });
-        });
-        return await abortable(operation, signal);
-    }
-    catch (error) {
-        call?.cancel();
-        if (signal.aborted) {
-            if (signal.reason instanceof errors.RimeTimeoutError)
-                throw new errors.RimeTimeoutError(signal.reason.message, id, {
-                    cause: signal.reason.cause,
-                });
-            throw signal.reason;
-        }
-        throw nativeError(error, id);
-    }
-}
-export async function discover(prepared, kind, language, signal) {
-    // Exactly one attempt. The client owns retries and the shared deadline.
-    if (kind === "voices") {
-        const method = schema.TextToSpeech.method.getSupportedSpeakers;
-        const response = await unary(prepared, method.name, method.input, method.output, create(method.input, { language: language ?? undefined }), signal);
-        return response.speakers;
-    }
-    const method = schema.TextToSpeech.method.getSupportedLanguages;
-    const response = await unary(prepared, method.name, method.input, method.output, create(method.input), signal);
-    return response.languages;
-}
-export class SynthesisCall {
-    signal;
+export class BidiCall {
     call;
+    signal;
     metadataPromise;
     statusPromise;
     status = null;
     id = null;
-    constructor(prepared, signal) {
+    constructor(call, signal) {
+        this.call = call;
         this.signal = signal;
-        this.call = openStream(prepared.client, prepared.metadata);
         this.metadataPromise = new Promise((resolve, reject) => {
             this.call.once("metadata", (metadata) => {
                 this.id = requestId(metadata);
@@ -155,7 +81,7 @@ export class SynthesisCall {
         this.id ??= failure.requestId;
         return failure;
     }
-    async writeMessage(message) {
+    async write(message) {
         try {
             this.signal.throwIfAborted();
             if (this.status) {
@@ -180,13 +106,6 @@ export class SynthesisCall {
             throw this.error(error);
         }
     }
-    async start(voice, language) {
-        // Writes do not depend on response metadata.
-        await this.writeMessage(header(voice, language));
-    }
-    async write(sentence) {
-        await this.writeMessage(textMessage(sentence));
-    }
     finishInput() {
         try {
             this.call.end();
@@ -195,24 +114,25 @@ export class SynthesisCall {
             throw this.error(error);
         }
     }
-    checkFormat(contentType) {
-        if (contentType !== "audio/pcm")
-            throw new errors.RimeAudioFormatError("Expected raw audio/pcm from the service", this.id);
+    async headers() {
+        try {
+            return await abortable(this.metadataPromise, this.signal);
+        }
+        catch (error) {
+            if (this.signal.aborted)
+                throw this.signal.reason;
+            throw this.error(error);
+        }
     }
-    async *audio() {
+    async *responses() {
         try {
-            const metadata = await abortable(this.metadataPromise, this.signal);
-            const contentType = metadata.get("x-rime-audio-content-type")[0];
-            for await (const response of this.call) {
-                if (response.audio.length)
-                    this.checkFormat(contentType);
-                yield response.audio;
-            }
+            await this.headers();
+            const responses = this.call;
+            for await (const response of responses)
+                yield response;
             const status = await abortable(this.statusPromise, this.signal);
             if (status.code !== grpc.status.OK)
                 throw rpcError(status.code, this.id);
-            // Validate empty success only after giving a rejection its proper error.
-            this.checkFormat(contentType);
         }
         catch (error) {
             if (this.signal.aborted)
@@ -221,3 +141,13 @@ export class SynthesisCall {
         }
     }
 }
+export async function connect(client, signal, seconds) {
+    await abortable(new Promise((resolve, reject) => client.waitForReady(Date.now() + seconds * 1000, (error) => error
+        ? reject(new errors.RimeTimeoutError("Connection establishment timed out"))
+        : resolve())), signal);
+}
+export function metadata(value) {
+    const result = new grpc.Metadata();
+    result.set("authorization", value);
+    return result;
+}

package/dist/index.d.ts

@@ -1,4 +1,8 @@
 export { Rime, type RimeOptions, type SynthesisOptions, type DiscoveryOptions, type VoiceListOptions, } from "./client.js";
-export { AudioStream } from "./stream.js";
-export { AudioFormat } from "./audio.js";
+export { AudioStream } from "./tts/stream.js";
+export { AudioFormat } from "./tts/audio.js";
 export * from "./errors.js";
+export { RealtimeSession } from "./realtime/session.js";
+export * from "./realtime/types.js";
+export { TranscriptStream } from "./stt/stream.js";
+export type { AudioSource, TranscriptionOptions, TranscriptionMode, TranscriptionPartial, TranscriptionFinal, TranscriptionUpdate, } from "./stt/types.js";

package/dist/index.js

@@ -1,4 +1,7 @@
 export { Rime, } from "./client.js";
-export { AudioStream } from "./stream.js";
-export { AudioFormat } from "./audio.js";
+export { AudioStream } from "./tts/stream.js";
+export { AudioFormat } from "./tts/audio.js";
 export * from "./errors.js";
+export { RealtimeSession } from "./realtime/session.js";
+export * from "./realtime/types.js";
+export { TranscriptStream } from "./stt/stream.js";

package/dist/pcm.d.ts

@@ -0,0 +1,21 @@
+/** Headerless signed little-endian PCM16; stereo samples are interleaved. */
+export interface PCMFormat {
+    /** Input frames per second; omitted means 16000. */
+    readonly sampleRate?: 8000 | 16000 | 24000 | 48000;
+    /** Samples per frame; omitted means one (mono). */
+    readonly channels?: 1 | 2;
+    /** Two-byte signed samples with no file header. */
+    readonly encoding?: "pcm_s16le";
+}
+export declare function resolvePCMFormat(input?: PCMFormat): Required<PCMFormat>;
+/** Streaming linear interpolation, matching Python audioop.ratecv with no filter.
+ * Integer phase remains bounded and preserves samples across chunk boundaries.
+ */
+export declare class InputConverter {
+    readonly format: Required<PCMFormat>;
+    private phase;
+    private previous;
+    constructor(format: Required<PCMFormat>);
+    clone(): InputConverter;
+    process(input: Uint8Array): Buffer;
+}

package/dist/pcm.js

@@ -0,0 +1,52 @@
+import { RimeAudioFormatError } from "./errors.js";
+export function resolvePCMFormat(input) {
+    if (input !== undefined &&
+        (input === null || typeof input !== "object" || Array.isArray(input)))
+        throw new RimeAudioFormatError("Input format must be a PCM format object");
+    const format = {
+        sampleRate: input?.sampleRate ?? 16000,
+        channels: input?.channels ?? 1,
+        encoding: input?.encoding ?? "pcm_s16le",
+    };
+    if (![8000, 16000, 24000, 48000].includes(format.sampleRate) ||
+        ![1, 2].includes(format.channels) ||
+        format.encoding !== "pcm_s16le")
+        throw new RimeAudioFormatError("Use PCM16 at 8, 16, 24 or 48 kHz, with one or two channels");
+    return format;
+}
+/** Streaming linear interpolation, matching Python audioop.ratecv with no filter.
+ * Integer phase remains bounded and preserves samples across chunk boundaries.
+ */
+export class InputConverter {
+    format;
+    phase = -16000;
+    previous = 0;
+    constructor(format) {
+        this.format = format;
+    }
+    clone() {
+        const copy = new InputConverter(this.format);
+        copy.phase = this.phase;
+        copy.previous = this.previous;
+        return copy;
+    }
+    process(input) {
+        const data = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+        const samples = [];
+        for (let offset = 0; offset < data.length; offset += this.format.channels * 2) {
+            const current = this.format.channels === 1
+                ? data.readInt16LE(offset)
+                : Math.floor((data.readInt16LE(offset) + data.readInt16LE(offset + 2)) / 2);
+            this.phase += 16000;
+            while (this.phase >= 0) {
+                samples.push(Math.floor((this.previous * this.phase + current * (16000 - this.phase)) /
+                    16000));
+                this.phase -= this.format.sampleRate;
+            }
+            this.previous = current;
+        }
+        const output = Buffer.alloc(samples.length * 2);
+        samples.forEach((sample, index) => output.writeInt16LE(sample, index * 2));
+        return output;
+    }
+}