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

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.1.0-alpha.14](https://github.com/rimelabs/rime-sdk/compare/typescript-v0.1.0-alpha.13...typescript-v0.1.0-alpha.14) (2026-10-12)
+
+
+### Features
+
+* **tts:** add sample rates, time-scale control, and buffered audio output ([1856d0d](https://github.com/rimelabs/rime-sdk/commit/1856d0d6c00a46d7917b61d73bc7f2a8526c8bb0))
+
+## [0.1.0-alpha.13](https://github.com/rimelabs/rime-sdk/compare/typescript-v0.1.0-alpha.12...typescript-v0.1.0-alpha.13) (2026-10-11)
+
+
+### Bug Fixes
+
+* **tts:** remove complete-text synthesis option ([#61](https://github.com/rimelabs/rime-sdk/issues/61)) ([4e3c133](https://github.com/rimelabs/rime-sdk/commit/4e3c1338dc9b129a0201a462f12fb414eeb520d1))
+
 ## [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)
 
 

package/README.md

@@ -1,13 +1,13 @@
-# Rime SDK for Node.js
+# Rime SDK for TypeScript and Node.js
 
-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
+Generate speech with Coda or Mist v3, transcribe audio with STT, and build spoken
+conversations with Prism through the `Rime` client. Your application handles
 audio capture and playback.
 
-## Install
+## Installation
 
-Requires Node.js 22 or later. This alpha package uses ESM and includes TypeScript types.
-Run it on a server. Browser use is not supported.
+Requires **Node.js 22 or later**. Install the alpha package from npm. It uses
+ESM, includes TypeScript types, and runs on a server; browsers are not supported.
 
 ```sh
 mkdir rime-quickstart
@@ -17,82 +17,14 @@ npm install @rimelabs/sdk wavefile
 export RIME_API_KEY="your-api-key"
 ```
 
-Get a TTS API key from the [Rime dashboard](https://app.rime.ai/).
-An explicit `new Rime({ apiKey: "..." })` overrides `RIME_API_KEY`. The SDK does not load `.env` files.
-The commands below use a macOS or Linux shell.
+For an existing project, skip the first three commands. Get an API key from the
+[Rime dashboard](https://app.rime.ai/). A key is required: `new Rime()` reads
+`RIME_API_KEY`, or you can pass `new Rime({ apiKey: "..." })` to override it.
+The SDK does not load `.env` files. Shell commands below assume macOS or Linux.
 
-These examples use JavaScript `.mjs` files so you can run them without a TypeScript build.
-The additional [wavefile package](https://github.com/rochars/wavefile) reads and writes WAV files
-for the examples. It is not required by the SDK.
-
-## TTS: save speech
-
-Save this as `tts.mjs`. It writes a playable `speech.wav` file with no audio-device dependencies.
-
-```javascript
-import { writeFileSync } from "node:fs";
-import wavefile from "wavefile";
-import { Rime } from "@rimelabs/sdk";
-
-const client = new Rime({ timeout: 60 });
-try {
-  const chunks = [];
-  for await (const chunk of client.tts.synthesize(
-    "Your appointment is confirmed for tomorrow.",
-  )) {
-    chunks.push(Buffer.from(chunk));
-  }
-  const pcm = Buffer.concat(chunks);
-  const samples = Array.from({ length: pcm.length / 2 }, (_, i) =>
-    pcm.readInt16LE(i * 2),
-  );
-  const wav = new wavefile.WaveFile();
-  wav.fromScratch(1, 24000, "16", samples);
-  writeFileSync("speech.wav", wav.toBuffer());
-  console.log("Saved speech.wav");
-} finally {
-  await client.close();
-}
-```
-
-Run `node tts.mjs`, then open `speech.wav` in your audio player.
-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.synthesize(...)` to select a voice.
-The default output is mono 24 kHz PCM16. The example adds its WAV header.
-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.
+Examples use JavaScript `.mjs` files so you can run them without a TypeScript build.
+The additional `wavefile` dependency is only needed by the Prism example; TTS and
+STT use the SDK and Node.js built-ins.
 
 ## Prism: send recorded speech
 
@@ -195,11 +127,176 @@ stop playback on interruption, and report the actual played position to Prism.
 Keep the API key on your server when you add a browser interface.
 TTS settings do not configure Prism sessions.
 
+## TTS
+
+Use `client.tts.synthesize(text, options)` for a complete string, or
+`client.tts.stream(textChunks, options)` for an async iterable of strings.
+Both return an `AudioStream` immediately; consume it with `for await`, without
+awaiting the method call. For complete audio in memory, await
+`client.tts.synthesizeToBuffer(text, options)` to receive a Node.js `Buffer`.
+Text is required and must contain non-whitespace characters.
+
+### Client options
+
+These optional `new Rime({...})` fields configure TTS. They do not configure STT or Prism.
+
+| Option | Purpose and values | Required | Default |
+| --- | --- | --- | --- |
+| `model` | Select `"coda"` or `"mistv3"`. | No | `"coda"` |
+| `endpoint` | Override the TTS TLS hostname and optional port, such as `"coda.api.rime.ai:443"`; no scheme or path. | No | `coda.api.rime.ai:443` for Coda; `mist.api.rime.ai:443` for Mist v3. |
+| `timeout` | Overall TTS timeout in positive seconds, such as `60`; `null` disables it. | No | No overall timeout. |
+
+### Synthesis options
+
+All three TTS methods accept the same `SynthesisOptions` fields. Import
+`AudioFormat` from `@rimelabs/sdk` when selecting an encoding.
+
+| Option | Purpose and values | Required | Default |
+| --- | --- | --- | --- |
+| `voice` | Voice name for the selected model, such as `"clementine"` or `"astra"`. | No | `"clementine"` for Coda; `"astra"` for Mist v3. |
+| `language` | Spoken language code, such as `"en"` or `"es"`; the service validates support. | No | `"en"` |
+| `audioFormat` | Output encoding: `AudioFormat.PCM`, `.WAV`, `.MP3`, `.PCM_24000`, or `.MULAW_8000`. | No | Raw PCM16 at 24 kHz (`PCM_24000`). |
+| `sampleRate` | Requested output rate in Hz: `8000`, `16000`, or `24000`. | No | `24000`; `8000` for `MULAW_8000`. |
+| `timeScaleFactor` | Duration multiplier from `0.4` to `2.5`; below `1` speeds speech up, above `1` slows it down. | No | Omitted; normal duration (`1`). |
+| `timestamps` | `true` requests word timings; supported only with Mist v3. | No | `false` |
+| `customLexicon` | Array of `{ spelling, pronunciation }` entries for Coda; pronunciations use space-separated X-SAMPA strings. | No | Empty array. |
+| `timeout` | Override the overall timeout with positive seconds, or `null` to disable it. | No | Inherits the client timeout. |
+
+Discover valid values with `await client.voices.list({ language: "en" })` and
+`await client.languages.list()`. Omit the voice language filter to list all voices
+for the selected model. Both calls accept an options object with `timeout` in
+seconds; discovery has an additional ten-second maximum.
+
+### Example: save an IVR greeting
+
+Save as `tts.mjs`. This writes a complete 16 kHz WAV file, ready for playback or upload.
+
+```javascript
+import { writeFile } from "node:fs/promises";
+import { AudioFormat, Rime } from "@rimelabs/sdk";
+
+const client = new Rime({ timeout: 60 });
+try {
+  const audio = await client.tts.synthesizeToBuffer(
+    "Thank you for calling. Your appointment is confirmed for tomorrow.",
+    {
+      audioFormat: AudioFormat.WAV,
+      sampleRate: 16000,
+      timeScaleFactor: 0.9,
+    },
+  );
+  await writeFile("greeting.wav", audio);
+  console.log("Saved greeting.wav");
+} finally {
+  await client.close();
+}
+```
+
+Run `node tts.mjs`, then open `greeting.wav` in an audio player.
+
+### Audio and stream behavior
+
+All output is mono. PCM is signed 16-bit little-endian audio without a header;
+WAV contains PCM16; MP3 is encoded by the service. PCM/WAV rates are requested
+from the server. MP3 headers determine the actual encoded rate. The fixed
+`PCM_24000` and `MULAW_8000` presets reject conflicting sample rates; mu-law is
+converted locally from 24 kHz PCM. Read `audio.sampleRate` on an `AudioStream`
+for the requested rate.
+
+The buffer helper waits for successful completion and finalizes WAV lengths.
+Its fixed limit is **64 MiB per call**, including headers; exceeding it throws
+`RimeResourceLimitError` without returning partial audio. WAV/MP3 stream chunks
+are fragments of one file. Use the buffer helper when you need a complete WAV.
+
+For incremental text, send fragments as they arrive; the service combines them
+into sentences. Consume streaming audio to the end to confirm success, since an
+error can follow earlier audio. Use `await audio.cancel()` when stopping early
+and `await client.close()` in a `finally` block to release the client. Synthesis
+is not retried automatically, and overall timeouts include pauses by the caller;
+connection and progress limits also apply.
+
+For timestamps, enable `timestamps: true`, consume the audio stream fully, then
+call `await audio.timestamps()`. The result has `status` and `spans` with word
+text and start/end seconds. Nonzero alignment status does not fail the audio.
+The buffer helper returns only bytes, so use an audio stream to access timings.
+Custom lexicons apply to the whole request; the service validates pronunciations
+and model/language support.
+
+## STT
+
+Use `client.stt.stream(audioChunks, options)` to transcribe one utterance.
+The required source is an async iterable of headerless signed PCM16 little-endian
+`Uint8Array` chunks (`Buffer` also works). Ending the source ends the utterance;
+your application decides when to stop.
+
+STT uses streaming gRPC over TLS to `stt.api.rime.ai:443`, with the client's API
+key. There is no STT model, endpoint, or protocol selector. TTS client settings,
+including its timeout, do not apply to STT.
+
+### Transcription options
+
+Pass these fields in the required `TranscriptionOptions` object.
+
+| Option | Purpose and values | Required | Default |
+| --- | --- | --- | --- |
+| `language` | Spoken BCP-47 language tag, such as `"en"` or `"es"`; passed to the service. | Yes | None; no automatic detection. |
+| `mode` | `"written"` normalizes written text; `"verbatim"` prefers spoken wording. | No | `"written"` |
+| `contextTerms` | Array of recognition hints, such as `["Rime"]`; hints do not force a match. | No | Empty array. |
+| `inputFormat` | Object with `sampleRate` (`8000`, `16000`, `24000`, `48000`), `channels` (`1` or `2`), and `encoding` (only `"pcm_s16le"`). | No | 16 kHz mono PCM16; each field is optional. |
+| `timeout` | Overall timeout in positive seconds, including source/consumer pauses; `null` disables it. | No | No overall timeout; independent of the client timeout. |
+| `signal` | An `AbortSignal`, such as `controller.signal`, to cancel this utterance. | No | No signal. |
+
+### Example: transcribe a recording
+
+Save a short recording as `utterance.pcm`: **16 kHz, mono, signed PCM16
+little-endian, with no WAV header**. Save this as `stt.mjs`.
+
+```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",
+    timeout: 120,
+  });
+  for await (const update of transcript) {
+    console.log(update.kind, update.text);
+  }
+} finally {
+  await client.close();
+}
+```
+
+Run `node stt.mjs`. Each partial update replaces the **complete current
+transcript**; do not append snapshots. A final update confirms successful
+completion and may be empty for silence. Errors do not turn partials into finals.
+
+The SDK converts supported input formats to 16 kHz mono. Stereo must be
+interleaved. WAV headers, MP3, and mu-law input are not accepted. Chunks may split
+sample frames, but an incomplete final frame fails the request. The SDK does not
+provide microphone capture, automatic end-of-speech detection, word timings, or
+diarization. Recognition is not retried automatically.
+
+Use `await transcript.cancel()` or the supplied `AbortSignal` to stop one
+utterance. Closing the client cancels all its operations. Audio sources must
+yield without blocking the event loop. Connection, acceptance, and completion
+limits still apply when the overall timeout is disabled.
+
 ## Help and licenses
 
-See [Rime documentation](https://docs.rime.ai/) for API keys, TTS models, and deployment information.
-The examples above run with the installed package. No source checkout is required.
+See the [TTS guide](https://github.com/rimelabs/rime-sdk/blob/main/typescript/docs/tts.md),
+[STT guide](https://github.com/rimelabs/rime-sdk/blob/main/typescript/docs/stt.md), and
+[Prism guide](https://github.com/rimelabs/rime-sdk/blob/main/typescript/docs/realtime.md)
+for more examples. Visit [Rime documentation](https://docs.rime.ai/) for service
+information, or report SDK issues on [GitHub](https://github.com/rimelabs/rime-sdk/issues).
+Include the SDK version and the error's `requestId` when available; omit API keys.
 
-SDK code uses the MIT license. The Prism protocol module uses Apache 2.0.
-BlingFire retains its MIT license. License texts and notices are included in the package.
-Its WASM runtime ships with the package. The SDK downloads no code or models at runtime.
+SDK code uses the [MIT license](LICENSE). The Prism protocol module uses
+[Apache 2.0](LICENSE-PRISM); see its [notices](NOTICE-PRISM).
+License texts and notices are included in the distribution.

package/dist/client.d.ts

@@ -11,8 +11,6 @@ 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;
@@ -30,6 +28,8 @@ export declare class Rime {
     readonly tts: {
         /** Synthesize complete text and return streaming audio. Do not await this call. */
         synthesize: (text: string, options?: SynthesisOptions) => AudioStream;
+        /** Await complete audio bytes, finalizing WAV lengths. Fixed output limit: 64 MiB. */
+        synthesizeToBuffer: (text: string, options?: SynthesisOptions) => Promise<Buffer>;
         /** Supply incremental text and return streaming audio. Do not await this call. */
         stream: (text: TextSource, options?: SynthesisOptions) => AudioStream;
     };

package/dist/client.js

@@ -25,7 +25,7 @@ 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.sttClient = new STT(this.credentials, () => this.checkOpen());
         this.stt = {
             stream: (audio, options) => this.sttClient.stream(audio, options),
         };
@@ -36,6 +36,7 @@ export class Rime {
         this.ttsClient = new TTS(this.credentials, deployment, defaultTimeout, () => this.checkOpen());
         this.tts = {
             synthesize: (text, options) => this.ttsClient.synthesize(text, options),
+            synthesizeToBuffer: (text, options) => this.ttsClient.synthesizeToBuffer(text, options),
             stream: (text, options) => this.ttsClient.stream(text, options),
         };
         this.voices = this.ttsClient.voices;

package/dist/grpc.d.ts

@@ -1,7 +1,7 @@
 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 rpcError(code: number, requestId?: string | null, details?: string): 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;
@@ -18,10 +18,10 @@ export declare class BidiCall<Input, Output> {
     get done(): boolean;
     cancel(): void;
     private error;
-    write(message: Input): Promise<void>;
-    finishInput(): void;
     headers(): Promise<grpc.Metadata>;
     responses(): AsyncGenerator<Output>;
+    write(message: Input): Promise<void>;
+    finishInput(): void;
 }
 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

@@ -2,7 +2,7 @@ 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) {
+export function rpcError(code, requestId = null, details) {
     const classes = {
         [grpc.status.UNAUTHENTICATED]: errors.RimeAuthenticationError,
         [grpc.status.PERMISSION_DENIED]: errors.RimePermissionError,
@@ -13,7 +13,9 @@ export function rpcError(code, requestId = null) {
         [grpc.status.CANCELLED]: errors.RimeCancelledError,
     };
     const ErrorType = classes[code] ?? errors.RimeStreamError;
-    return new ErrorType(`Rime operation failed: ${grpc.status[code] ?? "UNKNOWN"}`, requestId);
+    return new ErrorType(details?.trim()
+        ? details
+        : `Rime operation failed: ${grpc.status[code] ?? "UNKNOWN"}`, requestId);
 }
 export function serializer(desc) {
     return (message) => Buffer.from(toBinary(desc, message));
@@ -32,7 +34,9 @@ export function nativeError(error, id) {
         "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 rpcError(error.code, id ?? (metadata instanceof grpc.Metadata ? requestId(metadata) : null), "details" in error && typeof error.details === "string"
+            ? error.details
+            : undefined);
     }
     return new errors.RimeStreamError("Rime transport failed", id, {
         cause: error,
@@ -81,16 +85,60 @@ export class BidiCall {
         this.id ??= failure.requestId;
         return failure;
     }
+    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, status.details);
+        }
+        catch (error) {
+            if (this.signal.aborted)
+                throw this.signal.reason;
+            throw this.error(error);
+        }
+    }
     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 rpcError(this.status.code, this.id, this.status.details);
                 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());
+                const finish = (error) => {
+                    this.call.removeListener("status", onStatus);
+                    if (error)
+                        reject(error);
+                    else
+                        resolve();
+                };
+                // A rejected native write can emit final status without invoking its
+                // callback (for example, when exceeding the send-message limit).
+                const onStatus = (status) => finish(status.code === grpc.status.OK
+                    ? new errors.RimeStreamError("The service completed before input finished", this.id)
+                    : rpcError(status.code, this.id, status.details));
+                this.call.once("status", onStatus);
+                try {
+                    this.call.write(message, finish);
+                }
+                catch (error) {
+                    finish(error);
+                }
             }), this.signal);
         }
         catch (error) {
@@ -102,7 +150,7 @@ export class BidiCall {
             // 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 rpcError(status.code, this.id, status.details);
             throw this.error(error);
         }
     }
@@ -114,32 +162,6 @@ export class BidiCall {
             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

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { Rime, type RimeOptions, type SynthesisOptions, type DiscoveryOptions, type VoiceListOptions, } from "./client.js";
 export { AudioStream } from "./tts/stream.js";
 export { AudioFormat } from "./tts/audio.js";
+export type { PronunciationEntry } from "./tts/lexicon.js";
+export type { TimestampResult, TimestampStatus, WordTimestamp, } from "./tts/timestamps.js";
 export * from "./errors.js";
 export { RealtimeSession } from "./realtime/session.js";
 export * from "./realtime/types.js";

package/dist/stt/client.d.ts

@@ -3,11 +3,10 @@ import { TranscriptStream } from "./stream.js";
 import type { AudioSource, TranscriptionOptions } from "./types.js";
 export declare class STT {
     private readonly credentials;
-    private readonly endpoint;
     private readonly checkOpen;
     private connection;
     private streams;
-    constructor(credentials: Credentials, endpoint: string | null | undefined, checkOpen: () => void);
+    constructor(credentials: Credentials, checkOpen: () => void);
     stream(source: AudioSource, options: TranscriptionOptions): TranscriptStream;
     close(): Promise<void>;
 }

package/dist/stt/client.js

@@ -1,5 +1,5 @@
 import { connect, metadata } from "../grpc.js";
-import { endpointAddress, timeout } from "../validation.js";
+import { timeout } from "../validation.js";
 import { RimeInputError } from "../errors.js";
 import { resolvePCMFormat } from "../pcm.js";
 import { transport, requireSchema } from "./transport.js";
@@ -7,13 +7,11 @@ import { TranscriptStream } from "./stream.js";
 import { policy } from "./policy.js";
 export class STT {
     credentials;
-    endpoint;
     checkOpen;
     connection = null;
     streams = new Set();
-    constructor(credentials, endpoint, checkOpen) {
+    constructor(credentials, checkOpen) {
         this.credentials = credentials;
-        this.endpoint = endpoint;
         this.checkOpen = checkOpen;
     }
     stream(source, options) {
@@ -29,9 +27,7 @@ export class STT {
         if (!Array.isArray(terms) || terms.some((term) => typeof term !== "string"))
             throw new RimeInputError("contextTerms must be an array of strings");
         const format = resolvePCMFormat(options.inputFormat);
-        const target = this.endpoint == null
-            ? policy.target
-            : endpointAddress(this.endpoint).target;
+        const target = policy.target;
         const stream = new TranscriptStream({
             checkOpen: this.checkOpen,
             forget: (stream) => this.streams.delete(stream),

package/dist/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/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)) /
@@ -47,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;