1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
// GENERATED CONTENT - DO NOT EDIT
// Content was automatically extracted by Reffy into webref
// (https://github.com/w3c/webref)
// Source: WebTransport (https://w3c.github.io/webtransport/)
[Exposed=(Window,Worker), SecureContext]
interface WebTransportDatagramDuplexStream {
readonly attribute ReadableStream readable;
readonly attribute WritableStream writable;
readonly attribute unsigned long maxDatagramSize;
attribute unrestricted double? incomingMaxAge;
attribute unrestricted double? outgoingMaxAge;
attribute unrestricted double incomingHighWaterMark;
attribute unrestricted double outgoingHighWaterMark;
};
[Exposed=(Window,Worker), SecureContext]
interface WebTransport {
constructor(USVString url, optional WebTransportOptions options = {});
Promise<WebTransportConnectionStats> getStats();
readonly attribute Promise<undefined> ready;
readonly attribute WebTransportReliabilityMode reliability;
readonly attribute WebTransportCongestionControl congestionControl;
[EnforceRange] attribute unsigned short? anticipatedConcurrentIncomingUnidirectionalStreams;
[EnforceRange] attribute unsigned short? anticipatedConcurrentIncomingBidirectionalStreams;
readonly attribute Promise<WebTransportCloseInfo> closed;
readonly attribute Promise<undefined> draining;
undefined close(optional WebTransportCloseInfo closeInfo = {});
readonly attribute WebTransportDatagramDuplexStream datagrams;
Promise<WebTransportBidirectionalStream> createBidirectionalStream(
optional WebTransportSendStreamOptions options = {});
/* a ReadableStream of WebTransportBidirectionalStream objects */
readonly attribute ReadableStream incomingBidirectionalStreams;
Promise<WebTransportSendStream> createUnidirectionalStream(
optional WebTransportSendStreamOptions options = {});
/* a ReadableStream of WebTransportReceiveStream objects */
readonly attribute ReadableStream incomingUnidirectionalStreams;
WebTransportSendGroup createSendGroup();
static readonly attribute boolean supportsReliableOnly;
};
enum WebTransportReliabilityMode {
"pending",
"reliable-only",
"supports-unreliable",
};
dictionary WebTransportHash {
DOMString algorithm;
BufferSource value;
};
dictionary WebTransportOptions {
boolean allowPooling = false;
boolean requireUnreliable = false;
sequence<WebTransportHash> serverCertificateHashes;
WebTransportCongestionControl congestionControl = "default";
[EnforceRange] unsigned short? anticipatedConcurrentIncomingUnidirectionalStreams = null;
[EnforceRange] unsigned short? anticipatedConcurrentIncomingBidirectionalStreams = null;
};
enum WebTransportCongestionControl {
"default",
"throughput",
"low-latency",
};
dictionary WebTransportCloseInfo {
unsigned long closeCode = 0;
USVString reason = "";
};
dictionary WebTransportSendStreamOptions {
WebTransportSendGroup? sendGroup = null;
long long sendOrder = 0;
boolean waitUntilAvailable = false;
};
dictionary WebTransportConnectionStats {
unsigned long long bytesSent;
unsigned long long packetsSent;
unsigned long long bytesLost;
unsigned long long packetsLost;
unsigned long long bytesReceived;
unsigned long long packetsReceived;
DOMHighResTimeStamp smoothedRtt;
DOMHighResTimeStamp rttVariation;
DOMHighResTimeStamp minRtt;
WebTransportDatagramStats datagrams;
unsigned long long? estimatedSendRate;
};
dictionary WebTransportDatagramStats {
unsigned long long droppedIncoming;
unsigned long long expiredIncoming;
unsigned long long expiredOutgoing;
unsigned long long lostOutgoing;
};
[Exposed=(Window,Worker), SecureContext, Transferable]
interface WebTransportSendStream : WritableStream {
attribute WebTransportSendGroup? sendGroup;
attribute long long sendOrder;
Promise<WebTransportSendStreamStats> getStats();
WebTransportWriter getWriter();
};
dictionary WebTransportSendStreamStats {
unsigned long long bytesWritten;
unsigned long long bytesSent;
unsigned long long bytesAcknowledged;
};
[Exposed=(Window,Worker), SecureContext]
interface WebTransportSendGroup {
Promise<WebTransportSendStreamStats> getStats();
};
[Exposed=(Window,Worker), SecureContext, Transferable]
interface WebTransportReceiveStream : ReadableStream {
Promise<WebTransportReceiveStreamStats> getStats();
};
dictionary WebTransportReceiveStreamStats {
unsigned long long bytesReceived;
unsigned long long bytesRead;
};
[Exposed=(Window,Worker), SecureContext]
interface WebTransportBidirectionalStream {
readonly attribute WebTransportReceiveStream readable;
readonly attribute WebTransportSendStream writable;
};
[Exposed=*, SecureContext]
interface WebTransportWriter : WritableStreamDefaultWriter {
Promise<undefined> atomicWrite(optional any chunk);
};
[Exposed=(Window,Worker), Serializable, SecureContext]
interface WebTransportError : DOMException {
constructor(optional DOMString message = "", optional WebTransportErrorOptions options = {});
readonly attribute WebTransportErrorSource source;
readonly attribute unsigned long? streamErrorCode;
};
dictionary WebTransportErrorOptions {
WebTransportErrorSource source = "stream";
[Clamp] unsigned long? streamErrorCode = null;
};
enum WebTransportErrorSource {
"stream",
"session",
};
|
