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

package/dist/stt/types.d.ts

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

package/dist/stt/types.js

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

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

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

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

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

package/dist/tts/buffer.d.ts

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

package/dist/tts/buffer.js

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

package/dist/tts/client.d.ts

@@ -0,0 +1,53 @@
+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";
+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 {
+    timeout?: number | null;
+}
+export interface VoiceListOptions extends DiscoveryOptions {
+    language?: string | null;
+}
+export declare class TTS {
+    private readonly credentials;
+    private readonly deployment;
+    private readonly defaultTimeout;
+    private readonly checkOpen;
+    private client;
+    private streams;
+    private discoveryOperations;
+    readonly voices: {
+        list: (options?: VoiceListOptions) => Promise<string[]>;
+    };
+    readonly languages: {
+        list: (options?: DiscoveryOptions) => Promise<string[]>;
+    };
+    constructor(credentials: Credentials, deployment: Readonly<typeof policy>, defaultTimeout: number | null, checkOpen: () => void);
+    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;
+    close(): Promise<void>;
+}

package/dist/tts/client.js

@@ -0,0 +1,151 @@
+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, RimeResourceLimitError, RimeCancelledError, RimeTimeoutError, RimeUnavailableError, } from "../errors.js";
+export class TTS {
+    credentials;
+    deployment;
+    defaultTimeout;
+    checkOpen;
+    client = null;
+    streams = new Set();
+    discoveryOperations = new Map();
+    voices;
+    languages;
+    constructor(credentials, deployment, defaultTimeout, checkOpen) {
+        this.credentials = credentials;
+        this.deployment = deployment;
+        this.defaultTimeout = defaultTimeout;
+        this.checkOpen = checkOpen;
+        this.voices = {
+            list: async (options = {}) => {
+                if (options.language !== undefined && options.language !== null)
+                    nonempty(options.language, "language");
+                return this.discover("voices", options.language, options.timeout);
+            },
+        };
+        this.languages = {
+            list: (options = {}) => this.discover("languages", undefined, options.timeout),
+        };
+    }
+    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) };
+    }
+    /** Synthesize complete text and return an audio stream. Do not await this call. */
+    synthesize(text, options = {}) {
+        this.checkOpen();
+        if (typeof text !== "string")
+            throw new RimeInputError("text must be a string; use stream() for an async text source");
+        if (!text.trim())
+            throw new RimeInputError("Text must contain non-whitespace characters");
+        return this.stream((async function* () {
+            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();
+        if (typeof text === "string" ||
+            !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, 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), timestamps, lexicon, sampleRate, options.timeScaleFactor ?? undefined);
+        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;
+        const timer = setTimeout(() => controller.abort(new RimeTimeoutError("Discovery deadline expired")), budget * 1000);
+        const operation = (async () => {
+            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.discoveryOperations.delete(controller);
+            }
+        })();
+        this.discoveryOperations.set(controller, operation);
+        return operation;
+    }
+    async close() {
+        const discoveries = [...this.discoveryOperations.values()];
+        for (const controller of this.discoveryOperations.keys())
+            controller.abort(new RimeCancelledError("Client closed during discovery"));
+        await Promise.all([
+            ...[...this.streams].map((stream) => stream.cancel()),
+            Promise.allSettled(discoveries),
+        ]);
+        this.client?.close();
+    }
+}

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/{policy.d.ts → tts/policy.d.ts}

@@ -1,9 +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;
@@ -16,6 +17,4 @@ export declare const policy: {
     cleanupTimeout: number;
 };
 export declare function resolve(model: string, endpoint?: string | null): Readonly<typeof policy>;
-export declare function timeout(value: unknown, inherited?: number | null): number | null;
 export declare function nonempty(value: unknown, name: string): string;
-export declare function abortable<T>(promise: PromiseLike<T>, signal: AbortSignal): Promise<T>;

package/dist/tts/policy.js

@@ -0,0 +1,41 @@
+import { endpointAddress } from "../validation.js";
+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",
+    sourceChars: 1024,
+    outputBytes: 96000,
+    outputChunkBytes: 9600,
+    receiveBytes: 4194304,
+    authTimeout: 10,
+    connectionTimeout: 10,
+    firstAudioTimeout: 30,
+    progressTimeout: 60,
+    discoveryTimeout: 10,
+    cleanupTimeout: 2,
+};
+export function resolve(model, endpoint) {
+    const deployment = { ...policy, model };
+    if (model === "mistv3") {
+        const hostname = "mist.api.rime.ai";
+        deployment.target = `${hostname}:443`;
+        deployment.audience = hostname;
+        deployment.defaultVoice = "astra";
+    }
+    else if (model !== "coda") {
+        throw new RimeInputError("model must be 'coda' or 'mistv3'");
+    }
+    if (endpoint === undefined || endpoint === null)
+        return deployment;
+    return { ...deployment, ...endpointAddress(endpoint) };
+}
+export function nonempty(value, name) {
+    if (typeof value !== "string" || !value.trim())
+        throw new RimeInputError(`${name} must be a non-empty string`);
+    return value;
+}

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

@@ -1,11 +1,13 @@
 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>;
     checkOpen(): void;
     forget(stream: AudioStream): void;
 }
-export type TextSource = string | AsyncIterable<string>;
+export type TextSource = AsyncIterable<string>;
 export declare const constructionKey: unique symbol;
 export declare class AudioStream implements AsyncIterableIterator<Uint8Array> {
     private owner;
@@ -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;