@livekit/agents 1.1.0 → 1.2.0

package/dist/stream/multi_input_stream.d.cts

@@ -0,0 +1,55 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { ReadableStream } from 'node:stream/web';
+/**
+ * A fan-in multiplexer that merges multiple {@link ReadableStream} inputs into
+ * a single output {@link ReadableStream}. Inputs can be dynamically added and
+ * removed at any time while the stream is open.
+ *
+ * Unlike {@link DeferredReadableStream} which supports a single readable source,
+ * `MultiInputStream` allows N concurrent input streams to pump data into one output.
+ *
+ * Key behaviors:
+ * - An error in one input removes that input but does **not** kill the output.
+ * - When all inputs end or are removed, the output stays open (waiting for new inputs).
+ * - The output only closes when {@link close} is called explicitly.
+ * - {@link removeInputStream} releases the reader lock so the source can be reused.
+ */
+export declare class MultiInputStream<T> {
+    private transform;
+    private writer;
+    private inputs;
+    private pumpPromises;
+    private nextId;
+    private _closed;
+    private logger;
+    constructor();
+    /** The single output stream that consumers read from. */
+    get stream(): ReadableStream<T>;
+    /** Number of currently active input streams. */
+    get inputCount(): number;
+    /** Whether {@link close} has been called. */
+    get isClosed(): boolean;
+    /**
+     * Add an input {@link ReadableStream} that will be pumped into the output.
+     *
+     * @returns A unique identifier that can be passed to {@link removeInputStream}.
+     * @throws If the stream has already been closed.
+     */
+    addInputStream(source: ReadableStream<T>): string;
+    /**
+     * Detach an input stream by its ID and release the reader lock so the
+     * source stream can be reused elsewhere.
+     *
+     * No-op if the ID does not exist (e.g. the input already ended or was removed).
+     */
+    removeInputStream(id: string): Promise<void>;
+    /**
+     * Close the output stream and detach all inputs.
+     *
+     * Idempotent — calling more than once is a no-op.
+     */
+    close(): Promise<void>;
+    private shouldStopPumping;
+    private pumpInput;
+}
+//# sourceMappingURL=multi_input_stream.d.ts.map

package/dist/stream/multi_input_stream.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { ReadableStream } from 'node:stream/web';
+/**
+ * A fan-in multiplexer that merges multiple {@link ReadableStream} inputs into
+ * a single output {@link ReadableStream}. Inputs can be dynamically added and
+ * removed at any time while the stream is open.
+ *
+ * Unlike {@link DeferredReadableStream} which supports a single readable source,
+ * `MultiInputStream` allows N concurrent input streams to pump data into one output.
+ *
+ * Key behaviors:
+ * - An error in one input removes that input but does **not** kill the output.
+ * - When all inputs end or are removed, the output stays open (waiting for new inputs).
+ * - The output only closes when {@link close} is called explicitly.
+ * - {@link removeInputStream} releases the reader lock so the source can be reused.
+ */
+export declare class MultiInputStream<T> {
+    private transform;
+    private writer;
+    private inputs;
+    private pumpPromises;
+    private nextId;
+    private _closed;
+    private logger;
+    constructor();
+    /** The single output stream that consumers read from. */
+    get stream(): ReadableStream<T>;
+    /** Number of currently active input streams. */
+    get inputCount(): number;
+    /** Whether {@link close} has been called. */
+    get isClosed(): boolean;
+    /**
+     * Add an input {@link ReadableStream} that will be pumped into the output.
+     *
+     * @returns A unique identifier that can be passed to {@link removeInputStream}.
+     * @throws If the stream has already been closed.
+     */
+    addInputStream(source: ReadableStream<T>): string;
+    /**
+     * Detach an input stream by its ID and release the reader lock so the
+     * source stream can be reused elsewhere.
+     *
+     * No-op if the ID does not exist (e.g. the input already ended or was removed).
+     */
+    removeInputStream(id: string): Promise<void>;
+    /**
+     * Close the output stream and detach all inputs.
+     *
+     * Idempotent — calling more than once is a no-op.
+     */
+    close(): Promise<void>;
+    private shouldStopPumping;
+    private pumpInput;
+}
+//# sourceMappingURL=multi_input_stream.d.ts.map

package/dist/stream/multi_input_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi_input_stream.d.ts","sourceRoot":"","sources":["../../src/stream/multi_input_stream.ts"],"names":[],"mappings":";AAGA,OAAO,KAAK,EACV,cAAc,EAGf,MAAM,iBAAiB,CAAC;AAKzB;;;;;;;;;;;;;GAaG;AACH,qBAAa,gBAAgB,CAAC,CAAC;IAC7B,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,MAAM,CAAiC;IAC/C,OAAO,CAAC,MAAM,CAA0D;IACxE,OAAO,CAAC,YAAY,CAAyC;IAC7D,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAS;;IAOvB,yDAAyD;IACzD,IAAI,MAAM,IAAI,cAAc,CAAC,CAAC,CAAC,CAE9B;IAED,gDAAgD;IAChD,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,6CAA6C;IAC7C,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED;;;;;OAKG;IACH,cAAc,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,MAAM;IAejD;;;;;OAKG;IACG,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBlD;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA4B5B,OAAO,CAAC,iBAAiB;YAIX,SAAS;CAiCxB"}

package/dist/stream/multi_input_stream.js

@@ -0,0 +1,115 @@
+import { log } from "../log.js";
+import { isStreamReaderReleaseError } from "./deferred_stream.js";
+import { IdentityTransform } from "./identity_transform.js";
+class MultiInputStream {
+  transform;
+  writer;
+  inputs = /* @__PURE__ */ new Map();
+  pumpPromises = /* @__PURE__ */ new Map();
+  nextId = 0;
+  _closed = false;
+  logger = log();
+  constructor() {
+    this.transform = new IdentityTransform();
+    this.writer = this.transform.writable.getWriter();
+  }
+  /** The single output stream that consumers read from. */
+  get stream() {
+    return this.transform.readable;
+  }
+  /** Number of currently active input streams. */
+  get inputCount() {
+    return this.inputs.size;
+  }
+  /** Whether {@link close} has been called. */
+  get isClosed() {
+    return this._closed;
+  }
+  /**
+   * Add an input {@link ReadableStream} that will be pumped into the output.
+   *
+   * @returns A unique identifier that can be passed to {@link removeInputStream}.
+   * @throws If the stream has already been closed.
+   */
+  addInputStream(source) {
+    if (this._closed) {
+      throw new Error("MultiInputStream is closed");
+    }
+    const id = `input-${this.nextId++}`;
+    const reader = source.getReader();
+    this.inputs.set(id, reader);
+    const pumpDone = this.pumpInput(id, reader);
+    this.pumpPromises.set(id, pumpDone);
+    return id;
+  }
+  /**
+   * Detach an input stream by its ID and release the reader lock so the
+   * source stream can be reused elsewhere.
+   *
+   * No-op if the ID does not exist (e.g. the input already ended or was removed).
+   */
+  async removeInputStream(id) {
+    const reader = this.inputs.get(id);
+    if (!reader) return;
+    this.inputs.delete(id);
+    reader.releaseLock();
+    const pump = this.pumpPromises.get(id);
+    if (pump) {
+      await pump;
+      this.pumpPromises.delete(id);
+    }
+  }
+  /**
+   * Close the output stream and detach all inputs.
+   *
+   * Idempotent — calling more than once is a no-op.
+   */
+  async close() {
+    if (this._closed) return;
+    this._closed = true;
+    for (const reader of this.inputs.values()) {
+      reader.releaseLock();
+    }
+    this.inputs.clear();
+    await Promise.allSettled([...this.pumpPromises.values()]);
+    this.pumpPromises.clear();
+    try {
+      this.writer.releaseLock();
+    } catch {
+    }
+    try {
+      await this.transform.writable.close();
+    } catch {
+    }
+  }
+  shouldStopPumping(id) {
+    return this._closed || !this.inputs.has(id);
+  }
+  async pumpInput(id, reader) {
+    try {
+      while (true) {
+        if (this.shouldStopPumping(id)) break;
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (this.shouldStopPumping(id)) break;
+        await this.writer.write(value);
+      }
+    } catch (e) {
+      if (isStreamReaderReleaseError(e)) {
+        return;
+      }
+      this.logger.error({ error: e }, "Error pumping input stream from MultiInputStream");
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch {
+      }
+      this.inputs.delete(id);
+      this.pumpPromises.delete(id);
+    }
+  }
+}
+export {
+  MultiInputStream
+};
+//# sourceMappingURL=multi_input_stream.js.map

package/dist/stream/multi_input_stream.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/stream/multi_input_stream.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2025 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type {\n  ReadableStream,\n  ReadableStreamDefaultReader,\n  WritableStreamDefaultWriter,\n} from 'node:stream/web';\nimport { log } from '../log.js';\nimport { isStreamReaderReleaseError } from './deferred_stream.js';\nimport { IdentityTransform } from './identity_transform.js';\n\n/**\n * A fan-in multiplexer that merges multiple {@link ReadableStream} inputs into\n * a single output {@link ReadableStream}. Inputs can be dynamically added and\n * removed at any time while the stream is open.\n *\n * Unlike {@link DeferredReadableStream} which supports a single readable source,\n * `MultiInputStream` allows N concurrent input streams to pump data into one output.\n *\n * Key behaviors:\n * - An error in one input removes that input but does **not** kill the output.\n * - When all inputs end or are removed, the output stays open (waiting for new inputs).\n * - The output only closes when {@link close} is called explicitly.\n * - {@link removeInputStream} releases the reader lock so the source can be reused.\n */\nexport class MultiInputStream<T> {\n  private transform: IdentityTransform<T>;\n  private writer: WritableStreamDefaultWriter<T>;\n  private inputs: Map<string, ReadableStreamDefaultReader<T>> = new Map();\n  private pumpPromises: Map<string, Promise<void>> = new Map();\n  private nextId = 0;\n  private _closed = false;\n  private logger = log();\n\n  constructor() {\n    this.transform = new IdentityTransform<T>();\n    this.writer = this.transform.writable.getWriter();\n  }\n\n  /** The single output stream that consumers read from. */\n  get stream(): ReadableStream<T> {\n    return this.transform.readable;\n  }\n\n  /** Number of currently active input streams. */\n  get inputCount(): number {\n    return this.inputs.size;\n  }\n\n  /** Whether {@link close} has been called. */\n  get isClosed(): boolean {\n    return this._closed;\n  }\n\n  /**\n   * Add an input {@link ReadableStream} that will be pumped into the output.\n   *\n   * @returns A unique identifier that can be passed to {@link removeInputStream}.\n   * @throws If the stream has already been closed.\n   */\n  addInputStream(source: ReadableStream<T>): string {\n    if (this._closed) {\n      throw new Error('MultiInputStream is closed');\n    }\n\n    const id = `input-${this.nextId++}`;\n    const reader = source.getReader();\n    this.inputs.set(id, reader);\n\n    const pumpDone = this.pumpInput(id, reader);\n    this.pumpPromises.set(id, pumpDone);\n\n    return id;\n  }\n\n  /**\n   * Detach an input stream by its ID and release the reader lock so the\n   * source stream can be reused elsewhere.\n   *\n   * No-op if the ID does not exist (e.g. the input already ended or was removed).\n   */\n  async removeInputStream(id: string): Promise<void> {\n    const reader = this.inputs.get(id);\n    if (!reader) return;\n\n    // Delete first so the pump's finally-block is a harmless no-op.\n    this.inputs.delete(id);\n\n    // Releasing the lock causes any pending reader.read() inside pump to throw\n    // a TypeError, which is caught by isStreamReaderReleaseError.\n    reader.releaseLock();\n\n    // Wait for the pump to finish so the caller knows cleanup is complete.\n    const pump = this.pumpPromises.get(id);\n    if (pump) {\n      await pump;\n      this.pumpPromises.delete(id);\n    }\n  }\n\n  /**\n   * Close the output stream and detach all inputs.\n   *\n   * Idempotent — calling more than once is a no-op.\n   */\n  async close(): Promise<void> {\n    if (this._closed) return;\n    this._closed = true;\n\n    // Release every input reader to unblock pending reads inside pumps.\n    for (const reader of this.inputs.values()) {\n      reader.releaseLock();\n    }\n    this.inputs.clear();\n\n    // Wait for every pump loop to finish before touching the writer.\n    await Promise.allSettled([...this.pumpPromises.values()]);\n    this.pumpPromises.clear();\n\n    // Close the output writer + writable side of the transform.\n    try {\n      this.writer.releaseLock();\n    } catch {\n      // ignore if already released\n    }\n\n    try {\n      await this.transform.writable.close();\n    } catch {\n      // ignore if already closed\n    }\n  }\n\n  private shouldStopPumping(id: string): boolean {\n    return this._closed || !this.inputs.has(id);\n  }\n\n  private async pumpInput(id: string, reader: ReadableStreamDefaultReader<T>): Promise<void> {\n    try {\n      while (true) {\n        // If the stream was closed or the input was removed while we were\n        // awaiting the previous write, bail out immediately.\n        if (this.shouldStopPumping(id)) break;\n\n        const { done, value } = await reader.read();\n        if (done) break;\n\n        // Double-check after the (potentially long) read.\n        if (this.shouldStopPumping(id)) break;\n\n        await this.writer.write(value);\n      }\n    } catch (e) {\n      // TypeErrors from releaseLock() during removeInputStream / close are expected.\n      if (isStreamReaderReleaseError(e)) {\n        return;\n      }\n\n      this.logger.error({ error: e }, 'Error pumping input stream from MultiInputStream');\n    } finally {\n      try {\n        reader.releaseLock();\n      } catch {\n        // ignore if already released\n      }\n\n      this.inputs.delete(id);\n      this.pumpPromises.delete(id);\n    }\n  }\n}\n"],"mappings":"AAQA,SAAS,WAAW;AACpB,SAAS,kCAAkC;AAC3C,SAAS,yBAAyB;AAgB3B,MAAM,iBAAoB;AAAA,EACvB;AAAA,EACA;AAAA,EACA,SAAsD,oBAAI,IAAI;AAAA,EAC9D,eAA2C,oBAAI,IAAI;AAAA,EACnD,SAAS;AAAA,EACT,UAAU;AAAA,EACV,SAAS,IAAI;AAAA,EAErB,cAAc;AACZ,SAAK,YAAY,IAAI,kBAAqB;AAC1C,SAAK,SAAS,KAAK,UAAU,SAAS,UAAU;AAAA,EAClD;AAAA;AAAA,EAGA,IAAI,SAA4B;AAC9B,WAAO,KAAK,UAAU;AAAA,EACxB;AAAA;AAAA,EAGA,IAAI,aAAqB;AACvB,WAAO,KAAK,OAAO;AAAA,EACrB;AAAA;AAAA,EAGA,IAAI,WAAoB;AACtB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,eAAe,QAAmC;AAChD,QAAI,KAAK,SAAS;AAChB,YAAM,IAAI,MAAM,4BAA4B;AAAA,IAC9C;AAEA,UAAM,KAAK,SAAS,KAAK,QAAQ;AACjC,UAAM,SAAS,OAAO,UAAU;AAChC,SAAK,OAAO,IAAI,IAAI,MAAM;AAE1B,UAAM,WAAW,KAAK,UAAU,IAAI,MAAM;AAC1C,SAAK,aAAa,IAAI,IAAI,QAAQ;AAElC,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAM,kBAAkB,IAA2B;AACjD,UAAM,SAAS,KAAK,OAAO,IAAI,EAAE;AACjC,QAAI,CAAC,OAAQ;AAGb,SAAK,OAAO,OAAO,EAAE;AAIrB,WAAO,YAAY;AAGnB,UAAM,OAAO,KAAK,aAAa,IAAI,EAAE;AACrC,QAAI,MAAM;AACR,YAAM;AACN,WAAK,aAAa,OAAO,EAAE;AAAA,IAC7B;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,QAAuB;AAC3B,QAAI,KAAK,QAAS;AAClB,SAAK,UAAU;AAGf,eAAW,UAAU,KAAK,OAAO,OAAO,GAAG;AACzC,aAAO,YAAY;AAAA,IACrB;AACA,SAAK,OAAO,MAAM;AAGlB,UAAM,QAAQ,WAAW,CAAC,GAAG,KAAK,aAAa,OAAO,CAAC,CAAC;AACxD,SAAK,aAAa,MAAM;AAGxB,QAAI;AACF,WAAK,OAAO,YAAY;AAAA,IAC1B,QAAQ;AAAA,IAER;AAEA,QAAI;AACF,YAAM,KAAK,UAAU,SAAS,MAAM;AAAA,IACtC,QAAQ;AAAA,IAER;AAAA,EACF;AAAA,EAEQ,kBAAkB,IAAqB;AAC7C,WAAO,KAAK,WAAW,CAAC,KAAK,OAAO,IAAI,EAAE;AAAA,EAC5C;AAAA,EAEA,MAAc,UAAU,IAAY,QAAuD;AACzF,QAAI;AACF,aAAO,MAAM;AAGX,YAAI,KAAK,kBAAkB,EAAE,EAAG;AAEhC,cAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAC1C,YAAI,KAAM;AAGV,YAAI,KAAK,kBAAkB,EAAE,EAAG;AAEhC,cAAM,KAAK,OAAO,MAAM,KAAK;AAAA,MAC/B;AAAA,IACF,SAAS,GAAG;AAEV,UAAI,2BAA2B,CAAC,GAAG;AACjC;AAAA,MACF;AAEA,WAAK,OAAO,MAAM,EAAE,OAAO,EAAE,GAAG,kDAAkD;AAAA,IACpF,UAAE;AACA,UAAI;AACF,eAAO,YAAY;AAAA,MACrB,QAAQ;AAAA,MAER;AAEA,WAAK,OAAO,OAAO,EAAE;AACrB,WAAK,aAAa,OAAO,EAAE;AAAA,IAC7B;AAAA,EACF;AACF;","names":[]}

package/dist/stream/multi_input_stream.test.cjs

@@ -0,0 +1,344 @@
+"use strict";
+var import_web = require("node:stream/web");
+var import_vitest = require("vitest");
+var import_log = require("../log.cjs");
+var import_utils = require("../utils.cjs");
+var import_multi_input_stream = require("./multi_input_stream.cjs");
+function streamFrom(values) {
+  return new import_web.ReadableStream({
+    start(controller) {
+      for (const v of values) controller.enqueue(v);
+      controller.close();
+    }
+  });
+}
+(0, import_vitest.describe)("MultiInputStream", () => {
+  (0, import_vitest.beforeAll)(() => {
+    (0, import_log.initializeLogger)({ pretty: false });
+  });
+  (0, import_vitest.it)("should create a readable output stream", () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    (0, import_vitest.expect)(multi.stream).toBeInstanceOf(import_web.ReadableStream);
+    (0, import_vitest.expect)(multi.inputCount).toBe(0);
+    (0, import_vitest.expect)(multi.isClosed).toBe(false);
+  });
+  (0, import_vitest.it)("should read data from a single input stream", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const reader = multi.stream.getReader();
+    multi.addInputStream(streamFrom(["a", "b", "c"]));
+    const results = [];
+    for (let i = 0; i < 3; i++) {
+      const { value } = await reader.read();
+      results.push(value);
+    }
+    (0, import_vitest.expect)(results).toEqual(["a", "b", "c"]);
+    reader.releaseLock();
+    await multi.close();
+  });
+  (0, import_vitest.it)("should merge data from multiple input streams", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const reader = multi.stream.getReader();
+    multi.addInputStream(streamFrom([1, 2]));
+    multi.addInputStream(streamFrom([3, 4]));
+    const results = [];
+    for (let i = 0; i < 4; i++) {
+      const { value } = await reader.read();
+      results.push(value);
+    }
+    (0, import_vitest.expect)(results.sort()).toEqual([1, 2, 3, 4]);
+    reader.releaseLock();
+    await multi.close();
+  });
+  (0, import_vitest.it)("should allow adding inputs dynamically while reading", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const reader = multi.stream.getReader();
+    multi.addInputStream(streamFrom(["first"]));
+    const r1 = await reader.read();
+    (0, import_vitest.expect)(r1.value).toBe("first");
+    multi.addInputStream(streamFrom(["second"]));
+    const r2 = await reader.read();
+    (0, import_vitest.expect)(r2.value).toBe("second");
+    reader.releaseLock();
+    await multi.close();
+  });
+  (0, import_vitest.it)("should continue reading from remaining inputs after removing one", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const reader = multi.stream.getReader();
+    const slowSource = new import_web.ReadableStream({
+      async start(controller) {
+        controller.enqueue("slow-1");
+        await (0, import_utils.delay)(50);
+        controller.enqueue("slow-2");
+        await (0, import_utils.delay)(50);
+        controller.enqueue("slow-3");
+        controller.close();
+      }
+    });
+    const slowId = multi.addInputStream(slowSource);
+    const r1 = await reader.read();
+    (0, import_vitest.expect)(r1.value).toBe("slow-1");
+    await multi.removeInputStream(slowId);
+    multi.addInputStream(streamFrom(["fast-1", "fast-2"]));
+    const r2 = await reader.read();
+    (0, import_vitest.expect)(r2.value).toBe("fast-1");
+    const r3 = await reader.read();
+    (0, import_vitest.expect)(r3.value).toBe("fast-2");
+    reader.releaseLock();
+    await multi.close();
+  });
+  (0, import_vitest.it)("should handle swapping inputs (remove then add)", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const reader = multi.stream.getReader();
+    const id1 = multi.addInputStream(streamFrom(["from-A"]));
+    const r1 = await reader.read();
+    (0, import_vitest.expect)(r1.value).toBe("from-A");
+    await multi.removeInputStream(id1);
+    const id2 = multi.addInputStream(streamFrom(["from-B"]));
+    const r2 = await reader.read();
+    (0, import_vitest.expect)(r2.value).toBe("from-B");
+    await multi.removeInputStream(id2);
+    reader.releaseLock();
+    await multi.close();
+  });
+  (0, import_vitest.it)("should keep reader awaiting until an input is added", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const reader = multi.stream.getReader();
+    let readCompleted = false;
+    const readPromise = reader.read().then((result2) => {
+      readCompleted = true;
+      return result2;
+    });
+    await (0, import_utils.delay)(50);
+    (0, import_vitest.expect)(readCompleted).toBe(false);
+    multi.addInputStream(streamFrom(["hello"]));
+    const result = await readPromise;
+    (0, import_vitest.expect)(readCompleted).toBe(true);
+    (0, import_vitest.expect)(result.value).toBe("hello");
+    reader.releaseLock();
+    await multi.close();
+  });
+  (0, import_vitest.it)("should handle empty input streams without closing the output", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const reader = multi.stream.getReader();
+    multi.addInputStream(streamFrom([]));
+    await (0, import_utils.delay)(20);
+    multi.addInputStream(streamFrom(["data"]));
+    const result = await reader.read();
+    (0, import_vitest.expect)(result.value).toBe("data");
+    reader.releaseLock();
+    await multi.close();
+  });
+  (0, import_vitest.it)("should remove errored input without killing the output", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const reader = multi.stream.getReader();
+    const errorSource = new import_web.ReadableStream({
+      async start(controller) {
+        controller.enqueue("before-error");
+        await (0, import_utils.delay)(20);
+        controller.error(new Error("boom"));
+      }
+    });
+    multi.addInputStream(errorSource);
+    const r1 = await reader.read();
+    (0, import_vitest.expect)(r1.value).toBe("before-error");
+    await (0, import_utils.delay)(50);
+    (0, import_vitest.expect)(multi.inputCount).toBe(0);
+    multi.addInputStream(streamFrom(["after-error"]));
+    const r2 = await reader.read();
+    (0, import_vitest.expect)(r2.value).toBe("after-error");
+    reader.releaseLock();
+    await multi.close();
+  });
+  (0, import_vitest.it)("should keep other inputs alive when one errors", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const reader = multi.stream.getReader();
+    const goodSource = new import_web.ReadableStream({
+      async start(controller) {
+        await (0, import_utils.delay)(60);
+        controller.enqueue("good");
+        controller.close();
+      }
+    });
+    const badSource = new import_web.ReadableStream({
+      async start(controller) {
+        controller.error(new Error("bad"));
+      }
+    });
+    multi.addInputStream(goodSource);
+    multi.addInputStream(badSource);
+    await (0, import_utils.delay)(10);
+    const result = await reader.read();
+    (0, import_vitest.expect)(result.value).toBe("good");
+    reader.releaseLock();
+    await multi.close();
+  });
+  (0, import_vitest.it)("should end the output stream with done:true when close is called", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const reader = multi.stream.getReader();
+    multi.addInputStream(streamFrom(["data"]));
+    const r1 = await reader.read();
+    (0, import_vitest.expect)(r1.value).toBe("data");
+    await multi.close();
+    const r2 = await reader.read();
+    (0, import_vitest.expect)(r2.done).toBe(true);
+    (0, import_vitest.expect)(r2.value).toBeUndefined();
+    reader.releaseLock();
+  });
+  (0, import_vitest.it)("should resolve pending reads as done when close is called", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const reader = multi.stream.getReader();
+    const readPromise = reader.read();
+    await (0, import_utils.delay)(10);
+    await multi.close();
+    const result = await readPromise;
+    (0, import_vitest.expect)(result.done).toBe(true);
+    (0, import_vitest.expect)(result.value).toBeUndefined();
+    reader.releaseLock();
+  });
+  (0, import_vitest.it)("should be idempotent for multiple close calls", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    await multi.close();
+    await multi.close();
+    (0, import_vitest.expect)(multi.isClosed).toBe(true);
+  });
+  (0, import_vitest.it)("should throw when adding input after close", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    await multi.close();
+    (0, import_vitest.expect)(() => multi.addInputStream(streamFrom(["x"]))).toThrow("MultiInputStream is closed");
+  });
+  (0, import_vitest.it)("should no-op when removing a non-existent input", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    await multi.removeInputStream("does-not-exist");
+    await multi.close();
+  });
+  (0, import_vitest.it)("should release the source reader lock so the source can be reused", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const reader = multi.stream.getReader();
+    const source = new import_web.ReadableStream({
+      async start(controller) {
+        controller.enqueue("chunk-0");
+        await (0, import_utils.delay)(30);
+        controller.enqueue("chunk-1");
+        controller.close();
+      }
+    });
+    const id = multi.addInputStream(source);
+    const r1 = await reader.read();
+    (0, import_vitest.expect)(r1.value).toBe("chunk-0");
+    await multi.removeInputStream(id);
+    const sourceReader = source.getReader();
+    const sr = await sourceReader.read();
+    (0, import_vitest.expect)(sr.value).toBe("chunk-1");
+    sourceReader.releaseLock();
+    reader.releaseLock();
+    await multi.close();
+  });
+  (0, import_vitest.it)("should track inputCount correctly through add / remove / natural end", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    (0, import_vitest.expect)(multi.inputCount).toBe(0);
+    const id1 = multi.addInputStream(streamFrom(["a"]));
+    const id2 = multi.addInputStream(streamFrom(["b"]));
+    (0, import_vitest.expect)(multi.inputCount).toBe(2);
+    await multi.removeInputStream(id1);
+    (0, import_vitest.expect)(multi.inputCount).toBeLessThanOrEqual(1);
+    await (0, import_utils.delay)(20);
+    (0, import_vitest.expect)(multi.inputCount).toBe(0);
+    await multi.removeInputStream(id2);
+    (0, import_vitest.expect)(multi.inputCount).toBe(0);
+    await multi.close();
+  });
+  (0, import_vitest.it)("should handle concurrent reads and slow writes", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const reader = multi.stream.getReader();
+    const chunks = ["a", "b", "c", "d", "e"];
+    let idx = 0;
+    const source = new import_web.ReadableStream({
+      start(controller) {
+        const writeNext = () => {
+          if (idx < chunks.length) {
+            controller.enqueue(chunks[idx++]);
+            setTimeout(writeNext, 5);
+          } else {
+            controller.close();
+          }
+        };
+        writeNext();
+      }
+    });
+    multi.addInputStream(source);
+    const results = [];
+    for (let i = 0; i < chunks.length; i++) {
+      const { value } = await reader.read();
+      results.push(value);
+    }
+    (0, import_vitest.expect)(results).toEqual(chunks);
+    reader.releaseLock();
+    await multi.close();
+  });
+  (0, import_vitest.it)("should handle backpressure with large data", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const largeChunks = Array.from({ length: 1e3 }, (_, i) => `chunk-${i}`);
+    multi.addInputStream(streamFrom(largeChunks));
+    const reader = multi.stream.getReader();
+    const results = [];
+    let result = await reader.read();
+    while (!result.done) {
+      results.push(result.value);
+      if (results.length === largeChunks.length) break;
+      result = await reader.read();
+    }
+    (0, import_vitest.expect)(results).toEqual(largeChunks);
+    reader.releaseLock();
+    await multi.close();
+  });
+  (0, import_vitest.it)("should support tee on the output stream", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const [s1, s2] = multi.stream.tee();
+    const r1 = s1.getReader();
+    const r2 = s2.getReader();
+    multi.addInputStream(streamFrom([10, 20]));
+    const [a1, a2] = await Promise.all([r1.read(), r2.read()]);
+    (0, import_vitest.expect)(a1.value).toBe(10);
+    (0, import_vitest.expect)(a2.value).toBe(10);
+    const [b1, b2] = await Promise.all([r1.read(), r2.read()]);
+    (0, import_vitest.expect)(b1.value).toBe(20);
+    (0, import_vitest.expect)(b2.value).toBe(20);
+    r1.releaseLock();
+    r2.releaseLock();
+    await multi.close();
+  });
+  (0, import_vitest.it)("should return unique IDs from addInputStream", () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const id1 = multi.addInputStream(streamFrom(["a"]));
+    const id2 = multi.addInputStream(streamFrom(["b"]));
+    const id3 = multi.addInputStream(streamFrom(["c"]));
+    (0, import_vitest.expect)(id1).not.toBe(id2);
+    (0, import_vitest.expect)(id2).not.toBe(id3);
+    (0, import_vitest.expect)(id1).not.toBe(id3);
+  });
+  (0, import_vitest.it)("should cleanly close while pumps are actively writing", async () => {
+    const multi = new import_multi_input_stream.MultiInputStream();
+    const reader = multi.stream.getReader();
+    const infiniteSource = new import_web.ReadableStream({
+      async start(controller) {
+        let i = 0;
+        while (true) {
+          try {
+            controller.enqueue(`tick-${i++}`);
+          } catch {
+            break;
+          }
+          await (0, import_utils.delay)(5);
+        }
+      }
+    });
+    multi.addInputStream(infiniteSource);
+    const r1 = await reader.read();
+    (0, import_vitest.expect)(r1.done).toBe(false);
+    await multi.close();
+    const r2 = await reader.read();
+    (0, import_vitest.expect)(r2.done).toBe(true);
+    reader.releaseLock();
+  });
+});
+//# sourceMappingURL=multi_input_stream.test.cjs.map

package/dist/stream/multi_input_stream.test.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/stream/multi_input_stream.test.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2025 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport { ReadableStream } from 'node:stream/web';\nimport { beforeAll, describe, expect, it } from 'vitest';\nimport { initializeLogger } from '../log.js';\nimport { delay } from '../utils.js';\nimport { MultiInputStream } from './multi_input_stream.js';\n\nfunction streamFrom<T>(values: T[]): ReadableStream<T> {\n  return new ReadableStream<T>({\n    start(controller) {\n      for (const v of values) controller.enqueue(v);\n      controller.close();\n    },\n  });\n}\n\ndescribe('MultiInputStream', () => {\n  beforeAll(() => {\n    initializeLogger({ pretty: false });\n  });\n\n  // ---------------------------------------------------------------------------\n  // Basic functionality\n  // ---------------------------------------------------------------------------\n\n  it('should create a readable output stream', () => {\n    const multi = new MultiInputStream<string>();\n    expect(multi.stream).toBeInstanceOf(ReadableStream);\n    expect(multi.inputCount).toBe(0);\n    expect(multi.isClosed).toBe(false);\n  });\n\n  it('should read data from a single input stream', async () => {\n    const multi = new MultiInputStream<string>();\n    const reader = multi.stream.getReader();\n\n    multi.addInputStream(streamFrom(['a', 'b', 'c']));\n\n    const results: string[] = [];\n    // Read three values then close manually (output stays open after input ends).\n    for (let i = 0; i < 3; i++) {\n      const { value } = await reader.read();\n      results.push(value!);\n    }\n\n    expect(results).toEqual(['a', 'b', 'c']);\n    reader.releaseLock();\n    await multi.close();\n  });\n\n  it('should merge data from multiple input streams', async () => {\n    const multi = new MultiInputStream<number>();\n    const reader = multi.stream.getReader();\n\n    multi.addInputStream(streamFrom([1, 2]));\n    multi.addInputStream(streamFrom([3, 4]));\n\n    const results: number[] = [];\n    for (let i = 0; i < 4; i++) {\n      const { value } = await reader.read();\n      results.push(value!);\n    }\n\n    // Order is non-deterministic but all values must arrive.\n    expect(results.sort()).toEqual([1, 2, 3, 4]);\n    reader.releaseLock();\n    await multi.close();\n  });\n\n  // ---------------------------------------------------------------------------\n  // Dynamic add / remove\n  // ---------------------------------------------------------------------------\n\n  it('should allow adding inputs dynamically while reading', async () => {\n    const multi = new MultiInputStream<string>();\n    const reader = multi.stream.getReader();\n\n    multi.addInputStream(streamFrom(['first']));\n\n    const r1 = await reader.read();\n    expect(r1.value).toBe('first');\n\n    // Add a second input after reading from the first.\n    multi.addInputStream(streamFrom(['second']));\n\n    const r2 = await reader.read();\n    expect(r2.value).toBe('second');\n\n    reader.releaseLock();\n    await multi.close();\n  });\n\n  it('should continue reading from remaining inputs after removing one', async () => {\n    const multi = new MultiInputStream<string>();\n    const reader = multi.stream.getReader();\n\n    // A slow stream that emits over time.\n    const slowSource = new ReadableStream<string>({\n      async start(controller) {\n        controller.enqueue('slow-1');\n        await delay(50);\n        controller.enqueue('slow-2');\n        await delay(50);\n        controller.enqueue('slow-3');\n        controller.close();\n      },\n    });\n\n    const slowId = multi.addInputStream(slowSource);\n\n    // Read first value from slow source.\n    const r1 = await reader.read();\n    expect(r1.value).toBe('slow-1');\n\n    // Remove the slow source and add a fast one.\n    await multi.removeInputStream(slowId);\n\n    multi.addInputStream(streamFrom(['fast-1', 'fast-2']));\n\n    const r2 = await reader.read();\n    expect(r2.value).toBe('fast-1');\n\n    const r3 = await reader.read();\n    expect(r3.value).toBe('fast-2');\n\n    reader.releaseLock();\n    await multi.close();\n  });\n\n  it('should handle swapping inputs (remove then add)', async () => {\n    const multi = new MultiInputStream<string>();\n    const reader = multi.stream.getReader();\n\n    const id1 = multi.addInputStream(streamFrom(['from-A']));\n\n    const r1 = await reader.read();\n    expect(r1.value).toBe('from-A');\n\n    await multi.removeInputStream(id1);\n\n    const id2 = multi.addInputStream(streamFrom(['from-B']));\n\n    const r2 = await reader.read();\n    expect(r2.value).toBe('from-B');\n\n    await multi.removeInputStream(id2);\n    reader.releaseLock();\n    await multi.close();\n  });\n\n  // ---------------------------------------------------------------------------\n  // Reading before any input is added\n  // ---------------------------------------------------------------------------\n\n  it('should keep reader awaiting until an input is added', async () => {\n    const multi = new MultiInputStream<string>();\n    const reader = multi.stream.getReader();\n\n    let readCompleted = false;\n    const readPromise = reader.read().then((result) => {\n      readCompleted = true;\n      return result;\n    });\n\n    await delay(50);\n    expect(readCompleted).toBe(false);\n\n    // Now add an input to unblock the read.\n    multi.addInputStream(streamFrom(['hello']));\n\n    const result = await readPromise;\n    expect(readCompleted).toBe(true);\n    expect(result.value).toBe('hello');\n\n    reader.releaseLock();\n    await multi.close();\n  });\n\n  // ---------------------------------------------------------------------------\n  // Empty input streams\n  // ---------------------------------------------------------------------------\n\n  it('should handle empty input streams without closing the output', async () => {\n    const multi = new MultiInputStream<string>();\n    const reader = multi.stream.getReader();\n\n    // Add an empty stream — it should end immediately without affecting the output.\n    multi.addInputStream(streamFrom([]));\n\n    await delay(20);\n\n    // The output should still be open. Adding a real input should work.\n    multi.addInputStream(streamFrom(['data']));\n\n    const result = await reader.read();\n    expect(result.value).toBe('data');\n\n    reader.releaseLock();\n    await multi.close();\n  });\n\n  // ---------------------------------------------------------------------------\n  // Error handling\n  // ---------------------------------------------------------------------------\n\n  it('should remove errored input without killing the output', async () => {\n    const multi = new MultiInputStream<string>();\n    const reader = multi.stream.getReader();\n\n    // An input that errors after emitting one value.\n    const errorSource = new ReadableStream<string>({\n      async start(controller) {\n        controller.enqueue('before-error');\n        await delay(20);\n        controller.error(new Error('boom'));\n      },\n    });\n\n    multi.addInputStream(errorSource);\n\n    const r1 = await reader.read();\n    expect(r1.value).toBe('before-error');\n\n    // Wait for the error to propagate and the input to be removed.\n    await delay(50);\n\n    expect(multi.inputCount).toBe(0);\n\n    // The output is still alive — we can add another input.\n    multi.addInputStream(streamFrom(['after-error']));\n\n    const r2 = await reader.read();\n    expect(r2.value).toBe('after-error');\n\n    reader.releaseLock();\n    await multi.close();\n  });\n\n  it('should keep other inputs alive when one errors', async () => {\n    const multi = new MultiInputStream<string>();\n    const reader = multi.stream.getReader();\n\n    const goodSource = new ReadableStream<string>({\n      async start(controller) {\n        await delay(60);\n        controller.enqueue('good');\n        controller.close();\n      },\n    });\n\n    const badSource = new ReadableStream<string>({\n      async start(controller) {\n        controller.error(new Error('bad'));\n      },\n    });\n\n    multi.addInputStream(goodSource);\n    multi.addInputStream(badSource);\n\n    // Wait a bit for the bad source to error and be removed.\n    await delay(10);\n\n    // The good source should still be pumping.\n    const result = await reader.read();\n    expect(result.value).toBe('good');\n\n    reader.releaseLock();\n    await multi.close();\n  });\n\n  // ---------------------------------------------------------------------------\n  // Close semantics\n  // ---------------------------------------------------------------------------\n\n  it('should end the output stream with done:true when close is called', async () => {\n    const multi = new MultiInputStream<string>();\n    const reader = multi.stream.getReader();\n\n    multi.addInputStream(streamFrom(['data']));\n\n    const r1 = await reader.read();\n    expect(r1.value).toBe('data');\n\n    await multi.close();\n\n    const r2 = await reader.read();\n    expect(r2.done).toBe(true);\n    expect(r2.value).toBeUndefined();\n\n    reader.releaseLock();\n  });\n\n  it('should resolve pending reads as done when close is called', async () => {\n    const multi = new MultiInputStream<string>();\n    const reader = multi.stream.getReader();\n\n    // No inputs — read will be pending.\n    const readPromise = reader.read();\n\n    await delay(10);\n    await multi.close();\n\n    const result = await readPromise;\n    expect(result.done).toBe(true);\n    expect(result.value).toBeUndefined();\n\n    reader.releaseLock();\n  });\n\n  it('should be idempotent for multiple close calls', async () => {\n    const multi = new MultiInputStream<string>();\n\n    await multi.close();\n    await multi.close();\n\n    expect(multi.isClosed).toBe(true);\n  });\n\n  it('should throw when adding input after close', async () => {\n    const multi = new MultiInputStream<string>();\n    await multi.close();\n\n    expect(() => multi.addInputStream(streamFrom(['x']))).toThrow('MultiInputStream is closed');\n  });\n\n  // ---------------------------------------------------------------------------\n  // removeInputStream edge cases\n  // ---------------------------------------------------------------------------\n\n  it('should no-op when removing a non-existent input', async () => {\n    const multi = new MultiInputStream<string>();\n\n    // Should not throw.\n    await multi.removeInputStream('does-not-exist');\n\n    await multi.close();\n  });\n\n  it('should release the source reader lock so the source can be reused', async () => {\n    const multi = new MultiInputStream<string>();\n    const reader = multi.stream.getReader();\n\n    const source = new ReadableStream<string>({\n      async start(controller) {\n        controller.enqueue('chunk-0');\n        await delay(30);\n        controller.enqueue('chunk-1');\n        controller.close();\n      },\n    });\n\n    const id = multi.addInputStream(source);\n\n    const r1 = await reader.read();\n    expect(r1.value).toBe('chunk-0');\n\n    await multi.removeInputStream(id);\n\n    // The source's reader lock should be released — we can get a new reader.\n    const sourceReader = source.getReader();\n    const sr = await sourceReader.read();\n    expect(sr.value).toBe('chunk-1');\n    sourceReader.releaseLock();\n\n    reader.releaseLock();\n    await multi.close();\n  });\n\n  // ---------------------------------------------------------------------------\n  // Input count tracking\n  // ---------------------------------------------------------------------------\n\n  it('should track inputCount correctly through add / remove / natural end', async () => {\n    const multi = new MultiInputStream<string>();\n\n    expect(multi.inputCount).toBe(0);\n\n    const id1 = multi.addInputStream(streamFrom(['a']));\n    const id2 = multi.addInputStream(streamFrom(['b']));\n\n    expect(multi.inputCount).toBe(2);\n\n    await multi.removeInputStream(id1);\n    expect(multi.inputCount).toBeLessThanOrEqual(1);\n\n    // Let the remaining stream finish.\n    await delay(20);\n    expect(multi.inputCount).toBe(0);\n\n    await multi.removeInputStream(id2); // already gone, no-op\n    expect(multi.inputCount).toBe(0);\n\n    await multi.close();\n  });\n\n  // ---------------------------------------------------------------------------\n  // Concurrent reads and writes\n  // ---------------------------------------------------------------------------\n\n  it('should handle concurrent reads and slow writes', async () => {\n    const multi = new MultiInputStream<string>();\n    const reader = multi.stream.getReader();\n\n    const chunks = ['a', 'b', 'c', 'd', 'e'];\n    let idx = 0;\n\n    const source = new ReadableStream<string>({\n      start(controller) {\n        const writeNext = () => {\n          if (idx < chunks.length) {\n            controller.enqueue(chunks[idx++]);\n            setTimeout(writeNext, 5);\n          } else {\n            controller.close();\n          }\n        };\n        writeNext();\n      },\n    });\n\n    multi.addInputStream(source);\n\n    const results: string[] = [];\n    for (let i = 0; i < chunks.length; i++) {\n      const { value } = await reader.read();\n      results.push(value!);\n    }\n\n    expect(results).toEqual(chunks);\n\n    reader.releaseLock();\n    await multi.close();\n  });\n\n  // ---------------------------------------------------------------------------\n  // Backpressure\n  // ---------------------------------------------------------------------------\n\n  it('should handle backpressure with large data', async () => {\n    const multi = new MultiInputStream<string>();\n\n    const largeChunks = Array.from({ length: 1000 }, (_, i) => `chunk-${i}`);\n    multi.addInputStream(streamFrom(largeChunks));\n\n    const reader = multi.stream.getReader();\n    const results: string[] = [];\n\n    let result = await reader.read();\n    while (!result.done) {\n      results.push(result.value);\n      // Check if we've collected all expected values before reading again,\n      // to avoid hanging on the output which stays open after input ends.\n      if (results.length === largeChunks.length) break;\n      result = await reader.read();\n    }\n\n    expect(results).toEqual(largeChunks);\n\n    reader.releaseLock();\n    await multi.close();\n  });\n\n  // ---------------------------------------------------------------------------\n  // Multiple tee / concurrent consumers\n  // ---------------------------------------------------------------------------\n\n  it('should support tee on the output stream', async () => {\n    const multi = new MultiInputStream<number>();\n\n    const [s1, s2] = multi.stream.tee();\n    const r1 = s1.getReader();\n    const r2 = s2.getReader();\n\n    multi.addInputStream(streamFrom([10, 20]));\n\n    const [a1, a2] = await Promise.all([r1.read(), r2.read()]);\n    expect(a1.value).toBe(10);\n    expect(a2.value).toBe(10);\n\n    const [b1, b2] = await Promise.all([r1.read(), r2.read()]);\n    expect(b1.value).toBe(20);\n    expect(b2.value).toBe(20);\n\n    r1.releaseLock();\n    r2.releaseLock();\n    await multi.close();\n  });\n\n  // ---------------------------------------------------------------------------\n  // Return value of addInputStream\n  // ---------------------------------------------------------------------------\n\n  it('should return unique IDs from addInputStream', () => {\n    const multi = new MultiInputStream<string>();\n\n    const id1 = multi.addInputStream(streamFrom(['a']));\n    const id2 = multi.addInputStream(streamFrom(['b']));\n    const id3 = multi.addInputStream(streamFrom(['c']));\n\n    expect(id1).not.toBe(id2);\n    expect(id2).not.toBe(id3);\n    expect(id1).not.toBe(id3);\n  });\n\n  // ---------------------------------------------------------------------------\n  // close() while pumps are actively writing\n  // ---------------------------------------------------------------------------\n\n  it('should cleanly close while pumps are actively writing', async () => {\n    const multi = new MultiInputStream<string>();\n    const reader = multi.stream.getReader();\n\n    // A source that never stops on its own.\n    const infiniteSource = new ReadableStream<string>({\n      async start(controller) {\n        let i = 0;\n        while (true) {\n          try {\n            controller.enqueue(`tick-${i++}`);\n          } catch {\n            // controller.enqueue throws after stream is canceled\n            break;\n          }\n          await delay(5);\n        }\n      },\n    });\n\n    multi.addInputStream(infiniteSource);\n\n    // Read a couple of values.\n    const r1 = await reader.read();\n    expect(r1.done).toBe(false);\n\n    // Close while the infinite source is still pumping.\n    await multi.close();\n\n    const r2 = await reader.read();\n    expect(r2.done).toBe(true);\n\n    reader.releaseLock();\n  });\n});\n"],"mappings":"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","names":["result"]}