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

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);
+}

package/dist/tts/client.d.ts

@@ -1,4 +1,5 @@
 import { AudioFormat } from "./audio.js";
+import { type PronunciationEntry } from "./lexicon.js";
 import { AudioStream, type TextSource } from "./stream.js";
 import { Credentials } from "../auth.js";
 import { policy } from "./policy.js";
@@ -6,6 +7,14 @@ export interface SynthesisOptions {
     voice?: string | null;
     language?: string;
     audioFormat?: AudioFormat | null;
+    /** Requested output rate: 8000, 16000, or 24000 Hz. Defaults to 24000 for PCM/WAV/MP3. */
+    sampleRate?: number | null;
+    /** Duration multiplier from 0.4 to 2.5. Below 1 speeds speech up; above 1 slows it down. */
+    timeScaleFactor?: number | null;
+    /** Request final word timestamps. Supported only with model="mistv3". */
+    timestamps?: boolean;
+    /** Request-wide pronunciation overrides; requires a phoneme-capable Coda deployment. */
+    customLexicon?: readonly PronunciationEntry[];
     timeout?: number | null;
 }
 export interface DiscoveryOptions {
@@ -32,6 +41,11 @@ export declare class TTS {
     private prepare;
     /** Synthesize complete text and return an audio stream. Do not await this call. */
     synthesize(text: string, options?: SynthesisOptions): AudioStream;
+    /** Await complete audio in memory, finalizing WAV lengths. Never returns partial audio.
+     * The fixed output limit is 64 MiB (67,108,864 bytes); exceeding it raises
+     * RimeResourceLimitError. Use streaming synthesis for larger outputs or timestamps.
+     */
+    synthesizeToBuffer(text: string, options?: SynthesisOptions): Promise<Buffer>;
     /** Stream text chunks into synthesis and return an audio stream. Do not await this call. */
     stream(text: TextSource, options?: SynthesisOptions): AudioStream;
     private discover;

package/dist/tts/client.js

@@ -1,9 +1,11 @@
-import { AudioFormat } from "./audio.js";
+import { AudioFormat, resolveAudio } from "./audio.js";
+import { maxBufferBytes, finalizeWav } from "./buffer.js";
+import { snapshot } from "./lexicon.js";
 import { AudioStream, constructionKey } from "./stream.js";
 import { policy, timeout, nonempty } from "./policy.js";
 import { abortable } from "../cancellation.js";
 import { transport, connect, metadata, discover, } from "./transport.js";
-import { RimeInputError, RimeAudioFormatError, RimeCancelledError, RimeTimeoutError, RimeUnavailableError, } from "../errors.js";
+import { RimeInputError, RimeResourceLimitError, RimeCancelledError, RimeTimeoutError, RimeUnavailableError, } from "../errors.js";
 export class TTS {
     credentials;
     deployment;
@@ -49,6 +51,30 @@ export class TTS {
             yield text;
         })(), options);
     }
+    /** Await complete audio in memory, finalizing WAV lengths. Never returns partial audio.
+     * The fixed output limit is 64 MiB (67,108,864 bytes); exceeding it raises
+     * RimeResourceLimitError. Use streaming synthesis for larger outputs or timestamps.
+     */
+    async synthesizeToBuffer(text, options = {}) {
+        const audio = this.synthesize(text, options);
+        const chunks = [];
+        let size = 0;
+        try {
+            for await (const chunk of audio) {
+                if (chunk.byteLength > maxBufferBytes - size)
+                    throw new RimeResourceLimitError("Audio exceeds the 64 MiB buffer limit", audio.requestId);
+                chunks.push(chunk);
+                size += chunk.byteLength;
+            }
+            const data = Buffer.concat(chunks, size);
+            if (audio.format === AudioFormat.WAV)
+                finalizeWav(data, audio.sampleRate, audio.requestId);
+            return data;
+        }
+        finally {
+            await audio.cancel();
+        }
+    }
     /** Stream text chunks into synthesis and return an audio stream. Do not await this call. */
     stream(text, options = {}) {
         this.checkOpen();
@@ -56,18 +82,22 @@ export class TTS {
             !text ||
             typeof text[Symbol.asyncIterator] !== "function")
             throw new RimeInputError("text must be an async iterable of strings; use synthesize() for a string");
+        const lexicon = snapshot(options.customLexicon);
+        const timestamps = options.timestamps === undefined ? false : options.timestamps;
+        if (typeof timestamps !== "boolean")
+            throw new RimeInputError("timestamps must be a boolean");
+        if (timestamps && this.deployment.model !== "mistv3")
+            throw new RimeInputError("Word timestamps are supported only with model='mistv3'");
         const voice = options.voice === undefined || options.voice === null
             ? this.deployment.defaultVoice
             : 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 { format, sampleRate } = resolveAudio(options.audioFormat, options.sampleRate, options.timeScaleFactor);
         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));
+        }, text, voice, language, format, timeout(options.timeout, this.defaultTimeout), timestamps, lexicon, sampleRate, options.timeScaleFactor ?? undefined);
         this.streams.add(audio);
         return audio;
     }

package/dist/tts/lexicon.d.ts

@@ -0,0 +1,7 @@
+/** A word or phrase and its space-separated X-SAMPA pronunciation. */
+export interface PronunciationEntry {
+    readonly spelling: string;
+    readonly pronunciation: string;
+}
+/** Copy request options now; model and linguistic validation belong to the service. */
+export declare function snapshot(entries?: readonly PronunciationEntry[]): readonly PronunciationEntry[];

package/dist/tts/lexicon.js

@@ -0,0 +1,23 @@
+import { RimeInputError } from "../errors.js";
+// Unicode mode treats valid surrogate pairs as one code point outside this range.
+const unpairedSurrogate = /[\uD800-\uDFFF]/u;
+/** Copy request options now; model and linguistic validation belong to the service. */
+export function snapshot(entries = []) {
+    if (!Array.isArray(entries))
+        throw new RimeInputError("customLexicon must be an array of pronunciation entries");
+    // Array.from also visits holes, which are invalid entries.
+    return Object.freeze(Array.from(entries, (entry) => {
+        if (!entry ||
+            typeof entry !== "object" ||
+            typeof entry.spelling !== "string" ||
+            typeof entry.pronunciation !== "string")
+            throw new RimeInputError("Lexicon entries must have string spelling and pronunciation fields");
+        if (unpairedSurrogate.test(entry.spelling) ||
+            unpairedSurrogate.test(entry.pronunciation))
+            throw new RimeInputError("Lexicon spelling and pronunciation must contain valid Unicode");
+        return Object.freeze({
+            spelling: entry.spelling,
+            pronunciation: entry.pronunciation,
+        });
+    }));
+}

package/dist/tts/policy.d.ts

@@ -1,10 +1,10 @@
 export { timeout } from "../validation.js";
 export declare const policy: {
+    model: string;
     target: string;
     audience: string;
     defaultVoice: string;
     exchangeUrl: string;
-    sentenceBytes: number;
     sourceChars: number;
     outputBytes: number;
     outputChunkBytes: number;

package/dist/tts/policy.js

@@ -3,11 +3,11 @@ export { timeout } from "../validation.js";
 import { RimeInputError } from "../errors.js";
 const codaHostname = "coda.api.rime.ai";
 export const policy = {
+    model: "coda",
     target: `${codaHostname}:443`,
     audience: codaHostname,
     defaultVoice: "clementine",
     exchangeUrl: "https://themis.api.rime.ai/v1/token",
-    sentenceBytes: 65536,
     sourceChars: 1024,
     outputBytes: 96000,
     outputChunkBytes: 9600,
@@ -20,7 +20,7 @@ export const policy = {
     cleanupTimeout: 2,
 };
 export function resolve(model, endpoint) {
-    const deployment = { ...policy };
+    const deployment = { ...policy, model };
     if (model === "mistv3") {
         const hostname = "mist.api.rime.ai";
         deployment.target = `${hostname}:443`;

package/dist/tts/stream.d.ts

@@ -1,4 +1,6 @@
 import { AudioFormat } from "./audio.js";
+import type { TimestampResult } from "./timestamps.js";
+import type { PronunciationEntry } from "./lexicon.js";
 import { type PreparedConnection } from "./transport.js";
 export interface StreamOwner {
     prepare(signal: AbortSignal): Promise<PreparedConnection>;
@@ -14,6 +16,10 @@ export declare class AudioStream implements AsyncIterableIterator<Uint8Array> {
     private language;
     private formatValue;
     private timeout;
+    private timestampsRequested;
+    private customLexicon;
+    private sampleRateValue;
+    private timeScaleFactor?;
     private readonly controller;
     private readonly queue;
     private worker;
@@ -31,9 +37,16 @@ export declare class AudioStream implements AsyncIterableIterator<Uint8Array> {
     private readonly operationId;
     private bytesReceived;
     private bytesDelivered;
-    constructor(key: symbol, owner: StreamOwner, source: TextSource | null, voice: string, language: string, formatValue: AudioFormat, timeout: number | null);
+    constructor(key: symbol, owner: StreamOwner, source: TextSource | null, voice: string, language: string, formatValue: AudioFormat, timeout: number | null, timestampsRequested?: boolean, customLexicon?: readonly PronunciationEntry[], sampleRateValue?: number, timeScaleFactor?: number | undefined);
     get format(): AudioFormat;
+    /** Requested output rate. MP3 headers describe the encoded rate. */
+    get sampleRate(): number;
     get requestId(): string | null;
+    /** Read requested timestamps after consuming all audio; never drains audio.
+     * Calling before iteration completes rejects with RimeInputError. Synthesis
+     * errors reject here too; alignment failures are returned in status.
+     */
+    timestamps(): Promise<TimestampResult>;
     private start;
     private fail;
     private produce;

package/dist/tts/stream.js

@@ -1,11 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { debuglog } from "node:util";
 const log = debuglog("rime-sdk");
-import { Converter } from "./audio.js";
+import { AudioFormat, Converter, wireFormat } from "./audio.js";
 import { policy } from "./policy.js";
 import { abortable } from "../cancellation.js";
 import { ByteQueue } from "./queue.js";
-import { SentenceBuffer, ready } from "./sentences.js";
 import { SynthesisCall } from "./transport.js";
 import { RimeError, RimeInputError, RimeCancelledError, RimeTimeoutError, RimeStreamError, } from "../errors.js";
 export const constructionKey = Symbol("private stream constructor");
@@ -16,6 +15,10 @@ export class AudioStream {
     language;
     formatValue;
     timeout;
+    timestampsRequested;
+    customLexicon;
+    sampleRateValue;
+    timeScaleFactor;
     controller = new AbortController();
     queue = new ByteQueue(policy.outputBytes, policy.outputChunkBytes);
     worker = null;
@@ -33,22 +36,43 @@ export class AudioStream {
     operationId = randomUUID();
     bytesReceived = 0;
     bytesDelivered = 0;
-    constructor(key, owner, source, voice, language, formatValue, timeout) {
+    constructor(key, owner, source, voice, language, formatValue, timeout, timestampsRequested = false, customLexicon = [], sampleRateValue = 24000, timeScaleFactor) {
         this.owner = owner;
         this.source = source;
         this.voice = voice;
         this.language = language;
         this.formatValue = formatValue;
         this.timeout = timeout;
+        this.timestampsRequested = timestampsRequested;
+        this.customLexicon = customLexicon;
+        this.sampleRateValue = sampleRateValue;
+        this.timeScaleFactor = timeScaleFactor;
         if (key !== constructionKey)
             throw new TypeError("AudioStream is returned by client.tts.synthesize() or client.tts.stream()");
     }
     get format() {
         return this.formatValue;
     }
+    /** Requested output rate. MP3 headers describe the encoded rate. */
+    get sampleRate() {
+        return this.sampleRateValue;
+    }
     get requestId() {
         return this.call?.requestId ?? null;
     }
+    /** Read requested timestamps after consuming all audio; never drains audio.
+     * Calling before iteration completes rejects with RimeInputError. Synthesis
+     * errors reject here too; alignment failures are returned in status.
+     */
+    async timestamps() {
+        if (!this.timestampsRequested)
+            throw new RimeInputError("Enable timestamps: true when creating the stream");
+        if (this.failure)
+            throw this.failure;
+        if (!this.finished)
+            throw new RimeInputError("Consume all audio before reading timestamps");
+        return this.call.timestampResult();
+    }
     start() {
         if (this.failure)
             throw this.failure;
@@ -96,7 +120,7 @@ export class AudioStream {
     async produce() {
         const source = this.source;
         let iterator;
-        const buffer = new SentenceBuffer(policy.sentenceBytes);
+        let highSurrogate = "";
         let meaningful = false;
         try {
             try {
@@ -127,35 +151,39 @@ export class AudioStream {
                 }
                 if (result.done)
                     break;
-                const chunk = result.value;
-                if (typeof chunk !== "string")
+                if (typeof result.value !== "string")
                     throw new RimeInputError("The text source must yield strings");
+                let chunk = highSurrogate + result.value;
+                highSurrogate = "";
+                // A JavaScript source may split one Unicode character across yields.
+                if (/[\uD800-\uDBFF]$/.test(chunk)) {
+                    highSurrogate = chunk.slice(-1);
+                    chunk = chunk.slice(0, -1);
+                }
                 if (chunk.trim())
                     meaningful = true;
-                // Never split a surrogate pair when limiting native detector input size.
+                // Bound wire messages without splitting a Unicode character.
                 for (let offset = 0; offset < chunk.length;) {
                     let end = Math.min(chunk.length, offset + policy.sourceChars);
                     if (end < chunk.length && /[\uD800-\uDBFF]/.test(chunk[end - 1]))
                         end++;
-                    for (const sentence of buffer.feed(chunk.slice(offset, end))) {
-                        if (!this.submitted)
-                            this.progressAt = performance.now();
-                        this.submitted = true;
-                        await this.call.write(sentence);
-                    }
+                    const part = chunk.slice(offset, end);
+                    if (/[\uD800-\uDFFF]/u.test(part))
+                        throw new RimeInputError("Text must contain valid Unicode");
+                    if (!this.submitted)
+                        this.progressAt = performance.now();
+                    this.submitted = true;
+                    await this.call.write(part);
+                    this.progressAt = performance.now();
                     offset = end;
                 }
             }
+            if (highSurrogate)
+                throw new RimeInputError("Text must contain valid Unicode");
             if (!meaningful)
                 throw new RimeInputError("The text source contained no meaningful text");
-            for (const sentence of buffer.feed("", true)) {
-                if (!this.submitted)
-                    this.progressAt = performance.now();
-                this.submitted = true;
-                await this.call.write(sentence);
-            }
-            this.call.finishInput();
             this.inputDone = true;
+            this.call.finishInput();
         }
         catch (error) {
             if (error instanceof RimeError || this.controller.signal.aborted)
@@ -196,10 +224,9 @@ export class AudioStream {
     async run() {
         let tasks = [];
         try {
-            await abortable(ready, this.controller.signal);
             const prepared = await this.owner.prepare(this.controller.signal);
             this.call = new SynthesisCall(prepared, this.controller.signal);
-            await this.call.start(this.voice, this.language);
+            await this.call.start(this.voice, this.language, this.timestampsRequested, this.customLexicon, wireFormat(this.format), this.format === AudioFormat.MULAW_8000 ? 24000 : this.sampleRate, this.timeScaleFactor);
             tasks = [this.produce(), this.read()];
             await Promise.all(tasks);
             this.queue.finish();

package/dist/tts/timestamps.d.ts

@@ -0,0 +1,24 @@
+import type { SynthesisResponseTrailer } from "@rimelabs/api";
+/** A spoken, normalized word with start/end seconds from synthesis start. */
+export interface WordTimestamp {
+    readonly text: string;
+    readonly start: number;
+    readonly end: number;
+}
+/** Alignment's google.rpc.Code (0 means OK) and service explanation. */
+export interface TimestampStatus {
+    readonly code: number;
+    readonly message: string;
+}
+/** Final alignment status and words. Non-OK statuses carry no spans. */
+export interface TimestampResult {
+    readonly status: TimestampStatus;
+    readonly spans: readonly WordTimestamp[];
+}
+export declare class TimestampTrailer {
+    seen: boolean;
+    invalid: boolean;
+    private value;
+    accept(trailer: SynthesisResponseTrailer): void;
+    result(requestId: string | null): TimestampResult;
+}

package/dist/tts/timestamps.js

@@ -0,0 +1,46 @@
+import { RimeStreamError } from "../errors.js";
+export class TimestampTrailer {
+    seen = false;
+    invalid = false;
+    value;
+    accept(trailer) {
+        if (this.seen)
+            this.invalid = true;
+        else {
+            this.seen = true;
+            this.value = trailer.timestamps;
+        }
+    }
+    result(requestId) {
+        const malformed = () => new RimeStreamError("Invalid timestamp trailer", requestId);
+        if (this.invalid)
+            throw malformed();
+        const value = this.value;
+        if (!value)
+            throw new RimeStreamError("The service did not return requested timestamps", requestId);
+        if (!value.status || (value.status.code !== 0 && value.spans.length))
+            throw malformed();
+        const seconds = (duration) => {
+            if (!duration ||
+                duration.seconds < 0n ||
+                duration.seconds > 315576000000n ||
+                duration.nanos < 0 ||
+                duration.nanos >= 1000000000)
+                throw malformed();
+            return Number(duration.seconds) + duration.nanos / 1e9;
+        };
+        const spans = value.spans.map((span) => {
+            const start = seconds(span.start), end = seconds(span.end);
+            if (!span.text.trim() || end < start)
+                throw malformed();
+            return Object.freeze({ text: span.text, start, end });
+        });
+        return Object.freeze({
+            status: Object.freeze({
+                code: value.status.code,
+                message: value.status.message,
+            }),
+            spans: Object.freeze(spans),
+        });
+    }
+}

package/dist/tts/transport.d.ts

@@ -1,6 +1,7 @@
 export { metadata } from "../grpc.js";
 export { rpcError } from "../grpc.js";
 import * as grpc from "@grpc/grpc-js";
+import type { PronunciationEntry } from "./lexicon.js";
 export type Connection = grpc.Client;
 export interface PreparedConnection {
     client: Connection;
@@ -13,13 +14,17 @@ export declare const transport: {
 export declare function connect(client: grpc.Client, signal: AbortSignal): Promise<void>;
 export declare function discover(prepared: PreparedConnection, kind: DiscoveryKind, language: string | null | undefined, signal: AbortSignal): Promise<string[]>;
 export declare class SynthesisCall {
+    private audioFormat;
+    private timestampsRequested;
+    private readonly timestampTrailer;
     private readonly rpc;
     constructor(prepared: PreparedConnection, signal: AbortSignal);
     get requestId(): string | null;
     get done(): boolean;
     cancel(): void;
-    start(voice: string, language: string): Promise<void>;
-    write(sentence: string): Promise<void>;
+    start(voice: string, language: string, timestamps?: boolean, customLexicon?: readonly PronunciationEntry[], audioFormat?: string, sampleRate?: number, timeScaleFactor?: number): Promise<void>;
+    timestampResult(): import("./timestamps.js").TimestampResult;
+    write(text: string): Promise<void>;
     finishInput(): void;
     private checkFormat;
     audio(): AsyncGenerator<Uint8Array>;

package/dist/tts/transport.js

@@ -8,11 +8,12 @@ import * as schema from "@rimelabs/api";
 import { policy } from "./policy.js";
 import { abortable } from "../cancellation.js";
 import * as errors from "../errors.js";
+import { TimestampTrailer } from "./timestamps.js";
 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,
+        "grpc.max_send_message_length": 131072,
     }),
 };
 export function connect(client, signal) {
@@ -21,14 +22,17 @@ export function connect(client, signal) {
 function openStream(client, auth) {
     return client.makeBidiStreamRequest("/rime.TextToSpeech/SynthesizeStreaming", serializer(schema.StreamingSynthesisRequestSchema), deserializer(schema.SynthesisResponseStreamSchema), auth);
 }
-function header(voice, language) {
+function header(voice, language, timestamps, customLexicon, audioFormat, samplingRate, timeScaleFactor) {
     return create(schema.StreamingSynthesisRequestSchema, {
         payload: {
             case: "header",
             value: create(schema.SynthesisRequestSchema, {
                 speaker: voice,
                 language,
-                audioParameters: { audioFormat: "audio/pcm", samplingRate: 24000 },
+                splitStrategy: schema.SplitStrategy.ACCUMULATE_SENTENCE,
+                audioParameters: { audioFormat, samplingRate, timeScaleFactor },
+                timestamps: timestamps ? { enable: true } : undefined,
+                customLexicon: [...customLexicon],
             }),
         },
     });
@@ -75,6 +79,9 @@ export async function discover(prepared, kind, language, signal) {
     return response.languages;
 }
 export class SynthesisCall {
+    audioFormat = "audio/pcm";
+    timestampsRequested = false;
+    timestampTrailer = new TimestampTrailer();
     rpc;
     constructor(prepared, signal) {
         this.rpc = new BidiCall(openStream(prepared.client, prepared.metadata), signal);
@@ -88,25 +95,35 @@ export class SynthesisCall {
     cancel() {
         this.rpc.cancel();
     }
-    start(voice, language) {
-        return this.rpc.write(header(voice, language));
+    start(voice, language, timestamps = false, customLexicon = [], audioFormat = "audio/pcm", sampleRate = 24000, timeScaleFactor) {
+        this.timestampsRequested = timestamps;
+        this.audioFormat = audioFormat;
+        const message = header(voice, language, timestamps, customLexicon, audioFormat, sampleRate, timeScaleFactor);
+        return this.rpc.write(message);
     }
-    write(sentence) {
-        return this.rpc.write(textMessage(sentence));
+    timestampResult() {
+        return this.timestampTrailer.result(this.requestId);
+    }
+    write(text) {
+        return this.rpc.write(textMessage(text));
     }
     finishInput() {
         this.rpc.finishInput();
     }
     checkFormat(contentType) {
-        if (contentType !== "audio/pcm")
-            throw new errors.RimeAudioFormatError("Expected raw audio/pcm from the service", this.requestId);
+        if (contentType !== this.audioFormat)
+            throw new errors.RimeAudioFormatError(`Expected ${this.audioFormat} from the service`, this.requestId);
     }
     async *audio() {
         const headers = await this.rpc.headers();
         const contentType = headers.get("x-rime-audio-content-type")[0];
         for await (const response of this.rpc.responses()) {
+            if (response.payload.case === "trailer" && this.timestampsRequested)
+                this.timestampTrailer.accept(response.payload.value);
             if (response.payload.case !== "audio")
                 continue;
+            if (this.timestampTrailer.seen)
+                this.timestampTrailer.invalid = true;
             if (response.payload.value.length)
                 this.checkFormat(contentType);
             yield response.payload.value;

package/docs/stt.md

@@ -52,8 +52,8 @@ split sample frames; the SDK carries incomplete bytes into the next chunk. A
 truncated final frame raises `RimeAudioFormatError`, without committing the
 utterance. Each gRPC audio payload is at most 64 KiB of 16 kHz mono PCM16.
 
-The default recognition endpoint is `stt.api.rime.ai:443`, using TLS and the same
-API key as the other features. `new Rime({ sttEndpoint: "host:443" })` overrides only STT.
+Recognition connects to `stt.api.rime.ai:443` using TLS and the same API key as
+the other features. No endpoint configuration is needed.
 The existing `model`, `endpoint` and client `timeout` settings remain TTS settings.
 There is no STT voice/model selector; the service selects its recognizer.