livekit-client 2.22.3 → 2.23.0

package/dist/ts4.2/room/data-channel/types.d.ts

@@ -1,12 +1,12 @@
-export declare enum DataChannelKind {
-    RELIABLE = 0,
-    LOSSY = 1,
-    DATA_TRACK_LOSSY = 2
-}
-export declare const reliableDataChannelWaterMarkLow: number;
-export declare const reliableDataChannelWaterMarkHigh: number;
-export declare const lossyDataChannelWaterMarkLow: number;
-export declare const lossyDataChannelWaterMarkHigh: number;
-export declare function dataChannelLowWaterMark(kind: DataChannelKind): number;
-export declare function dataChannelHighWaterMark(kind: DataChannelKind): number;
-//# sourceMappingURL=types.d.ts.map
+export declare enum DataChannelKind {
+    RELIABLE = 0,
+    LOSSY = 1,
+    DATA_TRACK_LOSSY = 2
+}
+export declare const reliableDataChannelWaterMarkLow: number;
+export declare const reliableDataChannelWaterMarkHigh: number;
+export declare const lossyDataChannelWaterMarkLow: number;
+export declare const lossyDataChannelWaterMarkHigh: number;
+export declare function dataChannelLowWaterMark(kind: DataChannelKind): number;
+export declare function dataChannelHighWaterMark(kind: DataChannelKind): number;
+//# sourceMappingURL=types.d.ts.map

package/dist/ts4.2/room/data-stream/compression.d.ts

@@ -1,49 +1,49 @@
-/*
-* Compression helpers for data streams. The buffered deflate-raw variant ({@link deflateRawCompress})
-* is for the inline (single-packet) case where the payload is small and bounded;
-* {@link deflateRawTransform} / {@link inflateRawTransform} serve the chunked (multi-packet)
-* `sendText`/`sendBytes`/`sendFile` paths, streaming the bytes through without buffering the whole
-* payload.
-*
-* These operate on bytes (not strings) so a single set of helpers serves both text and byte streams;
-* the `TextEncoder`/`TextDecoder` boundary lives at the manager/reader edges.
-*
-* Both streaming variants are exposed as `ReadableWritablePair`s so they drop straight into a
-* `pipeThrough` chain. Each needs one localized cast to bridge a DOM lib-type mismatch: the platform
-* `CompressionStream`/`DecompressionStream` type their `writable` as `WritableStream<BufferSource>`
-* (a wider element type than `Uint8Array`), and `WritableStream<W>` is covariant in `W`, so neither
-* is structurally a `ReadableWritablePair<Uint8Array, Uint8Array>` without help.
-*
-* @internal
-*/
-import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
-/**
- * A `deflate-raw` compression transform (inverse of {@link inflateRawTransform}): pipe a byte stream
- * through it to get the compressed bytes without buffering the whole payload. Used for the chunked
- * `sendText`/`sendBytes`/`sendFile` paths, where the full payload is known up front but is streamed
- * (e.g. from `file.stream()`) rather than held in memory.
- */
-export declare function deflateRawTransform(): ReadableWritablePair<NonSharedUint8Array, NonSharedUint8Array>;
-/**
- * A `deflate-raw` decompression transform (inverse of {@link deflateRawTransform}): pipe a
- * stream of compressed bytes through it to get the decompressed bytes. Inflate emits output greedily,
- * so as long as the sender flushed at write boundaries each write's content is produced as soon as
- * its compressed bytes arrive.
- */
-export declare function inflateRawTransform(): ReadableWritablePair<NonSharedUint8Array, NonSharedUint8Array>;
-/** deflate-raw compresses a byte array in full. Use for inline payloads; prefer the streaming
- * path for the chunked case. */
-export declare function deflateRawCompress(data: NonSharedUint8Array): Promise<NonSharedUint8Array>;
-/**
- * Decompresses a raw-deflate byte array in full (inverse of {@link deflateRawCompress}).
- * `maxByteLength` bounds the decompressed output (decompression-bomb guard); exceeding it rejects
- * with a `PayloadTooLarge` error.
- */
-export declare function deflateRawDecompress(data: NonSharedUint8Array, maxByteLength?: number): Promise<NonSharedUint8Array>;
-/**
- * Drains a byte stream, concatenating all of its chunks into a single array. When
- * `maxByteLength` is given, drops the stream and throws `PayloadTooLarge` as soon as the
- * accumulated output exceeds it.
- */
-export declare function collect(stream: ReadableStream<NonSharedUint8Array>, maxByteLength?: number): Promise<NonSharedUint8Array>;
-//# sourceMappingURL=compression.d.ts.map
+/*
+* Compression helpers for data streams. The buffered deflate-raw variant ({@link deflateRawCompress})
+* is for the inline (single-packet) case where the payload is small and bounded;
+* {@link deflateRawTransform} / {@link inflateRawTransform} serve the chunked (multi-packet)
+* `sendText`/`sendBytes`/`sendFile` paths, streaming the bytes through without buffering the whole
+* payload.
+*
+* These operate on bytes (not strings) so a single set of helpers serves both text and byte streams;
+* the `TextEncoder`/`TextDecoder` boundary lives at the manager/reader edges.
+*
+* Both streaming variants are exposed as `ReadableWritablePair`s so they drop straight into a
+* `pipeThrough` chain. Each needs one localized cast to bridge a DOM lib-type mismatch: the platform
+* `CompressionStream`/`DecompressionStream` type their `writable` as `WritableStream<BufferSource>`
+* (a wider element type than `Uint8Array`), and `WritableStream<W>` is covariant in `W`, so neither
+* is structurally a `ReadableWritablePair<Uint8Array, Uint8Array>` without help.
+*
+* @internal
+*/
+import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
+/**
+ * A `deflate-raw` compression transform (inverse of {@link inflateRawTransform}): pipe a byte stream
+ * through it to get the compressed bytes without buffering the whole payload. Used for the chunked
+ * `sendText`/`sendBytes`/`sendFile` paths, where the full payload is known up front but is streamed
+ * (e.g. from `file.stream()`) rather than held in memory.
+ */
+export declare function deflateRawTransform(): ReadableWritablePair<NonSharedUint8Array, NonSharedUint8Array>;
+/**
+ * A `deflate-raw` decompression transform (inverse of {@link deflateRawTransform}): pipe a
+ * stream of compressed bytes through it to get the decompressed bytes. Inflate emits output greedily,
+ * so as long as the sender flushed at write boundaries each write's content is produced as soon as
+ * its compressed bytes arrive.
+ */
+export declare function inflateRawTransform(): ReadableWritablePair<NonSharedUint8Array, NonSharedUint8Array>;
+/** deflate-raw compresses a byte array in full. Use for inline payloads; prefer the streaming
+ * path for the chunked case. */
+export declare function deflateRawCompress(data: NonSharedUint8Array): Promise<NonSharedUint8Array>;
+/**
+ * Decompresses a raw-deflate byte array in full (inverse of {@link deflateRawCompress}).
+ * `maxByteLength` bounds the decompressed output (decompression-bomb guard); exceeding it rejects
+ * with a `PayloadTooLarge` error.
+ */
+export declare function deflateRawDecompress(data: NonSharedUint8Array, maxByteLength?: number): Promise<NonSharedUint8Array>;
+/**
+ * Drains a byte stream, concatenating all of its chunks into a single array. When
+ * `maxByteLength` is given, drops the stream and throws `PayloadTooLarge` as soon as the
+ * accumulated output exceeds it.
+ */
+export declare function collect(stream: ReadableStream<NonSharedUint8Array>, maxByteLength?: number): Promise<NonSharedUint8Array>;
+//# sourceMappingURL=compression.d.ts.map

package/dist/ts4.2/room/data-stream/constants.d.ts

@@ -1,18 +1,18 @@
-/**
- * Maximum size of a single data-stream chunk in bytes, and the budget used to decide whether a
- * payload can be sent inline as a single header packet. Kept below the ~16k data-channel MTU to
- * leave headroom for protocol framing and E2EE overhead.
- *
- * @internal
- */
-export declare const STREAM_CHUNK_SIZE_BYTES = 15000;
-/**
- * Default cap on the number of decompressed bytes a single incoming compressed data stream may
- * produce (5 GB). A tiny compressed payload can inflate to an arbitrarily large output
- * (decompression bomb), so the decompressor's output is bounded rather than trusting the wire
- * size; streams exceeding the cap error with `PayloadTooLarge`.
- *
- * @internal
- */
-export declare const DEFAULT_MAX_PAYLOAD_BYTE_LENGTH = 5000000000;
-//# sourceMappingURL=constants.d.ts.map
+/**
+ * Maximum size of a single data-stream chunk in bytes, and the budget used to decide whether a
+ * payload can be sent inline as a single header packet. Kept below the ~16k data-channel MTU to
+ * leave headroom for protocol framing and E2EE overhead.
+ *
+ * @internal
+ */
+export declare const STREAM_CHUNK_SIZE_BYTES = 15000;
+/**
+ * Default cap on the number of decompressed bytes a single incoming compressed data stream may
+ * produce (5 GB). A tiny compressed payload can inflate to an arbitrarily large output
+ * (decompression bomb), so the decompressor's output is bounded rather than trusting the wire
+ * size; streams exceeding the cap error with `PayloadTooLarge`.
+ *
+ * @internal
+ */
+export declare const DEFAULT_MAX_PAYLOAD_BYTE_LENGTH = 5000000000;
+//# sourceMappingURL=constants.d.ts.map

package/dist/ts4.2/room/data-stream/incoming/IncomingDataStreamManager.d.ts

@@ -1,29 +1,29 @@
-import type { DataPacket } from '@livekit/protocol';
-import { Encryption_Type } from '@livekit/protocol';
-import type { ByteStreamHandler, TextStreamHandler } from './StreamReader';
-export default class IncomingDataStreamManager {
-    private log;
-    /** Max number of decompressed bytes an incoming compressed stream may produce before it is
-     * errored (decompression-bomb guard). */
-    private maxPayloadByteLength;
-    constructor(maxPayloadByteLength?: number);
-    private byteStreamControllers;
-    private textStreamControllers;
-    private byteStreamHandlers;
-    private textStreamHandlers;
-    private isConnected;
-    private bufferedPackets;
-    setConnected(connected: boolean): void;
-    private flushBufferedPackets;
-    registerTextStreamHandler(topic: string, callback: TextStreamHandler): void;
-    unregisterTextStreamHandler(topic: string): void;
-    registerByteStreamHandler(topic: string, callback: ByteStreamHandler): void;
-    unregisterByteStreamHandler(topic: string): void;
-    clearControllers(): void;
-    validateParticipantHasNoActiveDataStreams(participantIdentity: string): void;
-    handleDataStreamPacket(packet: DataPacket, encryptionType: Encryption_Type): void;
-    private handleStreamHeader;
-    private handleStreamChunk;
-    private handleStreamTrailer;
-}
-//# sourceMappingURL=IncomingDataStreamManager.d.ts.map
+import type { DataPacket } from '@livekit/protocol';
+import { Encryption_Type } from '@livekit/protocol';
+import type { ByteStreamHandler, TextStreamHandler } from './StreamReader';
+export default class IncomingDataStreamManager {
+    private log;
+    /** Max number of decompressed bytes an incoming compressed stream may produce before it is
+     * errored (decompression-bomb guard). */
+    private maxPayloadByteLength;
+    constructor(maxPayloadByteLength?: number);
+    private byteStreamControllers;
+    private textStreamControllers;
+    private byteStreamHandlers;
+    private textStreamHandlers;
+    private isConnected;
+    private bufferedPackets;
+    setConnected(connected: boolean): void;
+    private flushBufferedPackets;
+    registerTextStreamHandler(topic: string, callback: TextStreamHandler): void;
+    unregisterTextStreamHandler(topic: string): void;
+    registerByteStreamHandler(topic: string, callback: ByteStreamHandler): void;
+    unregisterByteStreamHandler(topic: string): void;
+    clearControllers(): void;
+    validateParticipantHasNoActiveDataStreams(participantIdentity: string): void;
+    handleDataStreamPacket(packet: DataPacket, encryptionType: Encryption_Type): void;
+    private handleStreamHeader;
+    private handleStreamChunk;
+    private handleStreamTrailer;
+}
+//# sourceMappingURL=IncomingDataStreamManager.d.ts.map

package/dist/ts4.2/room/data-stream/incoming/StreamReader.d.ts

@@ -1,80 +1,80 @@
-import type { DataStream_Chunk } from '@livekit/protocol';
-import type { BaseStreamInfo, ByteStreamInfo, TextStreamInfo } from '../../types';
-export type BaseStreamReaderReadAllOpts = {
-    /** An AbortSignal can be used to terminate reads early. */
-    signal?: AbortSignal;
-};
-declare abstract class BaseStreamReader<T extends BaseStreamInfo> {
-    protected reader: ReadableStream<DataStream_Chunk>;
-    protected totalByteSize?: number;
-    protected _info: T;
-    protected bytesReceived: number;
-    get info(): T;
-    /** @internal */
-    protected validateBytesReceived(doneReceiving?: boolean): void;
-    constructor(info: T, stream: ReadableStream<DataStream_Chunk>, totalByteSize?: number);
-    /**
-     * Counts a chunk's bytes against `totalByteSize` and reports progress. Chunk ordering and
-     * de-duplication happen upstream in the manager's `ensureOrderedChunks`, so every chunk reaching
-     * here is new and in order.
-     */
-    protected handleChunkReceived(chunk: DataStream_Chunk): void;
-    /**
-     * @param progress - progress of the stream between 0 and 1. Undefined for streams of unknown size
-     */
-    onProgress?: (progress: number | undefined) => void;
-    abstract readAll(opts?: BaseStreamReaderReadAllOpts): Promise<string | Array<Uint8Array>>;
-}
-export declare class ByteStreamReader extends BaseStreamReader<ByteStreamInfo> {
-    signal?: AbortSignal;
-    [Symbol.asyncIterator](): {
-        next: () => Promise<IteratorResult<Uint8Array>>;
-        return(): Promise<IteratorResult<Uint8Array>>;
-    };
-    /**
-     * Injects an AbortSignal, which if aborted, will terminate the currently active
-     * stream iteration operation.
-     *
-     * Note that when using AbortSignal.timeout(...), the timeout applies across
-     * the whole iteration operation, not just one individual chunk read.
-     */
-    withAbortSignal(signal: AbortSignal): this;
-    readAll(opts?: BaseStreamReaderReadAllOpts): Promise<Array<Uint8Array>>;
-}
-/**
- * A class to read chunks from a ReadableStream and decode them as UTF-8 text.
- *
- * NOTE: chunk-level `version` (resending a chunk at an already-received `chunkIndex` to supersede
- * it) is not supported. The reader used to rebuild the whole string from a per-index chunk map and
- * yield it as `TextStreamChunk.collected`, which made superseding work; 5d4a6346 (#1410, text auto
- * chunking) changed the iterator to yield each chunk's text as it arrives, and a streaming reader
- * cannot retract text it has already handed to the consumer. No sender emits a versioned chunk.
- */
-export declare class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
-    signal?: AbortSignal;
-    /**
-     * Async iterator implementation to allow usage of `for await...of` syntax.
-     * Yields each chunk's decoded text as it arrives - a delta, not the string accumulated so far.
-     */
-    [Symbol.asyncIterator](): {
-        next: () => Promise<IteratorResult<string>>;
-        return(): Promise<IteratorResult<string>>;
-    };
-    /**
-     * Injects an AbortSignal, which if aborted, will terminate the currently active
-     * stream iteration operation.
-     *
-     * Note that when using AbortSignal.timeout(...), the timeout applies across
-     * the whole iteration operation, not just one individual chunk read.
-     */
-    withAbortSignal(signal: AbortSignal): this;
-    readAll(opts?: BaseStreamReaderReadAllOpts): Promise<string>;
-}
-export type ByteStreamHandler = (reader: ByteStreamReader, participantInfo: {
-    identity: string;
-}) => void;
-export type TextStreamHandler = (reader: TextStreamReader, participantInfo: {
-    identity: string;
-}) => void;
-export {};
-//# sourceMappingURL=StreamReader.d.ts.map
+import type { DataStream_Chunk } from '@livekit/protocol';
+import type { BaseStreamInfo, ByteStreamInfo, TextStreamInfo } from '../../types';
+export type BaseStreamReaderReadAllOpts = {
+    /** An AbortSignal can be used to terminate reads early. */
+    signal?: AbortSignal;
+};
+declare abstract class BaseStreamReader<T extends BaseStreamInfo> {
+    protected reader: ReadableStream<DataStream_Chunk>;
+    protected totalByteSize?: number;
+    protected _info: T;
+    protected bytesReceived: number;
+    get info(): T;
+    /** @internal */
+    protected validateBytesReceived(doneReceiving?: boolean): void;
+    constructor(info: T, stream: ReadableStream<DataStream_Chunk>, totalByteSize?: number);
+    /**
+     * Counts a chunk's bytes against `totalByteSize` and reports progress. Chunk ordering and
+     * de-duplication happen upstream in the manager's `ensureOrderedChunks`, so every chunk reaching
+     * here is new and in order.
+     */
+    protected handleChunkReceived(chunk: DataStream_Chunk): void;
+    /**
+     * @param progress - progress of the stream between 0 and 1. Undefined for streams of unknown size
+     */
+    onProgress?: (progress: number | undefined) => void;
+    abstract readAll(opts?: BaseStreamReaderReadAllOpts): Promise<string | Array<Uint8Array>>;
+}
+export declare class ByteStreamReader extends BaseStreamReader<ByteStreamInfo> {
+    signal?: AbortSignal;
+    [Symbol.asyncIterator](): {
+        next: () => Promise<IteratorResult<Uint8Array>>;
+        return(): Promise<IteratorResult<Uint8Array>>;
+    };
+    /**
+     * Injects an AbortSignal, which if aborted, will terminate the currently active
+     * stream iteration operation.
+     *
+     * Note that when using AbortSignal.timeout(...), the timeout applies across
+     * the whole iteration operation, not just one individual chunk read.
+     */
+    withAbortSignal(signal: AbortSignal): this;
+    readAll(opts?: BaseStreamReaderReadAllOpts): Promise<Array<Uint8Array>>;
+}
+/**
+ * A class to read chunks from a ReadableStream and decode them as UTF-8 text.
+ *
+ * NOTE: chunk-level `version` (resending a chunk at an already-received `chunkIndex` to supersede
+ * it) is not supported. The reader used to rebuild the whole string from a per-index chunk map and
+ * yield it as `TextStreamChunk.collected`, which made superseding work; 5d4a6346 (#1410, text auto
+ * chunking) changed the iterator to yield each chunk's text as it arrives, and a streaming reader
+ * cannot retract text it has already handed to the consumer. No sender emits a versioned chunk.
+ */
+export declare class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
+    signal?: AbortSignal;
+    /**
+     * Async iterator implementation to allow usage of `for await...of` syntax.
+     * Yields each chunk's decoded text as it arrives - a delta, not the string accumulated so far.
+     */
+    [Symbol.asyncIterator](): {
+        next: () => Promise<IteratorResult<string>>;
+        return(): Promise<IteratorResult<string>>;
+    };
+    /**
+     * Injects an AbortSignal, which if aborted, will terminate the currently active
+     * stream iteration operation.
+     *
+     * Note that when using AbortSignal.timeout(...), the timeout applies across
+     * the whole iteration operation, not just one individual chunk read.
+     */
+    withAbortSignal(signal: AbortSignal): this;
+    readAll(opts?: BaseStreamReaderReadAllOpts): Promise<string>;
+}
+export type ByteStreamHandler = (reader: ByteStreamReader, participantInfo: {
+    identity: string;
+}) => void;
+export type TextStreamHandler = (reader: TextStreamReader, participantInfo: {
+    identity: string;
+}) => void;
+export {};
+//# sourceMappingURL=StreamReader.d.ts.map

package/dist/ts4.2/room/data-stream/outgoing/OutgoingDataStreamManager.d.ts

@@ -1,73 +1,73 @@
-import { ClientInfo_Capability } from '@livekit/protocol';
-import type { StructuredLogger } from '../../../logger';
-import type RTCEngine from '../../RTCEngine';
-import type { ByteStreamInfo, SendBytesOptions, SendFileOptions, SendTextOptions, StreamBytesOptions, StreamTextOptions, TextStreamInfo } from '../../types';
-import { ByteStreamWriter, TextStreamWriter } from './StreamWriter';
-/**
- * Manages sending custom user data via data channels.
- * @internal
- */
-export default class OutgoingDataStreamManager {
-    protected engine: RTCEngine;
-    protected log: StructuredLogger;
-    /** Returns the advertised client protocol of a remote participant, used to decide whether a
-     * recipient can receive single-packet (inline) data streams. */
-    protected getRemoteParticipantClientProtocol: (identity: string) => number;
-    /** Returns the client capabilities a remote participant advertises, used to decide whether a
-     * recipient can decompress a deflate-raw compressed stream. */
-    protected getRemoteParticipantCapabilities: (identity: string) => Array<ClientInfo_Capability>;
-    /** Returns the identities of every remote participant currently in the room, used to decide
-     * whether a broadcast (no explicit destinations) can be sent inline. */
-    protected getAllRemoteParticipantIdentities: () => Array<string>;
-    constructor(engine: RTCEngine, log: StructuredLogger, getRemoteParticipantClientProtocol: (identity: string) => number, getRemoteParticipantCapabilities: (identity: string) => Array<ClientInfo_Capability>, getAllRemoteParticipantIdentities: () => Array<string>);
-    setupEngine(engine: RTCEngine): void;
-    /** {@inheritDoc LocalParticipant.sendText} */
-    sendText(text: string, options?: SendTextOptions): Promise<TextStreamInfo>;
-    /**
-     * Sends a complete in-memory byte payload. Mirrors {@link sendText}'s semantics: when every
-     * recipient supports data streams v2 the payload rides inline in a single header packet
-     * (optionally deflate-raw compressed), otherwise it is sent as a (optionally compressed)
-     * chunked byte stream. Unlike {@link sendFile}, the whole payload is already in memory, so the
-     * inline single-packet fast path applies.
-     */
-    sendBytes(bytes: Uint8Array, options?: SendBytesOptions): Promise<ByteStreamInfo>;
-    /**
-     * Returns true only if every recipient is known to support data streams v2 (single-packet inline
-     * streams and compression). For a targeted send this checks the named destination identities; for
-     * a broadcast (no explicit destinations) it checks every remote participant currently in the room.
-     * An empty room (nobody to receive) is considered eligible.
-     */
-    private allRecipientsSupportV2;
-    /**
-     * Returns true only if every recipient advertises the deflate-raw compression capability (so it
-     * can decompress a compressed stream). Resolved the same way as {@link allRecipientsSupportV2}:
-     * named destinations, or every remote participant for a broadcast; an empty room is eligible.
-     */
-    private allRecipientsSupportCompression;
-    /**
-     * Shared chunked-stream send for `sendText`/`sendFile`: sends the prebuilt header packet, then
-     * forwards `source` (optionally deflate-raw compressed) as `streamChunk` packets re-chunked to
-     * the MTU budget with contiguous indices, then sends the trailer. The source is consumed
-     * incrementally, so a `file.stream()` is never buffered in full. The platform compressor can't
-     * flush mid-stream, so compression is only used when the whole payload is available as a stream
-     * up front (not for incremental writers like `streamText`/`streamBytes`).
-     */
-    private sendChunkedByteStream;
-    /**
-     * @internal
-     */
-    streamText(options?: StreamTextOptions): Promise<TextStreamWriter>;
-    sendFile(file: File, options?: SendFileOptions): Promise<{
-        id: string;
-    }>;
-    /**
-     * Streams a file as a chunked byte stream, compressed (deflate-raw) when the runtime supports it
-     * and every recipient is on data streams v2. The file is piped `file.stream()` →
-     * (`CompressionStream`) → chunk packets via {@link sendChunkedByteStream}, so it is never fully
-     * buffered in memory — unlike {@link sendBytes}, there is no inline single-packet fast path for
-     * files (the compressed size can't be known up front without buffering the whole file).
-     */
-    private _sendFile;
-    streamBytes(options?: StreamBytesOptions): Promise<ByteStreamWriter>;
-}
-//# sourceMappingURL=OutgoingDataStreamManager.d.ts.map
+import { ClientInfo_Capability } from '@livekit/protocol';
+import type { StructuredLogger } from '../../../logger';
+import type RTCEngine from '../../RTCEngine';
+import type { ByteStreamInfo, SendBytesOptions, SendFileOptions, SendTextOptions, StreamBytesOptions, StreamTextOptions, TextStreamInfo } from '../../types';
+import { ByteStreamWriter, TextStreamWriter } from './StreamWriter';
+/**
+ * Manages sending custom user data via data channels.
+ * @internal
+ */
+export default class OutgoingDataStreamManager {
+    protected engine: RTCEngine;
+    protected log: StructuredLogger;
+    /** Returns the advertised client protocol of a remote participant, used to decide whether a
+     * recipient can receive single-packet (inline) data streams. */
+    protected getRemoteParticipantClientProtocol: (identity: string) => number;
+    /** Returns the client capabilities a remote participant advertises, used to decide whether a
+     * recipient can decompress a deflate-raw compressed stream. */
+    protected getRemoteParticipantCapabilities: (identity: string) => Array<ClientInfo_Capability>;
+    /** Returns the identities of every remote participant currently in the room, used to decide
+     * whether a broadcast (no explicit destinations) can be sent inline. */
+    protected getAllRemoteParticipantIdentities: () => Array<string>;
+    constructor(engine: RTCEngine, log: StructuredLogger, getRemoteParticipantClientProtocol: (identity: string) => number, getRemoteParticipantCapabilities: (identity: string) => Array<ClientInfo_Capability>, getAllRemoteParticipantIdentities: () => Array<string>);
+    setupEngine(engine: RTCEngine): void;
+    /** {@inheritDoc LocalParticipant.sendText} */
+    sendText(text: string, options?: SendTextOptions): Promise<TextStreamInfo>;
+    /**
+     * Sends a complete in-memory byte payload. Mirrors {@link sendText}'s semantics: when every
+     * recipient supports data streams v2 the payload rides inline in a single header packet
+     * (optionally deflate-raw compressed), otherwise it is sent as a (optionally compressed)
+     * chunked byte stream. Unlike {@link sendFile}, the whole payload is already in memory, so the
+     * inline single-packet fast path applies.
+     */
+    sendBytes(bytes: Uint8Array, options?: SendBytesOptions): Promise<ByteStreamInfo>;
+    /**
+     * Returns true only if every recipient is known to support data streams v2 (single-packet inline
+     * streams and compression). For a targeted send this checks the named destination identities; for
+     * a broadcast (no explicit destinations) it checks every remote participant currently in the room.
+     * An empty room (nobody to receive) is considered eligible.
+     */
+    private allRecipientsSupportV2;
+    /**
+     * Returns true only if every recipient advertises the deflate-raw compression capability (so it
+     * can decompress a compressed stream). Resolved the same way as {@link allRecipientsSupportV2}:
+     * named destinations, or every remote participant for a broadcast; an empty room is eligible.
+     */
+    private allRecipientsSupportCompression;
+    /**
+     * Shared chunked-stream send for `sendText`/`sendFile`: sends the prebuilt header packet, then
+     * forwards `source` (optionally deflate-raw compressed) as `streamChunk` packets re-chunked to
+     * the MTU budget with contiguous indices, then sends the trailer. The source is consumed
+     * incrementally, so a `file.stream()` is never buffered in full. The platform compressor can't
+     * flush mid-stream, so compression is only used when the whole payload is available as a stream
+     * up front (not for incremental writers like `streamText`/`streamBytes`).
+     */
+    private sendChunkedByteStream;
+    /**
+     * @internal
+     */
+    streamText(options?: StreamTextOptions): Promise<TextStreamWriter>;
+    sendFile(file: File, options?: SendFileOptions): Promise<{
+        id: string;
+    }>;
+    /**
+     * Streams a file as a chunked byte stream, compressed (deflate-raw) when the runtime supports it
+     * and every recipient is on data streams v2. The file is piped `file.stream()` →
+     * (`CompressionStream`) → chunk packets via {@link sendChunkedByteStream}, so it is never fully
+     * buffered in memory — unlike {@link sendBytes}, there is no inline single-packet fast path for
+     * files (the compressed size can't be known up front without buffering the whole file).
+     */
+    private _sendFile;
+    streamBytes(options?: StreamBytesOptions): Promise<ByteStreamWriter>;
+}
+//# sourceMappingURL=OutgoingDataStreamManager.d.ts.map

package/dist/ts4.2/room/data-stream/outgoing/StreamWriter.d.ts

@@ -1,16 +1,16 @@
-import type { BaseStreamInfo, ByteStreamInfo, TextStreamInfo } from '../../types';
-declare class BaseStreamWriter<T, InfoType extends BaseStreamInfo> {
-    protected writableStream: WritableStream<T>;
-    protected defaultWriter: WritableStreamDefaultWriter<T>;
-    protected onClose?: () => void;
-    readonly info: InfoType;
-    constructor(writableStream: WritableStream<T>, info: InfoType, onClose?: () => void);
-    write(chunk: T): Promise<void>;
-    close(): Promise<void>;
-}
-export declare class TextStreamWriter extends BaseStreamWriter<string, TextStreamInfo> {
-}
-export declare class ByteStreamWriter extends BaseStreamWriter<Uint8Array, ByteStreamInfo> {
-}
-export {};
-//# sourceMappingURL=StreamWriter.d.ts.map
+import type { BaseStreamInfo, ByteStreamInfo, TextStreamInfo } from '../../types';
+declare class BaseStreamWriter<T, InfoType extends BaseStreamInfo> {
+    protected writableStream: WritableStream<T>;
+    protected defaultWriter: WritableStreamDefaultWriter<T>;
+    protected onClose?: () => void;
+    readonly info: InfoType;
+    constructor(writableStream: WritableStream<T>, info: InfoType, onClose?: () => void);
+    write(chunk: T): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class TextStreamWriter extends BaseStreamWriter<string, TextStreamInfo> {
+}
+export declare class ByteStreamWriter extends BaseStreamWriter<Uint8Array, ByteStreamInfo> {
+}
+export {};
+//# sourceMappingURL=StreamWriter.d.ts.map

package/dist/ts4.2/room/data-stream/outgoing/header-utils.d.ts

@@ -1,18 +1,18 @@
-import { DataPacket, DataStream_CompressionType, DataStream_Header } from '@livekit/protocol';
-import type { ByteStreamInfo, StreamTextOptions, TextStreamInfo } from '../../types';
-/** The data-streams-v2 wire signals carried directly on the header: the compression flag and the
- * inline single-packet payload. Both used to live in reserved header attributes; they are now
- * first-class protobuf fields on `DataStream.Header`. */
-export interface StreamHeaderV2Fields {
-    /** Compression applied to the inline/chunked payload. Defaults to `NONE` when omitted. */
-    compression?: DataStream_CompressionType;
-    /** The full payload smuggled into the header for single-packet (inline) sends. */
-    inlineContent?: Uint8Array;
-}
-/** Builds the `DataStream_Header` for a text stream from its info and stream options. */
-export declare function buildTextStreamHeader(info: TextStreamInfo, options?: Pick<StreamTextOptions, 'version' | 'replyToStreamId' | 'type'>, v2?: StreamHeaderV2Fields): DataStream_Header;
-/** Builds the `DataStream_Header` for a byte stream from its info. */
-export declare function buildByteStreamHeader(info: ByteStreamInfo, v2?: StreamHeaderV2Fields): DataStream_Header;
-/** Wraps a `DataStream_Header` in a `DataPacket` ready to be sent over a data channel. */
-export declare function createStreamHeaderPacket(header: DataStream_Header, destinationIdentities?: Array<string>): DataPacket;
-//# sourceMappingURL=header-utils.d.ts.map
+import { DataPacket, DataStream_CompressionType, DataStream_Header } from '@livekit/protocol';
+import type { ByteStreamInfo, StreamTextOptions, TextStreamInfo } from '../../types';
+/** The data-streams-v2 wire signals carried directly on the header: the compression flag and the
+ * inline single-packet payload. Both used to live in reserved header attributes; they are now
+ * first-class protobuf fields on `DataStream.Header`. */
+export interface StreamHeaderV2Fields {
+    /** Compression applied to the inline/chunked payload. Defaults to `NONE` when omitted. */
+    compression?: DataStream_CompressionType;
+    /** The full payload smuggled into the header for single-packet (inline) sends. */
+    inlineContent?: Uint8Array;
+}
+/** Builds the `DataStream_Header` for a text stream from its info and stream options. */
+export declare function buildTextStreamHeader(info: TextStreamInfo, options?: Pick<StreamTextOptions, 'version' | 'replyToStreamId' | 'type'>, v2?: StreamHeaderV2Fields): DataStream_Header;
+/** Builds the `DataStream_Header` for a byte stream from its info. */
+export declare function buildByteStreamHeader(info: ByteStreamInfo, v2?: StreamHeaderV2Fields): DataStream_Header;
+/** Wraps a `DataStream_Header` in a `DataPacket` ready to be sent over a data channel. */
+export declare function createStreamHeaderPacket(header: DataStream_Header, destinationIdentities?: Array<string>): DataPacket;
+//# sourceMappingURL=header-utils.d.ts.map