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

package/dist/realtime/types.d.ts

@@ -2,6 +2,10 @@ import type { PCMFormat } from "../pcm.js";
 export type { PCMFormat } from "../pcm.js";
 import { RimeError, RimeTimeoutError } from "../errors.js";
 export type JsonValue = null | boolean | number | string | JsonValue[] | JsonObject;
+/** Your labels for replies, keys to strings, such as `{ step: "3" }`. Prism
+ * takes at most 16, keys up to 64 characters and values up to 512, and
+ * refuses keys starting with `prism_`. */
+export type Labels = Readonly<Record<string, string>>;
 export interface JsonObject {
     [key: string]: JsonValue;
 }
@@ -36,6 +40,10 @@ export interface ToolDefinition {
     readonly description?: string;
     readonly prismFiller?: PrismFiller;
 }
+/** History policy when the context fills. The server uses auto when omitted. */
+export type Truncation = "auto" | "disabled" | {
+    readonly retentionRatio: number;
+};
 export type TurnEagerness = "low" | "medium" | "high" | "auto";
 /** Omitted fields use the server's turn timing defaults. */
 export interface TurnDetection {
@@ -50,6 +58,7 @@ export interface TurnDetectionInfo {
     readonly endOfTurnTimeoutMs: number | null;
 }
 export interface RealtimeConnectOptions extends RealtimeOperationOptions {
+    readonly truncation?: Truncation;
     /** Defaults to wss://prism.api.rime.ai/v1/realtime. */
     readonly endpoint?: string;
     readonly model?: "prism";
@@ -59,6 +68,24 @@ export interface RealtimeConnectOptions extends RealtimeOperationOptions {
     readonly interruptOnSpeech?: boolean;
     readonly turnDetection?: TurnDetection;
     readonly timeouts?: RealtimeTimeouts;
+    /** Sent as the upgrade's `x-request-id`. It must be nonblank printable ASCII, or
+     * `connect` throws `RimeInputError`. Prism replaces IDs longer than 128 characters.
+     * A gateway can replace shorter IDs too. `info.requestId` reports the ID Prism
+     * actually used.
+     * Omitted or `null` sends none. */
+    readonly requestId?: string | null;
+    /** Labels every reply's `response.started` carries in `metadata`, such as
+     * `{ step: "3" }`; change them with `session.setResponseMetadata`. Prism
+     * refuses keys starting with `prism_`. Omitted or `null` sets none. */
+    readonly responseMetadata?: Labels | null;
+}
+/** Omitted fields keep their values. Empty instructions or tools clear them. */
+export interface RealtimeUpdateOptions extends RealtimeOperationOptions {
+    readonly truncation?: Truncation;
+    readonly instructions?: string;
+    readonly tools?: readonly ToolDefinition[];
+    readonly voice?: string;
+    readonly interruptOnSpeech?: boolean;
 }
 export interface ReplyOptions extends RealtimeOperationOptions {
     readonly instruction?: string | null;
@@ -68,6 +95,28 @@ export interface AudioChunk {
     readonly data: Uint8Array;
     readonly format?: PCMFormat;
 }
+/** An item without audio. IDs are optional on input and present in history results. */
+export type HistoryItem = {
+    readonly type: "message";
+    readonly id?: string;
+    readonly role: "user" | "assistant" | "system";
+    readonly text: string;
+} | {
+    readonly type: "function_call";
+    readonly id?: string;
+    readonly callId: string;
+    readonly name: string;
+    readonly arguments: string;
+} | {
+    readonly type: "function_call_output";
+    readonly id?: string;
+    readonly callId: string;
+    readonly output: string;
+};
+export interface HistoryCreateOptions extends RealtimeOperationOptions {
+    /** Omit to append, root to insert first, or an item ID to follow its whole turn. */
+    readonly previousItemId?: string;
+}
 export interface ResponseRef {
     readonly sessionId: string;
     readonly responseId: string;
@@ -86,7 +135,18 @@ export interface OutputRef {
     readonly contentIndex: number;
 }
 export interface SessionInfo {
+    /** Null when an older server does not publish its history policy. */
+    readonly truncation?: Truncation | null;
+    /** Settings revision published by the server; null when unavailable.
+     * Optional on caller-created values for compatibility. */
+    readonly settingsRevision?: number | null;
     readonly sessionId: string;
+    /** The `x-request-id` Prism's logs name this session by. Null when the
+     * server does not publish it. */
+    readonly requestId: string | null;
+    /** The labels replies carry, as Prism last confirmed them. Null when the
+     * server does not publish them. */
+    readonly responseMetadata: Labels | null;
     readonly model: "prism";
     readonly voice: string;
     readonly interruptOnSpeech: boolean;
@@ -96,6 +156,9 @@ export interface SessionInfo {
 }
 export interface RealtimeFault {
     readonly code: string;
+    /** Optional for compatibility with caller-created faults. The SDK derives
+     * its output classification from the code and ignores supplied values. */
+    readonly retryable?: boolean;
     readonly message: string;
     readonly scope: "event" | "utterance" | "response" | "tool_roundtrip" | "session" | "unknown";
     readonly requestId: string | null;
@@ -105,10 +168,18 @@ export interface RealtimeFault {
     readonly correlationId: string | null;
     readonly parameter: string | null;
 }
+/** An immutable fault produced by the SDK. */
+export interface NormalizedRealtimeFault extends RealtimeFault {
+    /** Whether the same request, unchanged, may succeed on another attempt.
+     * True only for capacity_exceeded, unavailable, and response_timeout.
+     * Unknown codes return false. The application owns retry timing, limits,
+     * and recovery after partial output; this value does not replay a request. */
+    readonly retryable: boolean;
+}
 export declare class RealtimeAdmissionTimeout extends RimeTimeoutError {
 }
 export declare class RimeRealtimeError extends RimeError {
-    readonly fault: RealtimeFault;
+    readonly fault: NormalizedRealtimeFault;
     constructor(fault: RealtimeFault);
 }
 export interface InputReady {
@@ -159,17 +230,26 @@ export interface TranscriptFinal {
     readonly itemId: string;
     readonly text: string;
 }
-export interface TranscriptFailed {
+export interface TranscriptFailed<Fault extends RealtimeFault = RealtimeFault> {
     readonly kind: "transcript.failed";
     readonly itemId: string;
-    readonly error: RealtimeFault;
+    readonly error: Fault;
 }
 export interface ResponseStarted {
+    /** Settings revision published by the server; null when unavailable.
+     * Optional on caller-created values for compatibility. */
+    readonly settingsRevision?: number | null;
     readonly kind: "response.started";
     readonly response: ResponseRef;
     readonly cause: "speech" | "text" | "proactive" | "tools" | "unknown";
     readonly parent: ResponseRef | null;
     readonly inputItemId: string | null;
+    /** The session's labels when the reply began. Prism's `prism_` keys are
+     * left out. */
+    readonly metadata: Labels;
+    /** The user items the reply answers: a spoken reply's committed turns, or
+     * a typed turn's item. Empty when the server names none. */
+    readonly inputItemIds: readonly string[];
 }
 export interface MessageStarted {
     readonly kind: "message.started";
@@ -209,22 +289,25 @@ export interface ResponseAbandoned {
     readonly response: ResponseRef;
 }
 export interface ResponseEnded {
+    /** Settings revision published by the server; null when unavailable.
+     * Optional on caller-created values for compatibility. */
+    readonly settingsRevision?: number | null;
     readonly kind: "response.ended";
     readonly response: ResponseRef;
     readonly status: "completed" | "cancelled" | "failed" | "unknown";
     readonly reason: string | null;
 }
-export interface FaultEvent {
+export interface FaultEvent<Fault extends RealtimeFault = RealtimeFault> {
     readonly kind: "error";
-    readonly error: RealtimeFault;
+    readonly error: Fault;
 }
-export type InputEvent = InputReady | SpeechHint | SpeechStarted | SpeechStopped | InputCommitted | TranscriptDelta | TranscriptFinal | TranscriptFailed;
+export type InputEvent<Fault extends RealtimeFault = RealtimeFault> = InputReady | SpeechHint | SpeechStarted | SpeechStopped | InputCommitted | TranscriptDelta | TranscriptFinal | TranscriptFailed<Fault>;
 export type ResponseEvent = ResponseStarted | ResponseAbandoned | MessageStarted | TextDelta | TextDone | AudioDelta | AudioDone | ToolCall | ResponseEnded;
-export interface SessionEvent {
+export interface SessionEvent<Fault extends RealtimeFault = RealtimeFault> {
     readonly sessionId: string;
     readonly eventId: string;
     readonly requestId: string | null;
-    readonly payload: InputEvent | ResponseEvent | FaultEvent;
+    readonly payload: InputEvent<Fault> | ResponseEvent | FaultEvent<Fault>;
 }
 export interface PlaybackInterrupted {
     readonly kind: "interrupted";

package/dist/realtime/types.js

@@ -1,10 +1,12 @@
 import { RimeError, RimeTimeoutError } from "../errors.js";
+import { normalizeFault } from "./faults.js";
 export class RealtimeAdmissionTimeout extends RimeTimeoutError {
 }
 export class RimeRealtimeError extends RimeError {
     fault;
     constructor(fault) {
-        super(`${fault.code}: ${fault.message}`, fault.requestId);
-        this.fault = fault;
+        const normalized = normalizeFault(fault);
+        super(`${normalized.code}: ${normalized.message}`, normalized.requestId);
+        this.fault = normalized;
     }
 }

package/docs/realtime.md

@@ -110,10 +110,13 @@ The runner is the only event reader. Do not consume `session.events` at the same
 time, call `reportPlayback` independently, or send a second audio source. Other
 session methods remain available for manual tools and application actions.
 
-On confirmed `speech.started`, the runner uses the effective
-`session.info.interruptOnSpeech` setting. It stops affected output, waits for the
-interrupted receipt, and reports the measured position. It ignores late audio
-for that response. A `speech.hint` alone does not stop playback. A server
+On confirmed `speech.started`, the runner uses the interruption setting of the
+latest reply that is still generating or has unmeasured physical playback. It
+resolves that setting from the reply's revision when the session receives the
+reply. Updates and late event consumption cannot change it. If interruption is
+enabled, the runner stops affected output, waits for the interrupted receipt,
+and reports the measured position. It ignores late audio for that response.
+A `speech.hint` alone does not stop playback. A server
 `truncate_not_current` refusal is forwarded as an event; it does not stop a newer
 response. Finished reports wait for generation completion and every output
 receipt, including outstanding playback from earlier responses. Prism treats
@@ -152,8 +155,9 @@ tool execution outside the runner.
 ## Connect
 
 Use `await client.realtime.connect()` with `RIME_API_KEY` set. It opens a WebSocket,
-initializes one conversation, and returns a `RealtimeSession`. Settings apply
-once. Open a new session to change them.
+initializes one conversation, and returns a `RealtimeSession`. Use
+`session.update` to change instructions, tools, voice, or interruption.
+Use `session.setResponseMetadata` to replace reply labels.
 
 | Option | Required? | Default and behavior |
 | --- | --- | --- |
@@ -165,15 +169,20 @@ once. Open a new session to change them.
 | `turnDetection` | No | Omitted settings use the server's turn timing defaults. |
 | `timeouts` | No | `{ connectS: 10, readyS: 30, requestS: 10 }`. Each field is optional. Units are seconds. |
 | `model` | No | `"prism"`, the only accepted value. |
+| `requestId` | No | Sent as `x-request-id`. It must be nonblank printable ASCII, or the SDK throws `RimeInputError`. Prism replaces IDs longer than 128 characters. A gateway can replace shorter IDs too. Read `session.info.requestId` for the ID Prism actually used. |
+| `responseMetadata` | No | Labels every reply carries in `response.started.metadata`, such as `{ step: "3" }`: up to 16 strings, keys up to 64 characters and values up to 512, no key starting with `prism_`. Prism refuses labels that break these limits, or keys starting with `prism_`, with `RimeRealtimeError` code `invalid_session`. |
 | `signal` | No | An `AbortSignal` that cancels connection setup. It does not cancel an established session. |
 
 Credentials come from `new Rime({ apiKey: "..." })` or `RIME_API_KEY`. Prism uses
 `Authorization: Bearer <key>`, without a TTS token exchange. TTS endpoint, model,
 voice, and timeout settings do not apply to Realtime.
 
-After connection, `session.info` contains `sessionId`, `model`, `voice`,
-`interruptOnSpeech`, `turnDetection`, `toolResultTimeoutS`, and
-`toolContinuationTimeoutS`.
+After connection, `session.info` contains `sessionId`, `requestId`, `model`,
+`voice`, `interruptOnSpeech`, `turnDetection`, `responseMetadata`,
+`toolResultTimeoutS`, and `toolContinuationTimeoutS`. `requestId` is the id
+Prism's logs use; include it when you report a problem. It is `null` on servers
+that do not send it. An event's or error's `requestId` names the SDK request
+that caused it instead.
 Check the effective interruption setting there. Tool wait durations are total
 server deadlines, not remaining time. A `null` duration can mean an omitted
 field; it does not prove that no deadline exists.
@@ -215,30 +224,81 @@ server reported in its initialization acknowledgment. A missing field is
 default. An unrecognized server eagerness becomes `"unknown"`.
 `interruptOnSpeech` remains a separate connection option.
 
+## Update session settings
+
+This method is available in the repository source and requires an SDK release
+that includes session updates.
+
+```ts
+const info = await session.update({
+  instructions: "Handle billing. Use only the supplied tools.",
+  tools: [refundTool], // An existing ToolDefinition.
+});
+console.log(info.settingsRevision);
+
+// For a transfer triggered by a tool call:
+await session.submitToolResult(call, "Transferred to billing.");
+await session.continueReply(parent);
+```
+
+`RealtimeUpdateOptions` has optional `instructions`, `tools`, `voice`,
+`interruptOnSpeech`, and `signal` fields. Omitted fields and `undefined` keep
+their values. `null` is not accepted.
+
+Omitted fields keep their values. A supplied tool list replaces the complete
+list. Empty instructions clear the prompt; an empty tool list removes all tools.
+An empty voice selects the deployment default. Instructions and tools supplied
+together change in one request.
+
+The method waits for the matching `session.updated` acknowledgment and returns
+session information. The stored session information changes only after that
+acknowledgment. A rejected update leaves it unchanged and keeps the connection
+open. Cancellation after submission does not undo an accepted update.
+
+Updates do not wait for turn readiness or tool results. Each reply keeps the
+settings it began with. A reply prepared on an early turn-end guess can be
+announced after an update but still use the previous settings revision.
+Modalities, eagerness, and the end-of-turn timeout cannot change mid-session.
+
+`SessionInfo`, `ResponseStarted`, and `ResponseEnded` expose `settingsRevision`.
+It is `null` when the server does not publish it. The field is optional on
+caller-created values. Users do not need to manage it. Use each reply's revision
+to identify its settings, rather than the latest session revision.
+
 ## Choose an operation
 
 Every method returns a promise. Arguments without `?` are required.
 
 | Method | Result and behavior |
 | --- | --- |
+| `update(options?)` | Changes supplied settings without reconnecting; returns `SessionInfo` after acknowledgment. |
 | `sendText(text, options?)` | Starts a typed user turn after readiness; returns `ResponseRef` at response creation. |
 | `sendAudio(chunk, options?)` | Sends microphone audio with transport backpressure. |
 | `requestReply(options?)` | Requests a reply without new user input; returns `ResponseRef`. Options can include `instruction` and `toolCall`. |
 | `addMessage(role, text, options?)` | Adds user or assistant history without a reply; returns `ItemRef` after acknowledgment. |
+| `getHistory(options?)` | Returns the ordered `readonly HistoryItem[]` that the next reply would see. |
+| `createItem(item, options?)` | Adds a message, past tool call, or tool result without a reply; returns `ItemRef` after acknowledgment. Options can include `previousItemId`. |
+| `deleteItem(itemId, options?)` | Hides an item from later replies and waits for acknowledgment. |
 | `submitToolResult(call, output, options?)` | Records a string result and waits for acknowledgment. |
 | `continueReply(parent, options?)` | Waits for parent completion and all tool result acknowledgments, then returns a new `ResponseRef`. |
 | `cancel(response, options?)` | Requests generation cancellation and waits for a terminal response or refusal. |
 | `clearAudio(options?)` | Clears buffered input and resets audio conversion after acknowledgment. |
+| `setResponseMetadata(metadata, options?)` | Replaces the labels for later replies once Prism confirms. |
 | `reportPlayback(report, options?)` | Reports interrupted or finished playback. |
 | `close()` | Closes the session and releases its resources. |
 
 Operation options accept `signal?: AbortSignal`. `requestReply` accepts its
-instruction, tool call, and signal in one object. Methods other than `sendText`,
-`requestReply`, `addMessage`, and `continueReply` return `Promise<void>`.
-
-Text must be nonblank and contain at most 4,000 Unicode characters. History
-roles are `"user"` and `"assistant"`. A reply instruction applies to one response;
-it does not replace session instructions.
+instruction, tool call, and signal in one object. `update` returns
+`Promise<SessionInfo>`. `sendText`, `requestReply`, and `continueReply` return
+`Promise<ResponseRef>`. `addMessage` and `createItem` return `Promise<ItemRef>`.
+`getHistory` returns `Promise<readonly HistoryItem[]>`. The other methods return
+`Promise<void>`.
+
+`sendText` and `addMessage` require nonblank text of at most 4,000 Unicode
+characters. `addMessage` accepts `"user"` and `"assistant"` roles. `createItem`
+also accepts `"system"` messages and allows blank message text, with the same
+length limit. A reply instruction applies to one response; it does not replace
+session instructions.
 
 A returned `ResponseRef` means generation started. Read `response.ended` for the
 terminal status. Generation can finish before cancellation takes effect, so a
@@ -304,7 +364,7 @@ also checks TypeScript callers.
 
 Filler applies when the reply has said nothing before calling a tool. If a reply
 calls several tools, the first call's tool controls the filler. `none` suppresses
-filler only; it does not silence other speech. Settings are fixed for the session.
+filler only; it does not silence other speech. Use `session.update({ tools })` to replace tools and their filler settings.
 
 Execute a tool once for each `tool.call` event. Validate its parsed `arguments`,
 then submit a string result with `submitToolResult(payload.call, output)`.
@@ -337,7 +397,7 @@ are exported from `@rimelabs/sdk`.
 | `input.committed` | `itemId` |
 | `transcript.delta`, `transcript.final` | `itemId` and `delta` or `text` |
 | `transcript.failed` | `itemId`, `error` |
-| `response.started` | `response`, `cause`, nullable `parent` and `inputItemId` |
+| `response.started` | `response`, `cause`, nullable `parent` and `inputItemId`, `inputItemIds` (the user items it answers), `metadata` (your own keys) |
 | `message.started` | `output` |
 | `text.delta`, `text.done` | `output` and `delta` or `text` |
 | `audio.delta`, `audio.done` | `output`; a delta also has `audio.data` and a complete `audio.format` |
@@ -406,6 +466,52 @@ with `RimeRealtimeError`. Its `.fault` has `code`, `message`, `scope`, nullable
 array. A response fault does not itself end generation. Session faults and lost
 connections end the session.
 
+`NormalizedRealtimeFault.retryable` reports whether the same request, unchanged,
+may succeed on another attempt. Read `event.payload.error.retryable` on an `error`
+event or `error.fault.retryable` on `RimeRealtimeError`. The SDK derives this
+value from the code; Prism does not send a retry flag.
+
+`RealtimeFault` accepts the previous fault shape, with an optional `retryable`
+field, for caller-created faults. `RimeRealtimeError` accepts this shape and
+ignores any supplied retry flag. Its `.fault` and SDK-emitted event faults are
+`NormalizedRealtimeFault` values with a required boolean `retryable` field.
+The SDK freezes these faults and their `callIds` arrays. Later changes to a
+constructor input do not change the error's fault.
+
+`TranscriptFailed`, `FaultEvent`, `InputEvent`, and `SessionEvent` default to
+`RealtimeFault`, so existing event literals can omit `retryable`. These types
+also accept a fault type parameter. `session.events` and the `runConversation`
+event callback use `SessionEvent<NormalizedRealtimeFault>`, which gives their
+faults a required boolean `retryable` field. An explicit `SessionEvent`
+annotation uses the default type and makes `retryable` optional.
+
+| Error code | `retryable` |
+| --- | --- |
+| `capacity_exceeded` | `true` |
+| `unavailable` | `true` |
+| `response_timeout` | `true` |
+| `context_length_exceeded` | `false` |
+| All other codes, including unknown codes | `false` |
+
+The application chooses the delay, attempt limit, and recovery operation. This
+value does not start a retry. It does not describe a local `RimeTimeoutError` or
+prove that no output or side effect occurred. The SDK's existing readiness
+retries have separate rules: an explicit refusal such as `typed_turn_busy`
+permits another attempt after a new readiness event, although its `retryable`
+value is `false` under this contract.
+
+For example, Prism can accept a user's question and then report
+`capacity_exceeded`. `sendText()` has already returned a `ResponseRef`; the
+failure arrives through an `error` event. Wait for `response.ended`, then apply
+the application's retry policy. If the question is already in history, use
+`requestReply()` to ask for another reply when appropriate. Repeating
+`sendText()` can add the question twice. A `response_timeout` can follow partial
+text or audio, which the application must handle before another attempt.
+
+For `context_length_exceeded`, the server message contains token counts.
+Unchanged attempts will fail until the conversation is shorter. Start a new
+session with shorter context. Use the history deletion method to remove items before retrying.
+
 Malformed fields in known events and mismatched request acknowledgments close
 the session with `RimeStreamError`. Unknown event kinds and extra fields remain
 accepted and ignored. The SDK does not replay a request after a protocol failure.
@@ -420,7 +526,64 @@ unknown outcome.
 
 Keep up with the event stream. The queue holds 256 events; incoming messages
 are limited to 1 MiB. A slow consumer ends the session. There is no automatic
-reconnect, history replay, or live configuration update.
+reconnect or history replay.
 
 Local peer tests cover the SDK protocol handling. Validate the gateway handshake
 and endpoint behavior for the deployment you use.
+
+The SDK retains the latest 128 interruption policy changes. Instructions or tools
+updates that keep the same interruption policy do not consume this history.
+If an unannounced reply refers to an older evicted policy, the session fails
+with a resource limit error instead of guessing its policy. A reply already
+received keeps its captured policy even after later settings updates.
+
+If an interruption setting changes without a published revision, later reply
+revisions can be ambiguous. The SDK preserves earlier known settings and raises
+a resource limit error for an ambiguous reply instead of guessing. A later
+acknowledgment with a revision establishes a new known setting. Replies without
+a revision use the current acknowledged setting.
+
+## Conversation history operations
+
+Available in the next SDK release. The Prism server must support history operations.
+Read history to obtain the items the next reply would see, in server order.
+Create messages with user, assistant, or system roles, past function calls, and
+function results. Creating an item does not start a reply or execute a tool.
+Message text is limited to 4000 Unicode characters. Optional client item IDs have
+1 to 32 characters. Tool arguments and results preserve the supplied strings.
+
+Omit the insertion anchor to append, use `root` to insert first, or give an item
+ID to insert after its whole turn. Results go after their calls and cannot take
+an anchor. Add a past call before adding its result.
+
+Deletion hides items from subsequent replies and keeps the conversation record.
+Deleting a call or its result hides both. An active reply keeps its original
+context. A deleted active call still needs a result and continuation through the
+existing tool APIs. Deleting an already deleted item succeeds; an unknown ID fails.
+History excludes replies still running and their inputs until those replies end.
+Requests work without typed-turn readiness. A canceled submitted request can still
+take effect; the SDK tracks its acknowledgment and does not replay it.
+
+```text
+const item = await session.createItem({ type: "message", role: "system", text: "Transferred to billing." }, { previousItemId: "root" });
+const items = await session.getHistory();
+await session.deleteItem(item.itemId);
+```
+
+## History truncation
+
+Available in the next SDK release. Set `truncation` at connection setup or during
+an existing session. Omit it to preserve compatibility with older Prism servers.
+The server must support truncation before you send this setting.
+
+`auto` drops the oldest turns and retains 0.8 of the available history capacity.
+`disabled` keeps all history and reports `context_length_exceeded` when it no
+longer fits. A retention ratio above zero and at most one selects how much history
+capacity to retain. Instructions and tools remain. This setting does not delete
+items from the conversation record. Session information reports the acknowledged
+policy in `session.info.truncation`, or `null` when an older server does not
+publish it.
+
+```text
+await session.update({ truncation: { retentionRatio: 0.9 } });
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimelabs/sdk",
-  "version": "0.1.0-alpha.20",
+  "version": "0.1.0-alpha.22",
   "description": "Rime streaming TTS, STT and Prism realtime SDK for Node.js",
   "license": "MIT",
   "type": "module",