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

package/docs/stt.md

@@ -0,0 +1,186 @@
+# Speech recognition
+
+## Complete recordings
+
+For a complete recording, use the native unary `Transcribe` RPC through the SDK.
+Pass **complete WAV bytes, including the header**, up to **16 MiB (16,777,216
+bytes)**. PCM16 mono 16 kHz WAV is the portable format. The SDK sends the file
+unchanged; it does not decode, resample, or add a header. The service validates
+its encoding and the supplied language and recognition hints.
+
+The result is a `Transcription` containing final text, resolved language, and a
+request ID when available. Silence may return empty text. There are no partial
+updates or automatic retries. TTS client settings do not apply. An optional
+overall timeout includes connection and upload; the SDK also bounds connection
+time and the unary request (120 seconds). Timeout, cancellation, and service
+errors use the existing SDK error categories. A request ID is included when the
+transport has made it available.
+
+```typescript
+import { readFile } from "node:fs/promises";
+import { Rime } from "@rimelabs/sdk";
+
+const client = new Rime();
+try {
+  const result = await client.stt.transcribe(await readFile("utterance.wav"), {
+    language: "en",
+    mode: "written",
+    contextTerms: ["Super-G", "USOC"],
+    timeout: 120,
+  });
+  console.log(result.text, result.language, result.requestId);
+} finally {
+  await client.close();
+}
+```
+
+`TranscribeOptions` also accepts an `AbortSignal` as `signal`. Aborting it or
+closing the client cancels pending requests with `RimeCancelledError`.
+
+## Streaming 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 if (update.kind === "final")
+      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.
+
+## Append-fragment streaming
+
+Choose `outputContract: "append_fragments"` on
+`client.stt.stream`. The default is `"revised_hypotheses"`; `transcribe()` does not
+accept an output contract. Both streaming modes use gRPC only.
+
+```javascript
+let text = "";
+const transcript = client.stt.stream(audioChunks(), {
+  language: "en", outputContract: "append_fragments",
+});
+for await (const update of transcript) {
+  if (update.kind === "delta") text += update.text;
+  else if (update.kind === "final") console.log(update.text);
+}
+```
+
+`TranscriptionDelta` is a permanent fragment, not a replacement partial. The
+server recognizes independent five-second audio windows; fragments after the
+first include newline separators. Do not strip, add separators, or drop deltas.
+The final text must match their concatenation. Empty speech can produce no
+updates before an empty final. A final is delivered only after `done` and an OK
+gRPC status, so a connection failure never promotes accumulated fragments to a
+successful result.
+
+Append mode suits longer recordings and consumers that cannot revise text. Send
+recordings as fast as backpressure permits. It does not enable unlimited-length
+streams: the service's 16 MiB audio and 120-second total-call limits still apply.
+Split larger recordings into separate streams. Live voice agents usually prefer
+revised hypotheses for earlier provisional text and corrections across windows.
+
+## 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. |
+| `outputContract` | `"revised_hypotheses"` (default) or `"append_fragments"`. Streaming only. |
+| `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.
+
+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.
+
+## Results and completion
+
+`TranscriptionPartial`, `TranscriptionDelta`, and `TranscriptionFinal` are discriminated types exported from `@rimelabs/sdk`. In the default revised-hypotheses mode, 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.
+
+When upgrading, `TranscriptionUpdate` now includes `TranscriptionDelta`. Update
+exhaustive handlers to handle `kind: "delta"`, even if you keep the default
+revised-hypotheses contract. Only finals have `language`: check
+`update.kind === "final"` before reading it, rather than assuming every
+non-partial update is final. Append deltas exactly; replace text with partials
+or the confirmed final.
+
+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. In revised-hypotheses mode,
+each replacement update is limited to 1 MiB of UTF-8 text; sizes are not summed
+across revisions. In append-fragments mode, the concatenated text across all
+deltas is limited to 1 MiB. The final transcript is also limited to 1 MiB in both
+modes. gRPC responses are bounded to 1 MiB plus 64 KiB for the protobuf envelope.
+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

@@ -0,0 +1,284 @@
+# TTS for Node.js
+
+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
+
+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() {
+  yield "Hello. ";
+  yield "This text arrives in separate chunks.";
+}
+```
+
+Use `client.tts.stream(text())` with the same file write and cleanup.
+Do not await `tts.stream()`; the first iterator read starts work. The quick start
+collects chunks before writing a WAV file.
+
+## Configuration
+
+Select Mist v3 with `new Rime({ model: "mistv3" })`. Mist v1 and v2 are not supported.
+
+| Model | Standard endpoint | Default voice |
+| --- | --- | --- |
+| `coda` | `coda.api.rime.ai:443` | `clementine` |
+| `mistv3` | `mist.api.rime.ai:443` | `astra` |
+
+### Client options
+
+| `new Rime({ ... })` option | Default | Meaning |
+| --- | --- | --- |
+| `apiKey` | `RIME_API_KEY` | API key; an explicit value overrides the environment |
+| `model` | `"coda"` | Model for speech and discovery |
+| `endpoint` | Model's standard endpoint | Custom hostname and optional port for speech and discovery |
+| `timeout` | No overall deadline | Positive seconds; `null` disables the overall deadline |
+
+Authentication uses bearer tokens over TLS. The SDK does not load `.env` files.
+
+Custom deployments use `new Rime({ model: "coda", endpoint: "host:8443" })`.
+Omit the scheme and path. TLS is required; the default port is `443`.
+Model defaults still apply.
+
+### Synthesis options
+
+`synthesize` and `synthesizeToBuffer` require a nonblank string; `stream` requires
+an async iterable of strings. All three accept the following settings:
+
+| Option | Default | Meaning |
+| --- | --- | --- |
+| `voice` | Model's default voice | Voice name from `client.voices.list()` |
+| `language` | `"en"` | Language code |
+| `audioFormat` | `AudioFormat.PCM` (24 kHz) | Output encoding, imported from `@rimelabs/sdk` |
+| `sampleRate` | `24000` (or fixed preset rate) | Requested output rate: `8000`, `16000`, or `24000` Hz |
+| `timeScaleFactor` | Omitted (normal duration) | Duration multiplier from `0.4` to `2.5`; below 1 is faster, above 1 is slower |
+| `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
+
+All output is mono. PCM and WAV use signed 16-bit little-endian samples.
+
+| `AudioFormat` | Encoding | Requested rate |
+| --- | --- | --- |
+| `PCM` | Headerless PCM16 | 8, 16, or 24 kHz |
+| `WAV` | PCM16 WAV | 8, 16, or 24 kHz |
+| `MP3` | MP3 (`audio/mpeg`) | 8, 16, or 24 kHz; encoded headers determine the actual rate |
+| `PCM_24000` | Headerless PCM16 compatibility preset | Fixed 24 kHz |
+| `MULAW_8000` | G.711 mu-law compatibility preset | Fixed 8 kHz |
+
+PCM/WAV sample rates are requested from the server; the SDK does not resample
+these formats. The existing mu-law preset still converts 24 kHz PCM locally.
+An explicit rate conflicting with a fixed preset fails locally. For configurable
+formats, `audio.format.sampleRate` is zero; use `audio.sampleRate` for the rate requested
+by the operation. Existing default streams still report `PCM_24000` as their format.
+
+PCM chunks contain complete sample frames. WAV and MP3 chunks are fragments of
+one encoded stream, not independent files. Streaming WAV may contain unknown
+lengths in its header; use `synthesizeToBuffer` for a completed IVR file.
+
+### Complete audio in memory
+
+Await `synthesizeToBuffer` to get all audio bytes. It uses the same streaming RPC,
+waits for successful completion, and finalizes WAV file lengths. On failure it
+raises an error and releases the stream; it never returns partial audio.
+The output limit is fixed at **64 MiB (67,108,864 bytes)** per call, including
+file headers. Exceeding it raises `RimeResourceLimitError` and returns no partial
+audio. For mono PCM16/WAV, this is approximately 70 minutes at 8 kHz, 35 minutes
+at 16 kHz, or 23 minutes at 24 kHz. Use streaming synthesis for larger outputs.
+Collection can temporarily use more memory than the output limit.
+Timeouts and client shutdown still apply. Use the streaming API to retrieve word timestamps.
+
+```javascript
+import { writeFile } from "node:fs/promises";
+import { AudioFormat, Rime } from "@rimelabs/sdk";
+
+const client = new Rime();
+try {
+  const audio = await client.tts.synthesizeToBuffer("Thank you for calling.", {
+    audioFormat: AudioFormat.WAV, sampleRate: 16000, timeScaleFactor: 0.9,
+  });
+  await writeFile("greeting.wav", audio);
+} finally {
+  await client.close();
+}
+```
+
+### Timeouts
+
+An overall deadline includes pauses between reads. Disabling it leaves internal
+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:
+
+```javascript
+const voices = await client.voices.list({ language: "en" });
+const languages = await client.languages.list();
+console.log(voices, languages);
+```
+
+Both return string arrays and accept `timeout`. Omit `language` to disable filtering.
+
+## Errors and cancellation
+
+Report SDK errors and request IDs while closing the client on failure:
+
+```javascript
+import { writeFile } from "node:fs/promises";
+import { Rime, RimeError } from "@rimelabs/sdk";
+
+let client;
+try {
+  client = new 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}`);
+  }
+  throw error;
+} finally {
+  await client?.close();
+}
+```
+
+Each SDK error inherits from `RimeError`:
+
+| Error | Meaning |
+| --- | --- |
+| `RimeAuthenticationError` | Missing or rejected credentials |
+| `RimePermissionError` | Access denied |
+| `RimeInputError` | Invalid input or client use |
+| `RimeResourceLimitError` | Service resource limit reached |
+| `RimeUnavailableError` | Service unavailable |
+| `RimeTimeoutError` | Overall or internal deadline reached |
+| `RimeAudioFormatError` | Unsupported or unexpected audio format |
+| `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.
+
+Keep cleanup when stopping early. A `for await` loop exit cancels the stream.
+For manual reads, call `await audio.cancel()` in `finally`. `await client.close()`
+stops all client work. Both calls are safe to repeat; both objects support
+`Symbol.asyncDispose`. Cancellation stops the RPC and limits cleanup time, but
+cannot force your text source to finish an unrelated promise.

package/package.json

@@ -1,13 +1,8 @@
 {
   "name": "@rimelabs/sdk",
-  "version": "0.1.0-alpha.2",
-  "description": "Rime streaming text-to-speech SDK for Node.js",
+  "version": "0.1.0-alpha.20",
+  "description": "Rime streaming TTS, STT and Prism realtime SDK for Node.js",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/rimelabs/rime-sdk.git",
-    "directory": "typescript"
-  },
   "type": "module",
   "engines": {
     "node": ">=22"
@@ -21,8 +16,10 @@
   },
   "files": [
     "dist",
-    "vendor",
+    "docs",
     "LICENSE",
+    "LICENSE-PRISM",
+    "NOTICE-PRISM",
     "README.md",
     "CHANGELOG.md"
   ],
@@ -31,16 +28,21 @@
     "check": "tsc -p tsconfig.json --noEmit",
     "test": "npm run build && node --test tests/*.test.mjs",
     "prepack": "npm run build",
-    "lint": "prettier --check src 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.0.1"
+    "@rimelabs/api": "0.4.0",
+    "ws": "^8.22.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "@types/ws": "^8.18.2",
+    "ajv": "^8.20.0",
     "prettier": "3.9.8",
-    "typescript": "^5.9.0"
-  }
+    "typescript": "^5.9.0",
+    "yaml": "^2.9.1"
+  },
+  "homepage": "https://docs.rime.ai/"
 }

package/dist/policy.js

@@ -1,82 +0,0 @@
-import { RimeInputError } from "./errors.js";
-const codaHostname = "coda.api.rime.ai";
-export const policy = {
-    target: `${codaHostname}:443`,
-    audience: codaHostname,
-    defaultVoice: "clementine",
-    exchangeUrl: "https://themis.api.rime.ai/v1/token",
-    sentenceBytes: 65536,
-    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 };
-    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;
-    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 {
-        ...deployment,
-        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;
-}
-export function nonempty(value, name) {
-    if (typeof value !== "string" || !value.trim())
-        throw new RimeInputError(`${name} must be a non-empty string`);
-    return value;
-}
-export function abortable(promise, signal) {
-    if (signal.aborted)
-        return Promise.reject(signal.reason);
-    return new Promise((resolve, reject) => {
-        const abort = () => {
-            signal.removeEventListener("abort", abort);
-            reject(signal.reason);
-        };
-        signal.addEventListener("abort", abort, { once: true });
-        Promise.resolve(promise).then((value) => {
-            signal.removeEventListener("abort", abort);
-            resolve(value);
-        }, (error) => {
-            signal.removeEventListener("abort", abort);
-            reject(error);
-        });
-    });
-}

package/dist/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 {};