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

package/dist/tts/transport.js

@@ -1,56 +1,38 @@
+import { connect as connectGrpc } from "../grpc.js";
+export { metadata } from "../grpc.js";
+import { BidiCall, serializer, deserializer, requestId, nativeError, } from "../grpc.js";
+export { rpcError } from "../grpc.js";
 import * as grpc from "@grpc/grpc-js";
-import { create, fromBinary, toBinary, } from "@bufbuild/protobuf";
+import { create, } from "@bufbuild/protobuf";
 import * as schema from "@rimelabs/api";
 import { policy } from "./policy.js";
 import { abortable } from "../cancellation.js";
 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);
-}
+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,
     }),
 };
-function serializer(desc) {
-    return (message) => Buffer.from(toBinary(desc, message));
-}
-function deserializer(desc) {
-    return (data) => fromBinary(desc, data);
-}
-export async function connect(client, signal) {
-    await abortable(new Promise((resolve, reject) => client.waitForReady(Date.now() + policy.connectionTimeout * 1000, (error) => error
-        ? reject(new errors.RimeTimeoutError("Connection establishment timed out"))
-        : resolve())), signal);
-}
-export function metadata(value) {
-    const result = new grpc.Metadata();
-    result.set("authorization", value);
-    return result;
+export function connect(client, signal) {
+    return connectGrpc(client, signal, policy.connectionTimeout);
 }
 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) {
     return create(schema.StreamingSynthesisRequestSchema, {
         payload: {
             case: "header",
             value: create(schema.SynthesisRequestSchema, {
                 speaker: voice,
                 language,
+                splitStrategy: schema.SplitStrategy.ACCUMULATE_SENTENCE,
                 audioParameters: { audioFormat: "audio/pcm", samplingRate: 24000 },
+                timestamps: timestamps ? { enable: true } : undefined,
+                customLexicon: [...customLexicon],
             }),
         },
     });
@@ -60,23 +42,6 @@ function textMessage(text) {
         payload: { case: "textChunk", value: text },
     });
 }
-function requestId(metadata) {
-    return metadata?.get("x-request-id")[0]?.toString() ?? null;
-}
-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,
-    });
-}
 async function unary(prepared, name, input, output, request, signal) {
     let call;
     let id = null;
@@ -114,115 +79,53 @@ export async function discover(prepared, kind, language, signal) {
     return response.languages;
 }
 export class SynthesisCall {
-    signal;
-    call;
-    metadataPromise;
-    statusPromise;
-    status = null;
-    id = null;
+    timestampsRequested = false;
+    timestampTrailer = new TimestampTrailer();
+    rpc;
     constructor(prepared, signal) {
-        this.signal = signal;
-        this.call = openStream(prepared.client, prepared.metadata);
-        this.metadataPromise = new Promise((resolve, reject) => {
-            this.call.once("metadata", (metadata) => {
-                this.id = requestId(metadata);
-                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", () => { });
+        this.rpc = new BidiCall(openStream(prepared.client, prepared.metadata), signal);
     }
     get requestId() {
-        return this.id;
+        return this.rpc.requestId;
     }
     get done() {
-        return this.status !== null || this.call.destroyed;
+        return this.rpc.done;
     }
     cancel() {
-        this.call.cancel();
+        this.rpc.cancel();
     }
-    error(error) {
-        const failure = nativeError(error, this.id);
-        this.id ??= failure.requestId;
-        return failure;
+    start(voice, language, timestamps = false, customLexicon = []) {
+        this.timestampsRequested = timestamps;
+        const message = header(voice, language, timestamps, customLexicon);
+        return this.rpc.write(message);
     }
-    async writeMessage(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);
-        }
+    timestampResult() {
+        return this.timestampTrailer.result(this.requestId);
     }
-    async start(voice, language) {
-        // Writes do not depend on response metadata.
-        await this.writeMessage(header(voice, language));
-    }
-    async write(sentence) {
-        await this.writeMessage(textMessage(sentence));
+    write(text) {
+        return this.rpc.write(textMessage(text));
     }
     finishInput() {
-        try {
-            this.call.end();
-        }
-        catch (error) {
-            throw this.error(error);
-        }
+        this.rpc.finishInput();
     }
     checkFormat(contentType) {
         if (contentType !== "audio/pcm")
-            throw new errors.RimeAudioFormatError("Expected raw audio/pcm from the service", this.id);
+            throw new errors.RimeAudioFormatError("Expected raw audio/pcm from the service", this.requestId);
     }
     async *audio() {
-        try {
-            const metadata = await abortable(this.metadataPromise, this.signal);
-            const contentType = metadata.get("x-rime-audio-content-type")[0];
-            const responses = this.call;
-            for await (const response of responses) {
-                if (response.payload.case !== "audio")
-                    continue;
-                const audio = response.payload.value;
-                if (audio.length)
-                    this.checkFormat(contentType);
-                yield audio;
-            }
-            const status = await abortable(this.statusPromise, this.signal);
-            if (status.code !== grpc.status.OK)
-                throw rpcError(status.code, this.id);
-            // Validate empty success only after giving a rejection its proper error.
-            this.checkFormat(contentType);
-        }
-        catch (error) {
-            if (this.signal.aborted)
-                throw this.signal.reason;
-            throw this.error(error);
+        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;
         }
+        this.checkFormat(contentType);
     }
 }

package/dist/validation.d.ts

@@ -0,0 +1,5 @@
+export declare function endpointAddress(endpoint: string): {
+    target: string;
+    audience: string;
+};
+export declare function timeout(value: unknown, inherited?: number | null): number | null;

package/dist/validation.js

@@ -0,0 +1,28 @@
+import { RimeInputError } from "./errors.js";
+export function endpointAddress(endpoint) {
+    const error = "endpoint must be a hostname with an optional port (1-65535), without a scheme or path";
+    if (typeof endpoint !== "string" || /\s/.test(endpoint))
+        throw new RimeInputError(error);
+    const [host, port, extra] = endpoint.split(":");
+    if (!host ||
+        host.length > 253 ||
+        extra !== undefined ||
+        host
+            .split(".")
+            .some((label) => !/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i.test(label)) ||
+        (port !== undefined &&
+            (!/^[0-9]{1,5}$/.test(port) || Number(port) < 1 || Number(port) > 65535)))
+        throw new RimeInputError(error);
+    return {
+        target: `${host.toLowerCase()}:${port === undefined ? 443 : Number(port)}`,
+        audience: host.toLowerCase(),
+    };
+}
+export function timeout(value, inherited = null) {
+    if (value === undefined)
+        return inherited;
+    if (value !== null &&
+        (typeof value !== "number" || !Number.isFinite(value) || value <= 0))
+        throw new RimeInputError("timeout must be finite positive seconds or null");
+    return value;
+}

package/docs/stt.md

@@ -0,0 +1,103 @@
+# Streaming speech recognition
+
+`client.stt.stream` transcribes one utterance from an async source of `Uint8Array` chunks (including Node buffers).
+The SDK handles the gRPC protocol, authentication, audio conversion, transcript
+revisions, backpressure, and cancellation. Your application decides when speech
+ends by exhausting the source.
+
+```typescript
+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",
+    inputFormat: { sampleRate: 16000, channels: 1 },
+    mode: "written",
+    contextTerms: ["Super-G", "USOC"],
+    timeout: 120,
+  });
+  for await (const update of transcript) {
+    if (update.kind === "partial") console.log("Current transcript:", update.text);
+    else console.log("Final:", update.text, "Language:", update.language);
+  }
+  console.log("Request:", transcript.requestId);
+} finally {
+  await client.close();
+}
+```
+
+The runnable [example](../examples/stt/stream.mjs) reads a PCM file
+without loading it all into memory. Use Node.js 22 or later; browsers are not supported.
+Open files inside the async generator so file errors are reported through the
+SDK and resources are opened only after the service accepts the utterance.
+
+## Options
+
+| Option | Meaning |
+| --- | --- |
+| `language` | Required spoken BCP-47 tag. Passed unchanged to the service; no detection or SDK language allowlist. The deployed catalog currently supports English and Spanish. |
+| `mode` | `"written"` (default) or `"verbatim"`. Formatting intent, not a guarantee of exact tokens. |
+| `contextTerms` | Sequence of recognition hints, copied unchanged and in order. The service validates terms and prompt budgets. |
+| `inputFormat` | `PCMFormat`: signed little-endian PCM16 at 8, 16, 24 or 48 kHz, mono or interleaved stereo. Defaults to 16 kHz mono. |
+| `timeout` | Optional positive overall timeout in seconds. Includes connection time, source pauses and consumer pauses. `null` disables this SDK deadline, but not internal or server deadlines. |
+
+Input contains raw samples, with no WAV header or compressed codec. Chunks may
+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.
+The existing `model`, `endpoint` and client `timeout` settings remain TTS settings.
+There is no STT voice/model selector; the service selects its recognizer.
+
+## Results and completion
+
+`TranscriptionPartial` and `TranscriptionFinal` are discriminated TypeScript types, exported from `@rimelabs/sdk`. Every update contains the complete current `text`.
+**Replace the previous transcript. Do not concatenate partials.** Later partials
+can change earlier words. `TranscriptionFinal.language` is the canonical language
+selected by the service.
+
+The source is not consumed until the server accepts the configuration. Audio
+upload and transcript reading run concurrently. Decoding currently uses cumulative
+two-second audio windows, so a partial is not promised for each audio packet.
+Silence can finish successfully with empty final text and no partials.
+
+Exhausting the source half-closes gRPC input. The SDK continues reading and emits
+one final result only after a matching `done` and successful gRPC completion.
+EOF, an error status, or cancellation cannot turn a partial into a final result.
+No audio is automatically replayed after a connection failure.
+
+## Lifetime and limits
+
+Construction is lazy: starting iteration begins work. Consume each stream with
+one reader. Breaking a `for await` loop calls the iterator's `return` and cancels
+unfinished work. `await transcript.cancel()` and async disposal also cancel it.
+Pass an `AbortSignal` through the stream's `signal` option to cancel just that
+utterance. Client close cancels all STT, TTS and realtime operations; cancelling
+one stream leaves its siblings running.
+
+The SDK bounds the transcript queue to 16 updates, each with at most 64 KiB of
+UTF-8 text, and bounds gRPC responses to 256 KiB. Slow consumers apply backpressure.
+Internal connection and acceptance waits are 10 seconds; completion after source
+exhaustion is bounded to 120 seconds. The completion timer stops after successful
+gRPC completion. The optional overall timeout remains active until the final
+result is consumed. An outstanding source `next()` cannot be forcibly stopped by
+JavaScript; the SDK stops waiting for it and attempts `return()` for at most two
+seconds. Sources that own devices should support cancellation themselves.
+
+Server input-idle, utterance-size, request-duration and model-context limits still
+apply. The current wire limit is 16 MiB per utterance; model context can impose a
+smaller limit depending on audio and recognition terms. There is no SDK VAD,
+server endpointing, word timing, diarization, or file-format detection.
+
+Failures use the shared SDK error hierarchy: caller/input errors, cancellation,
+authentication, permission, resource limits, timeouts, transient availability and
+protocol failures stay distinct. `requestId` is retained on streams and failures
+when the server supplies it. Keep it when reporting a problem.

package/docs/tts.md

@@ -1,12 +1,27 @@
 # TTS for Node.js
 
-You supply text; the SDK handles sentence boundaries and streams audio back.
+Send text as it becomes available; Rime automatically combines fragments into
+sentences for speech. For nonblank input, ending the text stream flushes any
+remaining text, even without final punctuation. Pausing the stream may delay
+speech for an unfinished sentence.
+
+If the source ends without any non-whitespace text, audio iteration rejects with
+`RimeInputError`.
+
+The SDK sends text in order with its whitespace preserved and streams audio back.
 Your application owns playback. Start with the complete WAV example in the
 [package quick start](../README.md#tts-save-speech).
 
+## String input
+
+Use `client.tts.synthesize(text)` for one nonblank string. It returns an audio
+stream; it does not wait for all audio to be generated. Do not await this call.
+Use the audio loop and cleanup shown in the package quick start.
+
 ## Stream incoming text
 
-An async text source can supply text as it arrives:
+Use `client.tts.stream(chunks)` for an async iterable of strings. A plain string
+belongs in `synthesize`, not `stream`. The source can supply partial sentences:
 
 ```javascript
 async function* text() {
@@ -16,8 +31,8 @@ async function* text() {
 ```
 
 Use `client.tts.stream(text())` with the same file write and cleanup.
-The SDK handles sentence boundaries. Do not await `tts.stream()`; the first
-iterator read starts work. The quick start collects chunks before writing a WAV file.
+Do not await `tts.stream()`; the first iterator read starts work. The quick start
+collects chunks before writing a WAV file.
 
 ## Configuration
 
@@ -45,14 +60,16 @@ Model defaults still apply.
 
 ### Synthesis options
 
-The `text` argument is required and accepts a nonblank string or an async text
-source. All options in `client.tts.stream(text, { ... })` are optional:
+Both methods require text input: a nonblank string for `synthesize`, or an
+async iterable of strings for `stream`. Both accept the following optional settings:
 
 | Option | Default | Meaning |
 | --- | --- | --- |
 | `voice` | Model's default voice | Voice name from `client.voices.list()` |
 | `language` | `"en"` | Language code |
 | `audioFormat` | `AudioFormat.PCM_24000` | Output profile, imported from `@rimelabs/sdk` |
+| `timestamps` | `false` | Request final word timestamps; requires `model: "mistv3"` |
+| `customLexicon` | `[]` | Array of pronunciation overrides for this request; requires Coda |
 | `timeout` | Client setting | Seconds; pass `null` to disable the overall deadline |
 
 ### Audio formats
@@ -74,6 +91,99 @@ connection and progress limits active. Discovery allows at most 10 seconds;
 a shorter supplied timeout takes precedence. Omit an operation's `timeout` or
 pass `undefined` to inherit the client setting.
 
+## Custom pronunciations (Coda)
+
+Pass words or phrases and their space-separated X-SAMPA pronunciations:
+
+```javascript
+import { writeFile } from "node:fs/promises";
+import { Rime, RimeInputError } from "@rimelabs/sdk";
+
+const lexicon = [{ spelling: "hello", pronunciation: 'h @ . " l oU' }];
+const client = new Rime({ model: "coda", timeout: 60 });
+try {
+  await writeFile("speech.pcm", client.tts.synthesize("Hello world.", {
+    language: "en",
+    customLexicon: lexicon,
+  }));
+} catch (error) {
+  if (error instanceof RimeInputError) {
+    console.error(`Invalid synthesis request: ${error.message}; requestId=${error.requestId}`);
+  }
+  throw error;
+} finally {
+  await client.close();
+}
+```
+
+TypeScript callers can import the `PronunciationEntry` type from `@rimelabs/sdk`.
+The SDK copies the array and entries when `tts.synthesize()` or `tts.stream()`
+is called. The same lexicon applies to the entire request, including an async
+text source; subsequent requests have their own options. Omit the option or
+pass an empty array for default pronunciation.
+
+The service matches whole words or phrases case-insensitively and applies the
+pronunciation after text normalization. Longest matches take precedence; the
+last entry for a repeated spelling wins. Inline `pronounce(...)` directives are
+not supported.
+
+Coda accepts custom pronunciations in German, English, Spanish, French,
+Italian, and Portuguese, with up to 500 entries per request. The service validates
+supported languages and pronunciation rules. Mist rejects nonempty lexicons.
+
+Malformed option types and invalid Unicode in lexicon fields throw locally.
+The service rejects unsupported models or languages, oversized lexicons, and
+ill-formed entries with `RimeInputError`
+before producing audio. Catch it around consuming the stream. Its `message`
+preserves the offending spelling and checks such as `no-primary-stress` or
+`unknown-phone`, and `requestId` identifies the request. The whole request fails;
+entries are never silently skipped or repaired.
+
+## Word timestamps (Mist v3)
+
+Enable timestamps on a synthesis, consume all audio, then read its result:
+
+```javascript
+import { writeFile } from "node:fs/promises";
+import { Rime } from "@rimelabs/sdk";
+
+const client = new Rime({ model: "mistv3", timeout: 60 });
+try {
+  const audio = client.tts.synthesize("Hello world.", { timestamps: true });
+  await writeFile("speech.pcm", audio);
+  const result = await audio.timestamps();
+  if (result.status.code === 0) {
+    for (const word of result.spans) {
+      console.log(word.text, word.start, word.end);
+    }
+  } else {
+    console.log("Timestamps unavailable:", result.status.code, result.status.message);
+  }
+} finally {
+  await client.close();
+}
+```
+
+`TimestampResult`, `TimestampStatus`, and `WordTimestamp` are exported types from
+`@rimelabs/sdk`. The result is immutable. `spans` is an array of words with `text`,
+`start`, and `end`; times are seconds from the beginning of the entire synthesis,
+including when text arrives incrementally. Resampling to `MULAW_8000` does not
+change these times. Words reflect normalized spoken text, so a number may become
+several words. The model supplies the timings; the SDK does not estimate them.
+
+Timestamps arrive once, after generation finishes. They are not incremental
+events for live interruption handling. `timestamps()` never consumes audio or
+waits for you to consume it: calling before successful iteration finishes, or
+without enabling timestamps, rejects with `RimeInputError`. Results remain
+accessible after a successfully consumed stream or its client is closed.
+
+`status.code` is a numeric `google.rpc.Code`: `0` is success. Nonzero codes such as
+`12` (unimplemented) or `4` (deadline exceeded) carry an explanation and no spans;
+they do not fail successful audio. Missing or malformed timestamp responses reject
+with `RimeStreamError` only when reading timestamps. A synthesis error or
+cancellation also prevents reading a successful timestamp result. Enabling
+timestamps with Coda throws `RimeInputError` before any request is sent.
+
 ## Discover voices and languages
 
 List voices and languages while the client is open:
@@ -97,7 +207,7 @@ import { Rime, RimeError } from "@rimelabs/sdk";
 let client;
 try {
   client = new Rime();
-  await writeFile("speech.pcm", client.tts.stream("Hello. This is Rime."));
+  await writeFile("speech.pcm", client.tts.synthesize("Hello. This is Rime."));
 } catch (error) {
   if (error instanceof RimeError) {
     console.error(`Speech failed: ${error.message}; requestId=${error.requestId}`);
@@ -122,6 +232,9 @@ Each SDK error inherits from `RimeError`:
 | `RimeCancelledError` | Operation cancelled |
 | `RimeStreamError` | Other stream or transport failure |
 
+Service errors retain their diagnostic message and request ID when provided.
+Use the exception type for programmatic handling; message wording may change.
+
 Partial audio can arrive before an error. Output is complete only after successful
 iteration. Synthesis is not retried automatically.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rimelabs/sdk",
-  "version": "0.1.0-alpha.10",
-  "description": "Rime streaming TTS and Prism realtime SDK for Node.js",
+  "version": "0.1.0-alpha.13",
+  "description": "Rime streaming TTS, STT and Prism realtime SDK for Node.js",
   "license": "MIT",
   "type": "module",
   "engines": {
@@ -17,7 +17,6 @@
   "files": [
     "dist",
     "docs",
-    "vendor",
     "LICENSE",
     "LICENSE-PRISM",
     "NOTICE-PRISM",
@@ -29,12 +28,12 @@
     "check": "tsc -p tsconfig.json --noEmit",
     "test": "npm run build && node --test tests/*.test.mjs",
     "prepack": "npm run build",
-    "lint": "prettier --check src tests ../examples/typescript/tts ../examples/typescript/realtime ../examples/typescript/common ../examples/typescript/browser ../examples/typescript/tests"
+    "lint": "prettier --check src tests examples/tts examples/realtime examples/common examples/browser examples/tests examples/stt"
   },
   "dependencies": {
     "@bufbuild/protobuf": "^2.11.0",
     "@grpc/grpc-js": "^1.14.0",
-    "@rimelabs/api": "0.3.0",
+    "@rimelabs/api": "0.4.0",
     "ws": "^8.22.0"
   },
   "devDependencies": {

package/dist/tts/sentences.d.ts

@@ -1,21 +0,0 @@
-interface BlingFire {
-    ready: Promise<BlingFire>;
-    _malloc(n: number): number;
-    _free(p: number): void;
-    _TextToSentences(input: number, length: number, output: number, capacity: number): number;
-    HEAPU8: Uint8Array;
-}
-export declare const ready: Promise<BlingFire>;
-export declare class SentenceBuffer {
-    private limit;
-    private pending;
-    private committed;
-    private parts;
-    private untilScan;
-    private sincePunctuation;
-    private highSurrogate;
-    constructor(limit: number);
-    feed(fragment: string, final?: boolean): Generator<string>;
-    private scan;
-}
-export {};