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

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.1.0-alpha.12](https://github.com/rimelabs/rime-sdk/compare/typescript-v0.1.0-alpha.11...typescript-v0.1.0-alpha.12) (2026-10-10)
+
+
+### ⚠ BREAKING CHANGES
+
+* Use synthesize for complete text and stream for incremental text in all SDKs. Go StreamSource becomes Stream. Rust synthesis moves under Client::tts(). Both methods return streaming audio.
+
+### Features
+
+* align TTS APIs and SDK example workflows ([#49](https://github.com/rimelabs/rime-sdk/issues/49)) ([bc2be77](https://github.com/rimelabs/rime-sdk/commit/bc2be779f7a845d51850fbe068a4cf6d95eab666))
+
+
+### Bug Fixes
+
+* **deps:** bump @rimelabs/api from 0.3.0 to 0.4.0 ([#54](https://github.com/rimelabs/rime-sdk/issues/54)) ([bc89e38](https://github.com/rimelabs/rime-sdk/commit/bc89e384a6555ed8bd31b94f62c1647662543769))
+
+## [0.1.0-alpha.11](https://github.com/rimelabs/rime-sdk/compare/typescript-v0.1.0-alpha.10...typescript-v0.1.0-alpha.11) (2026-10-09)
+
+
+### Features
+
+* add streaming STT to Python, Node.js, and Go ([#39](https://github.com/rimelabs/rime-sdk/issues/39)) ([79977ef](https://github.com/rimelabs/rime-sdk/commit/79977ef019bc474d799881e60223c6868af104d0))
+
 ## [0.1.0-alpha.10](https://github.com/rimelabs/rime-sdk/compare/typescript-v0.1.0-alpha.9...typescript-v0.1.0-alpha.10) (2026-10-08)
 
 

package/README.md

@@ -1,7 +1,8 @@
 # Rime SDK for Node.js
 
-Generate speech with TTS, or send speech to Prism and receive a spoken reply.
-Both APIs use the `Rime` client. Your application handles audio capture and playback.
+Generate speech with TTS, transcribe audio with STT, or send speech to Prism
+and receive a spoken reply. All use the `Rime` client. Your application handles
+audio capture and playback.
 
 ## Install
 
@@ -36,7 +37,7 @@ import { Rime } from "@rimelabs/sdk";
 const client = new Rime({ timeout: 60 });
 try {
   const chunks = [];
-  for await (const chunk of client.tts.stream(
+  for await (const chunk of client.tts.synthesize(
     "Your appointment is confirmed for tomorrow.",
   )) {
     chunks.push(Buffer.from(chunk));
@@ -59,10 +60,39 @@ This short example collects the audio in memory before writing the file.
 For long responses, write audio chunks as they arrive.
 
 Coda is the default model. Use `new Rime({ model: "mistv3" })` for Mist v3, or pass
-`{ voice: "your-voice" }` as the second argument to `client.tts.stream(...)` to select a voice.
+`{ voice: "your-voice" }` as the second argument to `client.tts.synthesize(...)` to select a voice.
 The default output is mono 24 kHz PCM16. The example adds its WAV header.
-To supply text from an LLM, pass an async iterable of strings instead of a string.
-The SDK handles sentence boundaries.
+Use `client.tts.synthesize(text)` for a complete string. To supply text from an LLM,
+pass an async iterable of strings to `client.tts.stream(chunks)`. Both methods
+return streaming audio. The SDK handles sentence boundaries.
+
+## STT quick start
+
+Stream one utterance of headerless signed PCM16 little-endian audio. Specify the
+spoken language; exhaust the audio source when the utterance ends. Each update
+replaces the complete current transcript.
+
+```javascript
+import { createReadStream } from "node:fs";
+import { Rime } from "@rimelabs/sdk";
+
+async function* audioChunks() {
+  yield* createReadStream("utterance.pcm");
+}
+
+const client = new Rime();
+try {
+  const transcript = client.stt.stream(audioChunks(), {
+    language: "en",
+  });
+  for await (const update of transcript) console.log(update.kind, update.text);
+} finally {
+  await client.close();
+}
+```
+
+Input defaults to 16 kHz mono. The [STT guide](https://github.com/rimelabs/rime-sdk/blob/main/typescript/docs/stt.md)
+covers other PCM formats, written/verbatim output, recognition hints and cancellation.
 
 ## Prism: send recorded speech
 

package/dist/auth.d.ts

@@ -21,6 +21,7 @@ export declare class Credentials {
     private controller;
     private closed;
     constructor(key: string, configuration: Readonly<AuthenticationConfiguration>);
+    authorization(): string;
     realtimeAuthorization(): string;
     metadata(signal: AbortSignal): Promise<string>;
     themisMetadata(signal: AbortSignal): Promise<string>;

package/dist/auth.js

@@ -81,18 +81,21 @@ export class Credentials {
         this.key = key;
         this.configuration = configuration;
     }
-    realtimeAuthorization() {
+    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

@@ -1 +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

@@ -16,3 +16,39 @@ export function abortable(promise, signal) {
         });
     });
 }
+/** 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,3 +1,5 @@
+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";
@@ -9,10 +11,16 @@ export interface RimeOptions {
     model?: string;
     endpoint?: string | null;
     timeout?: number | null;
+    /** Recognition hostname and optional port; defaults to stt.api.rime.ai:443. */
+    sttEndpoint?: string | null;
 }
 export declare class Rime {
     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>;
@@ -20,6 +28,9 @@ export declare class Rime {
     private closed;
     private closing;
     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: {

package/dist/client.js

@@ -1,3 +1,4 @@
+import { STT } from "./stt/client.js";
 import { Credentials } from "./auth.js";
 import { RimeAuthenticationError, RimeInputError } from "./errors.js";
 import { TTS, } from "./tts/client.js";
@@ -6,6 +7,8 @@ import { Realtime } from "./realtime/client.js";
 export class Rime {
     credentials;
     ttsClient;
+    sttClient;
+    stt;
     realtimeClient;
     realtime;
     closed = false;
@@ -22,12 +25,17 @@ export class Rime {
         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.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;
@@ -41,11 +49,19 @@ export class Rime {
         if (!this.closing) {
             this.closed = true;
             this.closing = (async () => {
-                await Promise.all([
-                    this.ttsClient.close(),
-                    this.realtimeClient.close(),
-                ]);
-                await this.credentials.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/grpc.js

@@ -0,0 +1,153 @@
+import { abortable } from "./cancellation.js";
+import * as grpc from "@grpc/grpc-js";
+import { fromBinary, toBinary, } from "@bufbuild/protobuf";
+import * as errors from "./errors.js";
+export function rpcError(code, requestId = null) {
+    const classes = {
+        [grpc.status.UNAUTHENTICATED]: errors.RimeAuthenticationError,
+        [grpc.status.PERMISSION_DENIED]: errors.RimePermissionError,
+        [grpc.status.INVALID_ARGUMENT]: errors.RimeInputError,
+        [grpc.status.RESOURCE_EXHAUSTED]: errors.RimeResourceLimitError,
+        [grpc.status.UNAVAILABLE]: errors.RimeUnavailableError,
+        [grpc.status.DEADLINE_EXCEEDED]: errors.RimeTimeoutError,
+        [grpc.status.CANCELLED]: errors.RimeCancelledError,
+    };
+    const ErrorType = classes[code] ?? errors.RimeStreamError;
+    return new ErrorType(`Rime operation failed: ${grpc.status[code] ?? "UNKNOWN"}`, requestId);
+}
+export function serializer(desc) {
+    return (message) => Buffer.from(toBinary(desc, message));
+}
+export function deserializer(desc) {
+    return (data) => fromBinary(desc, data);
+}
+export function requestId(metadata) {
+    return metadata?.get("x-request-id")[0]?.toString() ?? null;
+}
+export function nativeError(error, id) {
+    if (error instanceof errors.RimeError)
+        return error;
+    if (error &&
+        typeof error === "object" &&
+        "code" in error &&
+        typeof error.code === "number") {
+        const metadata = "metadata" in error ? error.metadata : null;
+        return rpcError(error.code, id ?? (metadata instanceof grpc.Metadata ? requestId(metadata) : null));
+    }
+    return new errors.RimeStreamError("Rime transport failed", id, {
+        cause: error,
+    });
+}
+export class BidiCall {
+    call;
+    signal;
+    metadataPromise;
+    statusPromise;
+    status = null;
+    id = null;
+    constructor(call, signal) {
+        this.call = call;
+        this.signal = signal;
+        this.metadataPromise = new Promise((resolve, reject) => {
+            this.call.once("metadata", (metadata) => {
+                this.id = requestId(metadata);
+                resolve(metadata);
+            });
+            // A trailers-only response has no metadata event.
+            this.call.once("status", () => resolve(new grpc.Metadata()));
+            this.call.once("error", reject);
+        });
+        this.metadataPromise.catch(() => { });
+        this.statusPromise = new Promise((resolve) => {
+            this.call.once("status", (status) => {
+                this.status = status;
+                this.id ??= requestId(status.metadata);
+                resolve(status);
+            });
+        });
+        this.call.on("error", () => { });
+    }
+    get requestId() {
+        return this.id;
+    }
+    get done() {
+        return this.status !== null || this.call.destroyed;
+    }
+    cancel() {
+        this.call.cancel();
+    }
+    error(error) {
+        const failure = nativeError(error, this.id);
+        this.id ??= failure.requestId;
+        return failure;
+    }
+    async write(message) {
+        try {
+            this.signal.throwIfAborted();
+            if (this.status) {
+                if (this.status.code !== grpc.status.OK)
+                    throw rpcError(this.status.code, this.id);
+                throw new errors.RimeStreamError("The service completed before input finished", this.id);
+            }
+            await abortable(new Promise((resolve, reject) => {
+                this.call.write(message, (error) => error ? reject(error) : resolve());
+            }), this.signal);
+        }
+        catch (error) {
+            if (this.signal.aborted)
+                throw this.signal.reason;
+            if (error instanceof errors.RimeError)
+                throw error;
+            // A native write error can precede the final status event. Preserve the
+            // server rejection even if the reader has not consumed a response.
+            const status = await abortable(this.statusPromise, this.signal);
+            if (status.code !== grpc.status.OK)
+                throw rpcError(status.code, this.id);
+            throw this.error(error);
+        }
+    }
+    finishInput() {
+        try {
+            this.call.end();
+        }
+        catch (error) {
+            throw this.error(error);
+        }
+    }
+    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 *responses() {
+        try {
+            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);
+        }
+        catch (error) {
+            if (this.signal.aborted)
+                throw this.signal.reason;
+            throw this.error(error);
+        }
+    }
+}
+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

@@ -4,3 +4,5 @@ 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

@@ -4,3 +4,4 @@ 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;
+    }
+}

package/dist/realtime/async.d.ts

@@ -1,3 +1,4 @@
+export { scope } from "../cancellation.js";
 export declare class Deferred<T> {
     readonly promise: Promise<T>;
     resolve: (value: T) => void;
@@ -16,11 +17,6 @@ export declare class Mutex {
     private waiters;
     acquire(signal: AbortSignal): Promise<() => void>;
 }
-/** 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;
-};
 export declare function cancellation(signal?: AbortSignal): {
     signal: AbortSignal;
     dispose: () => void | undefined;

package/dist/realtime/async.js

@@ -1,3 +1,4 @@
+export { scope } from "../cancellation.js";
 import { abortable } from "../cancellation.js";
 import { RimeCancelledError } from "../errors.js";
 export class Deferred {
@@ -72,42 +73,6 @@ export class Mutex {
         };
     }
 }
-/** 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);
-        },
-    };
-}
 export function cancellation(signal) {
     const controller = new AbortController();
     const abort = () => controller.abort(new RimeCancelledError("Realtime operation cancelled"));

package/dist/realtime/audio.d.ts

@@ -1,13 +1,2 @@
 import type { AudioChunk, PCMFormat } from "./types.js";
 export declare function formatOf(chunk: AudioChunk): 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/realtime/audio.js

@@ -1,14 +1,7 @@
 import { RimeAudioFormatError } from "../errors.js";
+import { resolvePCMFormat } from "../pcm.js";
 export function formatOf(chunk) {
-    const format = {
-        sampleRate: chunk.format?.sampleRate ?? 16000,
-        channels: chunk.format?.channels ?? 1,
-        encoding: chunk.format?.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");
+    const format = resolvePCMFormat(chunk.format);
     if (!(chunk.data instanceof Uint8Array) ||
         chunk.data.length % (2 * format.channels))
         throw new RimeAudioFormatError("Audio must contain complete PCM16 frames as Uint8Array");
@@ -16,39 +9,3 @@ export function formatOf(chunk) {
         throw new RimeAudioFormatError("Send audio in chunks of at most 192000 bytes");
     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;
-    }
-}