@soniox/node 2.0.0 → 2.0.1

package/dist/index.cjs

@@ -342,10 +342,34 @@ var AsyncEventQueue = class {
 		return this.done;
 	}
 	/**
+	* Drop buffered events without ending the queue.
+	*
+	* Intended for owners that know their consumer has gone away (e.g. an
+	* async-iterator consumer broke out of its `for await` loop). The queue
+	* remains active and accepts future pushes. Callers must ensure no other
+	* iterator is concurrently consuming this queue, since this also drops
+	* events those consumers would have observed.
+	*/
+	clear() {
+		this.queue = [];
+	}
+	/**
 	* Async iterator implementation.
+	*
+	* The returned iterator implements `return()` so consumers that exit
+	* `for await` early (via `break`, `throw`, or an outer `return`) cleanly
+	* release the iteration without further work. The queue itself is left
+	* in place — call {@link clear} or {@link end}/{@link abort} if buffered
+	* events should also be dropped.
 	*/
 	[Symbol.asyncIterator]() {
-		return { next: () => this.next() };
+		return {
+			next: () => this.next(),
+			return: (value) => Promise.resolve({
+				value,
+				done: true
+			})
+		};
 	}
 	/**
 	* Get the next event from the queue.
@@ -695,6 +719,7 @@ function filterSpecialTokens(tokens) {
 var RealtimeSttSession = class {
 	emitter = new TypedEmitter();
 	eventQueue = new AsyncEventQueue();
+	iteratorAttached = false;
 	apiKey;
 	wsBaseUrl;
 	config;
@@ -883,9 +908,26 @@ var RealtimeSttSession = class {
 	}
 	/**
 	* Async iterator for consuming events.
+	*
+	* The returned iterator's `return()` resets the internal iterator-attach
+	* flag and drops any buffered events, so consumers that exit `for await`
+	* early (via `break` etc.) stop accruing memory while the session keeps
+	* running.
 	*/
 	[Symbol.asyncIterator]() {
-		return this.eventQueue[Symbol.asyncIterator]();
+		this.iteratorAttached = true;
+		const inner = this.eventQueue[Symbol.asyncIterator]();
+		return {
+			next: () => inner.next(),
+			return: (value) => {
+				this.iteratorAttached = false;
+				this.eventQueue.clear();
+				return inner.return?.(value) ?? Promise.resolve({
+					value,
+					done: true
+				});
+			}
+		};
 	}
 	/**
 	* @internal Debug-only: forcefully close the underlying WebSocket to
@@ -894,6 +936,15 @@ var RealtimeSttSession = class {
 	__debugForceDisconnect() {
 		this.ws?.close(4999, "debug: simulated disconnect");
 	}
+	/**
+	* Push an event to the async iterator queue only when a consumer has
+	* attached via `[Symbol.asyncIterator]()`. Listener-only consumers
+	* (the documented `.on()` pattern) never drain the queue, so pushing
+	* unconditionally would leak buffered events on long-running sessions.
+	*/
+	enqueueIfIterating(event) {
+		if (this.iteratorAttached) this.eventQueue.push(event);
+	}
 	async createWebSocket() {
 		return new Promise((resolve, reject) => {
 			try {
@@ -943,21 +994,21 @@ var RealtimeSttSession = class {
 				tokens: userTokens
 			};
 			this.emitter.emit("result", filteredResult);
-			this.eventQueue.push({
+			this.enqueueIfIterating({
 				kind: "result",
 				data: filteredResult
 			});
 			if (hasEndpoint) {
 				this.emitter.emit("endpoint");
-				this.eventQueue.push({ kind: "endpoint" });
+				this.enqueueIfIterating({ kind: "endpoint" });
 			}
 			if (hasFinalized) {
 				this.emitter.emit("finalized");
-				this.eventQueue.push({ kind: "finalized" });
+				this.enqueueIfIterating({ kind: "finalized" });
 			}
 			if (result.finished) {
 				this.emitter.emit("finished");
-				this.eventQueue.push({ kind: "finished" });
+				this.enqueueIfIterating({ kind: "finished" });
 				this.settleFinish();
 				this.cleanup("finished", void 0, "finished");
 			}
@@ -1142,6 +1193,7 @@ var RealtimeTtsStream = class extends TypedEmitter {
 	streamId;
 	_state = "active";
 	audioQueue = new AsyncEventQueue();
+	iteratorAttached = false;
 	connection;
 	ownsConnection;
 	/** @internal */
@@ -1220,9 +1272,37 @@ var RealtimeTtsStream = class extends TypedEmitter {
 		this._endStream();
 		if (this.ownsConnection) this.connection.close();
 	}
-	/** Async iterator that yields decoded audio chunks. */
+	/**
+	* Async iterator that yields decoded audio chunks.
+	*
+	* The returned iterator's `return()` resets the internal iterator-attach
+	* flag and drops any buffered audio, so consumers that exit `for await`
+	* early (via `break` etc.) stop accruing memory while the stream keeps
+	* receiving server audio.
+	*/
 	[Symbol.asyncIterator]() {
-		return this.audioQueue[Symbol.asyncIterator]();
+		this.iteratorAttached = true;
+		const inner = this.audioQueue[Symbol.asyncIterator]();
+		return {
+			next: () => inner.next(),
+			return: (value) => {
+				this.iteratorAttached = false;
+				this.audioQueue.clear();
+				return inner.return?.(value) ?? Promise.resolve({
+					value,
+					done: true
+				});
+			}
+		};
+	}
+	/**
+	* Push an audio chunk to the async iterator queue only when a consumer
+	* has attached via `[Symbol.asyncIterator]()`. Listener-only consumers
+	* (the documented `.on('audio', ...)` pattern) never drain the queue,
+	* so pushing unconditionally would leak buffered chunks.
+	*/
+	enqueueIfIterating(chunk) {
+		if (this.iteratorAttached) this.audioQueue.push(chunk);
 	}
 	/** @internal Dispatch a server event to this stream. */
 	_handleEvent(event) {
@@ -1239,7 +1319,7 @@ var RealtimeTtsStream = class extends TypedEmitter {
 		if (event.audio !== void 0) {
 			const chunk = decodeBase64ToUint8Array(event.audio);
 			this.emit("audio", chunk);
-			this.audioQueue.push(chunk);
+			this.enqueueIfIterating(chunk);
 		}
 		if (event.audio_end) this.emit("audioEnd");
 		if (event.terminated) this._endStream();