diff --git a/packages/webrtc/src/rtc-chunking.ts b/packages/webrtc/src/rtc-chunking.ts new file mode 100644 index 0000000..4d1d83f --- /dev/null +++ b/packages/webrtc/src/rtc-chunking.ts @@ -0,0 +1,138 @@ +/** + * WebRTC transport-level chunking (webrtc-implementation-plan workaround). + * + * werift's SCTP `send()` blocks until a whole message is handed to the wire + * through the slow-start congestion window, which stalls for large messages + * when the peer is Chromium. To keep every DataChannel message small, large + * Noise ciphertext frames are split here — *below* the DataChannel, *above* + * Noise — and transparently reassembled on the other side. The Remote Protocol + * and Noise semantics are untouched; this layer only changes how ciphertext + * bytes are framed over the DataChannel. + * + * Frame layout (only when the payload exceeds the chunk size): + * + * [0..4) magic "RTCH" + * [4..8) messageId uint32 + * [8..10) index uint16 + * [10..12) total uint16 + * [12..) payload up to RTC_CHUNK_PAYLOAD_BYTES + */ + +export const RTC_CHUNK_MAGIC = new Uint8Array([0x52, 0x54, 0x43, 0x48]) // "RTCH" +export const RTC_CHUNK_HEADER_BYTES = 12 +export const RTC_CHUNK_PAYLOAD_BYTES = 8 * 1024 +export const RTC_CHUNK_MAX_MESSAGE_BYTES = 4 * 1024 * 1024 +const RTC_CHUNK_MAX_TOTAL = Math.ceil(RTC_CHUNK_MAX_MESSAGE_BYTES / RTC_CHUNK_PAYLOAD_BYTES) +const MAX_IN_FLIGHT_MESSAGES = 8 +const MAX_ASSEMBLY_AGE_MS = 30_000 + +interface Assembly { + messageId: number + total: number + receivedBytes: number + chunks: Uint8Array[] + updatedAt: number +} + +export class RtcChunkCodec { + private nextMessageId = 1 + private readonly assemblies = new Map() + + encode(data: Uint8Array): Uint8Array[] { + if (data.byteLength <= RTC_CHUNK_PAYLOAD_BYTES) return [data] + if (data.byteLength > RTC_CHUNK_MAX_MESSAGE_BYTES) { + throw new Error('WebRTC transport message exceeds the reassembly limit.') + } + const messageId = this.nextMessageId + this.nextMessageId = messageId === 0xffff_ffff ? 1 : messageId + 1 + const total = Math.ceil(data.byteLength / RTC_CHUNK_PAYLOAD_BYTES) + const frames: Uint8Array[] = [] + for (let index = 0; index < total; index += 1) { + const start = index * RTC_CHUNK_PAYLOAD_BYTES + const chunk = data.subarray(start, Math.min(data.byteLength, start + RTC_CHUNK_PAYLOAD_BYTES)) + const frame = new Uint8Array(RTC_CHUNK_HEADER_BYTES + chunk.byteLength) + frame.set(RTC_CHUNK_MAGIC) + const view = new DataView(frame.buffer) + view.setUint32(4, messageId) + view.setUint16(8, index) + view.setUint16(10, total) + frame.set(chunk, RTC_CHUNK_HEADER_BYTES) + frames.push(frame) + } + return frames + } + + decode(frame: Uint8Array): Uint8Array | undefined { + if (!isChunk(frame)) { + if (frame.byteLength > RTC_CHUNK_MAX_MESSAGE_BYTES) { + throw new Error('WebRTC transport message exceeds the reassembly limit.') + } + return frame + } + if (frame.byteLength < RTC_CHUNK_HEADER_BYTES) throw new Error('WebRTC transport chunk header is invalid.') + const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength) + const messageId = view.getUint32(4) + const index = view.getUint16(8) + const total = view.getUint16(10) + if (messageId === 0 || total < 2 || total > RTC_CHUNK_MAX_TOTAL || index >= total) { + throw new Error('WebRTC transport chunk metadata is invalid.') + } + const chunk = frame.subarray(RTC_CHUNK_HEADER_BYTES) + if (chunk.byteLength > RTC_CHUNK_PAYLOAD_BYTES + || (index < total - 1 && chunk.byteLength !== RTC_CHUNK_PAYLOAD_BYTES) + || (index === total - 1 && chunk.byteLength === 0)) { + throw new Error('WebRTC transport chunk length is invalid.') + } + + this.pruneStale() + let assembly = this.assemblies.get(messageId) + if (assembly === undefined) { + if (index !== 0 || this.assemblies.size >= MAX_IN_FLIGHT_MESSAGES) { + throw new Error('WebRTC transport chunk sequence is invalid.') + } + assembly = { messageId, total, receivedBytes: 0, chunks: [], updatedAt: Date.now() } + this.assemblies.set(messageId, assembly) + } + if (assembly.total !== total || index !== assembly.chunks.length) { + this.assemblies.delete(messageId) + throw new Error('WebRTC transport chunk sequence is invalid.') + } + const receivedBytes = assembly.receivedBytes + chunk.byteLength + if (receivedBytes > RTC_CHUNK_MAX_MESSAGE_BYTES) { + this.assemblies.delete(messageId) + throw new Error('WebRTC transport message exceeds the reassembly limit.') + } + assembly.chunks.push(Uint8Array.from(chunk)) + assembly.receivedBytes = receivedBytes + assembly.updatedAt = Date.now() + if (assembly.chunks.length < total) return undefined + this.assemblies.delete(messageId) + const message = new Uint8Array(assembly.receivedBytes) + let offset = 0 + for (const part of assembly.chunks) { + message.set(part, offset) + offset += part.byteLength + } + return message + } + + reset(): void { + this.nextMessageId = 1 + this.assemblies.clear() + } + + private pruneStale(): void { + const now = Date.now() + for (const [messageId, assembly] of this.assemblies) { + if (now - assembly.updatedAt > MAX_ASSEMBLY_AGE_MS) this.assemblies.delete(messageId) + } + } +} + +function isChunk(frame: Uint8Array): boolean { + if (frame.byteLength < RTC_CHUNK_MAGIC.byteLength) return false + for (let index = 0; index < RTC_CHUNK_MAGIC.byteLength; index += 1) { + if (frame[index] !== RTC_CHUNK_MAGIC[index]) return false + } + return true +}