WebTransport

3.1. ~WebTransport~session

`~WebTransport~session@ は、 その `下層~接続@ と称される［ ~HTTP3／~HTTP2 ］`接続$越しの~WebTransportが成す~sessionである。 ~pool法が可能化されたときは、 1 個の`接続$に複数個の`~WebTransport~session$が在り得る。 ◎ A WebTransport session is a session of WebTransport over an HTTP/3 or HTTP/2 underlying connection. There may be multiple WebTransport sessions on one connection, when pooling is enabled.

各`~WebTransport~session$は、 次に挙げる能力を有する — それらは `WEB-TRANSPORT-OVERVIEW$r にて定義される： ◎ A WebTransport session has the following capabilities defined in [WEB-TRANSPORT-OVERVIEW]:

各`~WebTransport~session$には、 次に挙げる通達が生じ得る： ◎ A WebTransport session has the following signals:

3.2. ~WebTransport~stream

`~WebTransport~stream@ は、 `WEB-TRANSPORT-OVERVIEW$r `§ ~stream＠~WT-OVERVIEW#features-streams$ にて述べられるとおり，［ `~WebTransport~session$上の `依拠-可能$な順序どおりな~byteたちが成す~stream ］用の概念である。 ◎ A WebTransport stream is a concept for a reliable in-order stream of bytes on a WebTransport session, as described in [WEB-TRANSPORT-OVERVIEW] Section 4.3.

各`~WebTransport~stream$ %~stream は、 次に挙げる能力を有する： ◎ A WebTransport stream has the following capabilities:

各`~WebTransport~session$には、 次に挙げる通達が生じ得る： ◎ A WebTransport stream has the following signals:

4.1. 内部~slot

各 `WebTransportDatagramDuplexStream$I は、 次に挙げる内部~slotを有する — 各項に与える記述は規範的ではない： ◎ A WebTransportDatagramDuplexStream object has the following internal slots. ◎ Internal Slot｜Description (non-normative)

`Readable@sl

ある `ReadableStream$I ◎ A ReadableStream＼

流入~datagram用。 ◎ for incoming datagrams.

`Writable@sl

ある `WritableStream$I ◎ A WritableStream＼

流出~datagram用。 ◎ for outgoing datagrams.

`IncomingDatagramsQueue@sl

ある`~queue$ ◎ A queue＼

( 流入~datagram, 時刻印 ) が成す~pairたちからなる。 ◎ of pairs of an incoming datagram and a timestamp.

`IncomingDatagramsPullPromise@sl

ある~promise ◎ A promise＼

`~datagram群を~pullする$により設定され， 流入~datagramを待機する。 ◎ set by pullDatagrams, to wait for an incoming datagram.

`IncomingDatagramsHighWaterMark@sl

ある `unrestricted double$c ◎ An unrestricted double＼

流入~datagramたちの`限界水位$を表現する。 ◎ representing the high water mark of the incoming datagrams.

`IncomingDatagramsExpirationDuration@sl

~NULL ／ ある `unrestricted double$c ◎ ↓

~NULL でない場合、 流入~datagramたち用の失効n所要時間を（~milli秒数で）表現する。 ◎ An unrestricted double representing the expiration duration for incoming datagrams (in milliseconds), or null.

`OutgoingDatagramsQueue@sl

ある`~queue$ ◎ A queue＼

( 流出~datagram, 時刻印, ~promise ) が成す~tupleたちからなる。 ◎ of tuples of an outgoing datagram, a timestamp and a promise＼

この~tupleを成す~promiseは、 ~datagramが［ 送信される／破棄される ］とき解決される。 ◎ which is resolved when the datagram is sent or discarded.

`OutgoingDatagramsHighWaterMark@sl

ある `unrestricted double$c ◎ An unrestricted double＼

流出~datagramの`限界水位$を表現する。 ◎ representing the high water mark of the outgoing datagrams.

`OutgoingDatagramsExpirationDuration@sl

~NULL ／ ある `unrestricted double$c ◎ ↓

~NULL でない場合、 流出~datagram用の失効n所要時間を（~milli秒数で）表現する。 ◎ An unrestricted double value representing the expiration duration for outgoing datagrams (in milliseconds), or null.

`OutgoingMaxDatagramSize@sl

ある整数 ◎ An integer＼

流出~datagram用の最大~sizeを表現する。 ◎ representing the maximum size for an outgoing datagram.

~UAは、 所与の `WebTransport$I ~obj %~transport に対し［ %~transport . `State$sl ~IN { `connecting^l, `connected^l } ］が満たされる間は， %~transport . `OutgoingMaxDatagramSize$sl を更新してもヨイ。 ◎ The user agent MAY update [[OutgoingMaxDatagramSize]] for any WebTransport object whose [[State]] is either "connecting" or "connected".

`WebTransportDatagramDuplexStream$I を `作成する@DPS ときは、 所与の ( %可読~stream, %可書~stream ) に対し，次の手続きを遂行する： ◎ To create a WebTransportDatagramDuplexStream given a readable, and a writable, perform the following steps.

1. %~stream ~LET `新たな$ `WebTransportDatagramDuplexStream$I — その ⇒＃ `Readable$sl ~SET %可読~stream, `Writable$sl ~SET %可書~stream, `IncomingDatagramsQueue$sl ~SET 新たな`~queue$, `IncomingDatagramsPullPromise$sl ~SET ~NULL, `IncomingDatagramsHighWaterMark$sl ~SET `実装定義$な値, `IncomingDatagramsExpirationDuration$sl ~SET ~NULL, `OutgoingDatagramsQueue$sl ~SET 新たな`~queue$, `OutgoingDatagramsHighWaterMark$sl ~SET `実装定義$な値†, `OutgoingDatagramsExpirationDuration$sl ~SET ~NULL, `OutgoingMaxDatagramSize$sl ~SET `実装定義$な整数

   注記†： この実装定義な値は、［ まずまずの~throughputを確保する ］かつ［ 伝送される~dataの適時性を危うくしない ］よう調律されるべきである。

   ◎ Let stream be a new WebTransportDatagramDuplexStream, with: • [[Readable]] •• readable • [[Writable]] •• writable • [[IncomingDatagramsQueue]] •• an empty queue • [[IncomingDatagramsPullPromise]] •• null • [[IncomingDatagramsHighWaterMark]] •• an implementation-defined value • [[IncomingDatagramsExpirationDuration]] •• null • [[OutgoingDatagramsQueue]] •• an empty queue • [[OutgoingDatagramsHighWaterMark]] •• an implementation-defined value •• This implementation-defined value should be tuned to ensure decent throughput, without jeopardizing the timeliness of transmitted data. • [[OutgoingDatagramsExpirationDuration]] •• null • [[OutgoingMaxDatagramSize]] •• an implementation-defined integer.
2. ~RET %~stream ◎ Return stream.

4.2. 属性

`readable@mD ◎ readable, of type ReadableStream, readonly

取得子~手続きは ⇒ ~RET コレ . `Readable$sl ◎ The getter steps are: • Return this.[[Readable]].

`writable@mD ◎ writable, of type WritableStream, readonly

取得子~手続きは ⇒ ~RET コレ . `Writable$sl ◎ The getter steps are: • Return this.[[Writable]].

`incomingMaxAge@mD ◎ incomingMaxAge, of type unrestricted double, nullable

取得子~手続きは ⇒ ~RET コレ . `IncomingDatagramsExpirationDuration$sl ◎ The getter steps are: • Return this.[[IncomingDatagramsExpirationDuration]].

設定子~手続きは、 `所与の値$ %値 に対し： ◎ The setter steps, given value, are:

1. ~IF［ %値 ~LT 0 ］~OR［ %値 ~EQ NaN ］ ⇒ ~THROW `RangeError$E ◎ If value is negative or NaN, throw a RangeError.
2. ~IF［ %値 ~EQ 0 ］ ⇒ %値 ~SET ~NULL ◎ If value is 0, set value to null.
3. コレ . `IncomingDatagramsExpirationDuration$sl ~SET %値 ◎ Set this.[[IncomingDatagramsExpirationDuration]] to value.

`maxDatagramSize@mD ◎ maxDatagramSize, of type unsigned long, readonly

`writable$mD に渡してもよい~dataの最大~size ◎ The maximum size data that may be passed to writable.＼

取得子~手続きは ⇒ ~RET コレ . `OutgoingMaxDatagramSize$sl ◎ The getter steps are to return this.[[OutgoingMaxDatagramSize]].

`outgoingMaxAge@mD ◎ outgoingMaxAge, of type unrestricted double, nullable

取得子~手続きは ⇒ ~RET コレの `OutgoingDatagramsExpirationDuration$sl ◎ The getter steps are: • Return this's [[OutgoingDatagramsExpirationDuration]].

設定子~手続きは、 `所与の値$ %値 に対し： ◎ The setter steps, given value, are:

1. ~IF［ %値 ~LT 0 ］~OR［ %値 ~EQ NaN ］ ⇒ ~THROW `RangeError$E ◎ If value is negative or NaN, throw a RangeError.
2. ~IF［ %値 ~EQ 0 ］ ⇒ %値 ~SET ~NULL ◎ If value is 0, set value to null.
3. コレ . `OutgoingDatagramsExpirationDuration$sl ~SET %値 ◎ Set this.[[OutgoingDatagramsExpirationDuration]] to value.

`incomingHighWaterMark@mD ◎ incomingHighWaterMark, of type unrestricted double

取得子~手続きは ⇒ ~RET コレ . `IncomingDatagramsHighWaterMark$sl ◎ The getter steps are: • Return this.[[IncomingDatagramsHighWaterMark]].

設定子~手続きは、 `所与の値$ %値 に対し： ◎ The setter steps, given value, are:

1. ~IF［ %値 ~LT 0 ］~OR［ %値 ~EQ NaN ］ ⇒ ~THROW `RangeError$E ◎ If value is negative or NaN, throw a RangeError.
2. ~IF［ %値 ~LT 1 ］ ⇒ %値 ~SET 1 ◎ If value is < 1, set value to 1.
3. コレ . `IncomingDatagramsHighWaterMark$sl ~SET %値 ◎ Set this.[[IncomingDatagramsHighWaterMark]] to value.

`outgoingHighWaterMark@mD ◎ outgoingHighWaterMark, of type unrestricted double

取得子~手続きは ⇒ ~RET コレ . `OutgoingDatagramsHighWaterMark$sl ◎ The getter steps are: • Return this.[[OutgoingDatagramsHighWaterMark]].

設定子~手続きは、 `所与の値$ %値 に対し： ◎ The setter steps, given value, are:

1. ~IF［ %値 ~LT 0 ］~OR［ %値 ~EQ NaN ］ ⇒ ~THROW `RangeError$E ◎ If value is negative or NaN, throw a RangeError.
2. ~IF［ %値 ~LT 1 ］ ⇒ %値 ~SET 1 ◎ If value is < 1, set value to 1.
3. コレ . `OutgoingDatagramsHighWaterMark$sl ~SET %値 ◎ Set this.[[OutgoingDatagramsHighWaterMark]] to value.

4.3. 手続-

~UAは、 次に従うベキである ⇒ `WebTransport$I ~objが［ その `State$sl ~EQ `connected^l ］を満たす間は ⇒ `~datagram群を受信する$ ~algoが進捗を為せるようになったときには、 アリな限り適度に早く，それを走らす ◎ The user agent SHOULD run receiveDatagrams for any WebTransport object whose [[State]] is "connected" as soon as reasonably possible whenever the algorithm can make progress.

~UAは、 次に従うベキである ⇒ `WebTransport$I ~objが［ その `State$sl ~IN { `connecting^l, `connected^l } ］を満たす間は ⇒ `~datagram群を送信する$ ~algoが進捗を為せるようになったときには、 アリな限り適度に早く，それを走らす ◎ The user agent SHOULD run sendDatagrams for any WebTransport object whose [[State]] is "connecting" or "connected" as soon as reasonably possible whenever the algorithm can make progress.

5.1. 内部~slot

各 `WebTransport$I %~transport は、 次に挙げる内部~slotを有する — 各項に与える【~data型~以外の】記述は規範的ではない： ◎ A WebTransport object has the following internal slots. ◎ Internal Slot｜Description (non-normative)

`SendStreams@sl

`有順序~集合$ ◎ An ordered set＼

%~transport に所有されている `WebTransportSendStream$I たちからなる ◎ An ordered set of WebTransportSendStreams owned by this WebTransport.

`ReceiveStreams@sl

`有順序~集合$ ◎ An ordered set＼

%~transport に所有されている `WebTransportReceiveStream$I たちからなる ◎ of WebTransportReceiveStreams owned by this WebTransport.

`IncomingBidirectionalStreams@sl

`IncomingUnidirectionalStreams@sl

いずれも，ある `ReadableStream$I ◎ A ReadableStream＼

順に，~serverから受信した［ 双方向~streamを表現する `WebTransportBidirectionalStream$I たち／ 一方向~streamを表現する `WebTransportReceiveStream$I たち ］からなる† ◎ consisting of WebTransportBidirectionalStream objects. ◎ IncomingUnidirectionalStreams ◎ A ReadableStream consisting of WebTransportReceiveStreams.

【† “からなる（ `consisting of^en ）” とは、 これら各~objが `ReadableStream$I に~chunkとして~enqueueされることを意味する — ［ `双方向~streamを~pullする$, `一方向~streamを~pullする$ ］を見よ。 】

注記： 流入~stream上にすでに~dataがあるかどうかは、 ~serverの挙動に依存することになる。 【！Note: Whether the incoming streams already have data on them will depend on server behavior.】

`State@sl

次に挙げるいずれか ⇒＃ `connecting^l, `connected^l, `draining^l, `closed^l, `failed^l ◎ An enum indicating the state of the transport. One of "connecting", "connected", "draining", "closed", and "failed".

%~transport の状態を指示する ◎ ↑

`Ready@sl

ある~promise ◎ A promise＼

`~WebTransport~sessionを確立する$ことに ⇒＃ 成功したとき充足される／ 失敗したとき却下される ◎ fulfilled when the associated WebTransport session gets established, or rejected if the establishment process failed.

`Reliability@sl

ある `WebTransportReliabilityMode$I ◎ A WebTransportReliabilityMode＼

接続が確立されるまでは `pending$l を返す。 それ以降は、 接続が［ `不依拠-可能$な（~UDP越し）~transportを~supportするならば `supports-unreliable$l ／ `依拠-可能$な（~fallbackによる~TCP越し）~transportしか~supportしないならば `reliable-only$l ］を返す。 ◎ indicating whether the first hop supports unreliable (UDP) transport or whether only reliable (TCP fallback) transport is available.＼ ◎ Returns "pending" until a connection has been established.

`CongestionControl@sl

ある `WebTransportCongestionControl$I ◎ A WebTransportCongestionControl＼

応用により［ ~throughput／短い待時間 ］用に最適化された輻輳~制御~algoが要請され，~UAにより満足されたならば、 その選好を 【 `throughput$l ／ `low-latency$l として】 指示する。 他の場合は `default$l になる。 ◎ indicating whether a preference for a congestion control algorithm optimized for throughput or low latency was requested by the application and satisfied by the user agent, or "default".

`AnticipatedConcurrentIncomingUnidirectionalStreams@sl

~NULL ／ ある整数 ◎ ↓

~NULL でない場合、［ 同時並行に~openな，`流入~一方向$な~streamたち ］として［ ~serverが作成するものと応用が見越す個数 ］を与える。 ◎ The number of concurrently open incoming unidirectional streams the application anticipates the server creating, or null.

`AnticipatedConcurrentIncomingBidirectionalStreams@sl

~NULL ／ ある整数 ◎ ↓

~NULL でない場合、［ 同時並行に~openな，`双方向$な~streamたち ］として［ ~serverが作成するものと応用が見越す個数 ］を与える。 ◎ The number of concurrently open bidirectional streams the application anticipates the server creating, or null.

`Protocol@sl

ある文字列 ◎ A string＼

~serverにより選定された応用~levelの~protocolを指示する。 ◎ indicating the application-level protocol selected by the server, if any.＼

初期~時は空~文字列とする。 ◎ Initially an empty string.

`Closed@sl

ある~promise ◎ A promise＼

%~transport が ⇒＃ 上品に~closeされたとき充足される／ 中途で~closeされたとき却下される／ 初期化に失敗したとき却下される ◎ fulfilled when the associated WebTransport object is closed gracefully, or rejected when it is closed abruptly or failed on initialization.

`Draining@sl

ある~promise ◎ A promise＼

%~transport が［ `DRAIN_WEBTRANSPORT_SESSION$ft `~capsule$ ／ `GOAWAY$ft ~frame ］を受信したとき充足される。 ◎ fulfilled when the associated WebTransport session receives a DRAIN_WEBTRANSPORT_SESSION capsule or a GOAWAY frame.

`Datagrams@sl

ある `WebTransportDatagramDuplexStream$I ◎ A WebTransportDatagramDuplexStream.

この~session越しに~datagram群を［ 送信する／受信する ］ための単独の二重化~stream。 ◎ ↓↓

`Session@sl

~NULL ／ %~transport 用の`~WebTransport~session$ ◎ A WebTransport session for this WebTransport object, or null.

5.2. 構築子

5.3. 属性

【 原文には、 各~属性のうち一部に（規範的でない）記述もあるが、 属性が返す内部~slotの定義にて同様な内容が述べられているので，この訳では省略する （あるいは、そこへ移動している）。 】

`ready@mT ◎ ready, of type Promise<undefined>, readonly

取得子~手続きは ⇒ ~RET コレ . `Ready$sl ◎ On getting, it MUST return this's [[Ready]].

`closed@mT ◎ closed, of type Promise<WebTransportCloseInfo>, readonly

取得子~手続きは ⇒ ~RET コレ . `Closed$sl ◎ On getting, it MUST return this's [[Closed]].

`draining@mT ◎ draining, of type Promise<undefined>, readonly

取得子~手続きは ⇒ ~RET コレ . `Draining$sl ◎ On getting, it MUST return this's [[Draining]].

`datagrams@mT ◎ datagrams, of type WebTransportDatagramDuplexStream, readonly

取得子~手続きは ⇒ ~RET コレ . `Datagrams$sl ◎ ↑↑ A single duplex stream for sending and receiving datagrams over this session.＼ ◎ The getter steps for the datagrams attribute SHALL be: • Return this's [[Datagrams]].

`incomingBidirectionalStreams@mT ◎ incomingBidirectionalStreams, of type ReadableStream, readonly

取得子~手続きは ⇒ ~RET コレ . `IncomingBidirectionalStreams$sl ◎ ↑↑ Returns a ReadableStream of WebTransportBidirectionalStreams that have been received from the server.＼ ◎ ↑↑ Note: Whether the incoming streams already have data on them will depend on server behavior. ◎ The getter steps for the incomingBidirectionalStreams attribute SHALL be: • Return this's [[IncomingBidirectionalStreams]].

`incomingUnidirectionalStreams@mT ◎ incomingUnidirectionalStreams, of type ReadableStream, readonly

取得子~手続きは ⇒ ~RET コレ . `IncomingUnidirectionalStreams$sl ◎ ↑↑ A ReadableStream of unidirectional streams, each represented by a WebTransportReceiveStream, that have been received from the server.＼ ◎ ↑↑ Note: Whether the incoming streams already have data on them will depend on server behavior. ◎ The getter steps for incomingUnidirectionalStreams are: • Return this.[[IncomingUnidirectionalStreams]].

`reliability@mT ◎ reliability, of type WebTransportReliabilityMode, readonly

取得子~手続きは ⇒ ~RET コレ . `Reliability$sl ◎ Whether connection supports unreliable (over UDP) transport or only reliable (over TCP fallback) transport. Returns "pending" until a connection has been established.＼ The getter steps are to return this's [[Reliability]].

`congestionControl@mT ◎ congestionControl, of type WebTransportCongestionControl, readonly

取得子~手続きは ⇒ ~RET コレ . `CongestionControl$sl ◎ The application’s preference, if requested in the constructor, and satisfied by the user agent, for a congestion control algorithm optimized for either throughput or low latency for sending on this connection. If a preference was requested but not satisfied, then the value is "default"＼ The getter steps are to return this's [[CongestionControl]].

`supportsReliableOnly@mT ◎ supportsReliableOnly, of type boolean, readonly

取得子~手続きは ⇒ ~RET ~IS［ ~UAは、 `~WebTransport~session$を`依拠-可能$な`接続$越しに限り~supportする ］ ◎ Returns true if the user agent supports WebTransport sessions over exclusively reliable connections, otherwise false.

`anticipatedConcurrentIncomingUnidirectionalStreams@mT ◎ anticipatedConcurrentIncomingUnidirectionalStreams, of type unsigned short, nullable

値の意味は、 `WebTransportOptions$I の `anticipatedConcurrentIncomingUnidirectionalStreams$mb を見よ。 ◎ Optionally lets an application specify the number of concurrently open incoming unidirectional streams it anticipates the server creating.＼ If not null, the user agent SHOULD attempt to reduce future round-trips by taking [[AnticipatedConcurrentIncomingUnidirectionalStreams]] into consideration in its negotiations with the server.

取得子~手続きは ⇒ ~RET コレ . `AnticipatedConcurrentIncomingUnidirectionalStreams$sl ◎ The getter steps are to return this's [[AnticipatedConcurrentIncomingUnidirectionalStreams]].

設定子~手続きは ⇒ コレ . `AnticipatedConcurrentIncomingUnidirectionalStreams$sl ~SET 所与の値 ◎ The setter steps, given value, are to set this's [[AnticipatedConcurrentIncomingUnidirectionalStreams]] to value.

`anticipatedConcurrentIncomingBidirectionalStreams@mT ◎ anticipatedConcurrentIncomingBidirectionalStreams, of type unsigned short, nullable

値の意味は、 `WebTransportOptions$I の `anticipatedConcurrentIncomingBidirectionalStreams$mb を見よ。 ◎ Optionally lets an application specify the number of concurrently open bidirectional streams it anticipates the server creating.＼ If not null, the user agent SHOULD attempt to reduce future round-trips by taking [[AnticipatedConcurrentIncomingBidirectionalStreams]] into consideration in its negotiations with the server.

取得子~手続きは ⇒ ~RET コレ . `AnticipatedConcurrentIncomingBidirectionalStreams$sl ◎ The getter steps are to return this's [[AnticipatedConcurrentIncomingBidirectionalStreams]].

設定子~手続きは ⇒ コレ . `AnticipatedConcurrentIncomingBidirectionalStreams$sl ~SET 所与の値 ◎ The setter steps, given value, are to set this's [[AnticipatedConcurrentIncomingBidirectionalStreams]] to value.

注記： ［ `anticipatedConcurrentIncomingUnidirectionalStreams$mT ／ `anticipatedConcurrentIncomingBidirectionalStreams$mT ］は、 設定したとしても，［ 応用が，自身が見越した~streamの個数を受信するようになる ］ことを保証するものではない。 ◎ Note: Setting anticipatedConcurrentIncomingUnidirectionalStreams or anticipatedConcurrentIncomingBidirectionalStreams does not guarantee the application will receive the number of streams it anticipates.

`protocol@mT ◎ protocol, of type DOMString, readonly

［ 構築子~optionとして空でない `protocols$mb が利用された ］下で［ `~WebTransport~session$が確立された ］なら、［ ~serverにより選定された応用~levelの~protocol ］が在る場合は，それを指示する文字列を返す。 他の場合、 空~文字列を返す。 ◎ Once a WebTransport session has been established and the protocols constructor option was used to provide a non-empty array, returns the application-level protocol selected by the server, if any. Otherwise, an empty string.＼

取得子~手続きは ⇒ ~RET コレ .`Protocol$sl ◎ The getter steps are to return this's [[Protocol]].

5.4. ~method

`close(closeInfo)@mT ◎ close(closeInfo)

この `WebTransport$I に結付けられた`~WebTransport~session$を終了する。 ◎ Terminates the WebTransport session associated with the WebTransport object.

~method手続きは： ◎ When close is called, the user agent MUST run the following steps:

1. %~transport ~LET コレ ◎ Let transport be this.
2. ~IF［ %~transport . `State$sl ~IN { `closed^l, `failed^l } ］ ⇒ ~RET ◎ If transport.[[State]] is "closed" or "failed", then abort these steps.

3. ~IF［ %~transport . `State$sl ~EQ `connecting^l ］： ◎ If transport.[[State]] is "connecting":

   1. %~error ~LET `~WebTransport用の例外を作成する$( `session^l ) ◎ Let error be a newly created WebTransportError whose source is "session".
   2. `~WebTransportを片付ける$( %~transport, %~error ) ◎ Cleanup transport with error.
   3. ~RET ◎ Abort these steps.
4. %~session ~LET %~transport . `Session$sl ◎ Let session be transport.[[Session]].
5. %~code ~LET %closeInfo[ "`closeCode$mb" ] ◎ Let code be closeInfo.closeCode.
6. %事由 ~LET 空な`~byte列$ ◎ ↓

7. %事由~文字列 ~LET `~scalar値~文字列に変換する$( %closeInfo[ "`reason$mb" ] )

   【 原文は，`符号単位$に基づいて演算しているが、 以下で~UTF-8符号化法を適用するためには， ~scalar値に変換する必要があろう。 】

   ◎ ↓
8. %長さ ~LET 0 ◎ ↓

9. %事由~文字列 を成す ~EACH( %符号位置 ) に対し： 【！`符号単位~接頭辞$】

   1. %~byte列 ~LET `~UTF-8符号化する$( %符号位置 )
   2. %長さ ~INCBY %~byte列 の`長さ$byte
   3. ~IF［ %長さ ~GT 1024 ］ ⇒ ~BREAK
   4. %事由 に %~byte列 を付加する
   ◎ Let reasonString be the maximal code unit prefix of closeInfo.reason where the length of the UTF-8 encoded prefix doesn’t exceed 1024. ◎ Let reason be reasonString, UTF-8 encoded.

10. この段は`並列的$に走らす ⇒ `~WebTransport~sessionを終了する$( %~session, %~code, %事由 ) ◎ In parallel, terminate session with code and reason.

    注記： これはまた［ %~transport . `SendStreams$sl, %~transport . `ReceiveStreams$sl ］内に包含された各`~WebTransport~stream$に対しても［ `設定し直す$WT／ `送信を停止させる$WT ］ ◎ Note: This also resets or sends STOP_SENDING WebTransport streams contained in transport.[[SendStreams]] and [[ReceiveStreams]].

11. `~WebTransportを片付ける$( %~transport, `AbortError$E, %closeInfo ) ◎ Cleanup transport with AbortError and closeInfo.

`getStats()@mT ◎ getStats()

この `WebTransport$I の`下層~接続$用の統計を集めて， その結果を非同期的に報告する。 ◎ Gathers stats for this WebTransport's underlying connection and reports the result asynchronously.

~method手続きは： ◎ When getStats is called, the user agent MUST run the following steps:

1. %~transport ~LET コレ ◎ Let transport be this.
2. %~promise ~LET `新たな~promise$ ◎ Let p be a new promise.

3. ~IF［ %~transport . `State$sl ~EQ `failed^l ］ ⇒ ~RET `却下される~promise$( `InvalidStateError$E 例外 ) ◎ ↑

   【 この段は、 原文では［ `~promiseを却下する$( %p, `InvalidStateError^E 例外 ) ］を行ってから値を返さずに手続きを終えているが，誤りであろう。 `failed^l は、 以下で`並列的$に走らす手続きの中でも取扱われているので，この段は不要かもしれない。 】

   ◎ If transport.[[State]] is "failed", reject p with an InvalidStateError and abort these steps.

4. この段は`並列的$に走らす： ◎ Run the following steps in parallel:

   1. ~IF［ %~transport . `State$sl ~EQ `connecting^l ］ ⇒ %~transport . `State$sl が変化するまで待機する ◎ If transport.[[State]] is "connecting", wait until it changes.
   2. ~IF［ %~transport . `State$sl ~EQ `failed^l ］ ⇒＃ `~promiseを却下する$( %p, `InvalidStateError$E 例外 )； ~RET ◎ If transport.[[State]] is "failed", reject p with an InvalidStateError and abort these steps.

   3. ~IF［ %~transport . `State$sl ~EQ `closed^l ］：

      1. %統計 ~LET `新たな$ `WebTransportConnectionStats$I ~obj
      2. %統計 を成す各~memberを当の接続~用に可用な最も近過去な統計を表現するよう設定する — 統計が収集される正確な時点は、 `実装定義$とする。
      3. `~promiseを解決する$( %p, %統計 )
      4. ~RET
      ◎ If transport.[[State]] is "closed", resolve p with the most recent stats available for the connection and abort these steps. The exact point at which those stats are collected is implementation-defined.
   4. `下層~接続$から統計を集める — 各~datagram上の統計も含む ◎ Gather the stats from the underlying connection, including stats on datagrams.

   5. `~network~taskを~queueする$( %~transport, 次の手続き ) ◎ Queue a network task with transport to＼

      手続きは： ◎ run the following steps:

      1. %統計 ~LET `新たな$ `WebTransportConnectionStats$I ~obj ◎ Let stats be a new WebTransportConnectionStats object＼
      2. %統計 を成す各~memberを集められた統計を表現するよう設定する ◎ representing the gathered stats.
      3. `~promiseを解決する$( %~promise, %統計 ) ◎ Resolve p with stats.
5. ~RET %~promise ◎ Return p.

`createBidirectionalStream(options)@mT ◎ createBidirectionalStream()

流出~双方向~stream用の `WebTransportBidirectionalStream$I ~objを作成する。 ~streamの作成だけでは、 ~dataの送信に利用されるまでは， 即時に相手の端点から可視になることはないことに注意。 ◎ Creates a WebTransportBidirectionalStream object for an outgoing bidirectional stream. Note that the mere creation of a stream is not immediately visible to the peer until it is used to send data.

注記： 当の~stream上に~dataが送信されるまでは、 ~serverが当の~streamを自覚するようになることは期待されない。 ◎ Note: There is no expectation that the server will be aware of the stream until data is sent on it.

~method手続きは： ◎ When createBidirectionalStream is called, the user agent MUST run the following steps:

1. %~transport ~LET コレ ◎ Let transport be this.
2. ~IF［ %~transport . `State$sl ~IN { `closed^l, `failed^l } ］ ⇒ ~RET `却下される~promise$( `InvalidStateError$E ) ◎ If transport.[[State]] is "closed" or "failed", return a new rejected promise with an InvalidStateError.
3. %送信-~group ~LET %options[ "`sendGroup$mb" ] ◎ Let sendGroup be options's sendGroup.
4. %送信-順序 ~LET %options[ "`sendOrder$mb" ] ◎ Let sendOrder be options's sendOrder.
5. %可用になるまで待機するか ~LET %options[ "`waitUntilAvailable$mb" ] ◎ Let waitUntilAvailable be options's waitUntilAvailable.
6. %~promise ~LET `新たな~promise$ ◎ Let p be a new promise.

7. この段は、 `並列的$に走らすことに加え： ◎ Run the following steps in parallel,＼

   • 次が満たされた`ときは中止する$ ⇒ %~transport . `State$sl ~IN { `closed^l, `failed^l } ◎ but abort when transport’s [[State]] becomes "closed" or "failed",＼

   • `中止されたときは$ ⇒ `~network~taskを~queueする$( %~transport, 次の手続き ) ◎ and instead queue a network task with transport to＼

     手続きは ⇒ `~promiseを却下する$( %~promise, `InvalidStateError$E ) ◎ reject p with an InvalidStateError:

   1. %~stream~ID ~LET %~transport . `Session$sl 用に妥当かつ一意な新たな~stream~ID — `QUIC$r `§ 19.11＠~RFCx/rfc9000#section-19.11$ にて定義されるとおり

      ~IF［ 枯渇に因り，即時に可用な~stream~IDは無い ］：

      1. ~IF［ %可用になるまで待機するか ~EQ ~F ］ ⇒＃ `~promiseを却下する$( %p, `QuotaExceededError$E 例外 )； ~RET
      2. ~stream~IDが可用になるまで待機する
      3. %~stream~ID ~SET 可用になった~stream~ID
      ◎ Let streamId be a new stream ID that is valid and unique for transport.[[Session]], as defined in [QUIC] Section 19.11. If one is not immediately available due to exhaustion, wait for it to become available if waitUntilAvailable is true, reject p with a QuotaExceededError and abort these steps otherwise.
   2. %内部~stream ~LET `双方向~streamを作成する$( %~transport . `Session$sl, %~stream~ID ) ◎ Let internalStream be the result of creating a bidirectional stream with transport.[[Session]] and streamId.

   3. `~network~taskを~queueする$( %~transport, 次の手続き ) ◎ Queue a network task with transport to＼

      手続きは： ◎ run the following steps:

      1. ~IF［ %~transport . `State$sl ~IN { `closed^l, `failed^l } ］ ⇒＃ `~promiseを却下する$( %~promise, `InvalidStateError$E )； ~RET ◎ If transport.[[State]] is "closed" or "failed", reject p with an InvalidStateError and abort these steps.
      2. %~stream ~LET `WebTransportBidirectionalStream$I を`作成する$wtB( %内部~stream, %~transport, %送信-~group, %送信-順序 ) ◎ Let stream be the result of creating a WebTransportBidirectionalStream with internalStream, transport, sendGroup, and sendOrder.
      3. `~promiseを解決する$( %~promise, %~stream ) ◎ Resolve p with stream.
8. ~RET %~promise ◎ Return p.

`createUnidirectionalStream(options)@mT ◎ createUnidirectionalStream()

流出~一方向~stream用の `WebTransportSendStream$I を作成する。 ~streamの作成だけでは、 ~dataの送信に利用されるまでは， ~serverからは即時に可視にならないことに注意。 ◎ Creates a WebTransportSendStream for an outgoing unidirectional stream. Note that the mere creation of a stream is not immediately visible to the server until it is used to send data.

注記： 当の~stream上に~dataが送信されるまでは、 ~serverが当の~streamを自覚するようになることは期待されない。 ◎ Note: There is no expectation that the server will be aware of the stream until data is sent on it.

~method手続きは： ◎ When createUnidirectionalStream() method is called, the user agent MUST run the following steps:

1. %~transport ~LET コレ ◎ Let transport be this.
2. ~IF［ %~transport . `State$sl ~IN { `closed^l, `failed^l } ］ ⇒ ~RET `却下される~promise$( `InvalidStateError$E ) ◎ If transport.[[State]] is "closed" or "failed", return a new rejected promise with an InvalidStateError.
3. %送信-~group ~LET %options[ "`sendGroup$mb" ] ◎ Let sendGroup be options's sendGroup.
4. %送信-順序 ~LET %options[ "`sendOrder$mb" ] ◎ Let sendOrder be options's sendOrder.
5. %可用になるまで待機するか ~LET %options[ "`waitUntilAvailable$mb" ] ◎ Let waitUntilAvailable be options's waitUntilAvailable.
6. %~promise ~LET `新たな~promise$ ◎ Let p be a new promise.

7. この段は、 `並列的$に走らすことに加え： ◎ Run the following steps in parallel,＼

   • 次が満たされた`ときは中止する$ ⇒ %~transport . `State$sl ~IN { `closed^l, `failed^l } ◎ but abort when transport’s [[State]] becomes "closed" or "failed",＼

   • `中止されたときは$ ⇒ `~network~taskを~queueする$( %~transport, 次の手続き ) ◎ and instead queue a network task with transport to＼

     手続きは ⇒ `~promiseを却下する$( %~promise, `InvalidStateError$E ) ◎ reject p with an InvalidStateError:

   1. %~stream~ID ~LET %~transport . `Session$sl 用に妥当かつ一意な新たな~stream~ID — `QUIC$r `§ 19.11＠~RFCx/rfc9000#section-19.11$ にて定義されるとおり

      ~IF［ 枯渇に因り，即時に可用な~stream~IDは無い ］：

      1. ~IF［ %可用になるまで待機するか ~EQ ~F ］ ⇒＃ `~promiseを却下する$( %p, `QuotaExceededError$E 例外 )； ~RET
      2. ~stream~IDが可用になるまで待機する
      3. %~stream~ID ~SET 可用になった~stream~ID
      ◎ Let streamId be a new stream ID that is valid and unique for transport.[[Session]], as defined in [QUIC] Section 19.11. If one is not immediately available due to exhaustion, wait for it to become available if waitUntilAvailable is true, reject p with a QuotaExceededError and abort these steps otherwise.

   2. %内部~stream ~LET `流出~一方向~streamを作成する$( %~transport . `Session$sl, %~stream~ID ) ◎ Let internalStream be the result of creating an outgoing unidirectional stream with transport.[[Session]] and streamId.

   3. `~network~taskを~queueする$( %~transport, 次の手続き ) ◎ Queue a network task with transport to＼

      手続きは： ◎ run the following steps:

      1. ~IF［ %~transport . `State$sl ~IN { `closed^l, `failed^l } ］ ⇒＃ `~promiseを却下する$( %~promise, `InvalidStateError$E )； ~RET ◎ If transport.[[State]] is "closed" or "failed", reject p with an InvalidStateError and abort these steps.
      2. %~stream ~LET `WebTransportSendStream$I を`作成する$wtS( %内部~stream, %~transport, %送信-~group, %送信-順序 ) ◎ Let stream be the result of creating a WebTransportSendStream with internalStream, transport, sendGroup, and sendOrder.
      3. `~promiseを解決する$( %~promise, %~stream ) ◎ Resolve p with stream.
8. ~RET %~promise ◎ return p.

`createSendGroup()@mT ◎ createSendGroup()

`WebTransportSendGroup$I を作成する。 ◎ Creates a WebTransportSendGroup.

~method手続きは： ◎ When createSendGroup() method is called, the user agent MUST run the following steps:

1. %~transport ~LET コレ ◎ Let transport be this.
2. ~IF［ %~transport . `State$sl ~IN { `closed^l, `failed^l } ］ ⇒ ~THROW `InvalidStateError$E ◎ If transport.[[State]] is "closed" or "failed", throw an InvalidStateError.
3. ~RET `WebTransportSendGroup$I を`作成する$TSG( %~transport ) ◎ Return the result of creating a WebTransportSendGroup with transport.

5.5. 手続-

5.6. ~clientにより起動されたものでない~sessionの終了n

5.7. 文脈を片付ける手続き

5.8. ~garbage収集

~UAは、 所与の ( `WebTransport$I ~obj %~transport ) に対し， %~transport が ~OR↓ を満たす間は %~transport を~garbage収集しないモノトスル： ◎ ↓

• ~AND↓：

  • %~transport . `State$sl ~IN { `connecting^l, `connected^l, `draining^l }
  • ［ 関連な~streamのうち`~lockされて$RSいるものがある ］~OR［ 関連な~promiseのうち観測されているものがある ］

  上の条件において：

  • 関連な~streamとは、 次に挙げる~streamの総称である ⇒＃ %~transport . `IncomingBidirectionalStreams$sl, %~transport . `IncomingUnidirectionalStreams$sl, 【%~transport . `ReceiveStreams$sl を成す】各 `WebTransportReceiveStream$I, %~transport . `Datagrams$sl . `Readable$sl
  • 関連な~promiseとは、［ %~transport . `State$sl に応じて，次に挙げる %~transport の属性（たち） ］が返した~promiseの総称である ⇒＃ `connecting^l ならば［ `ready$mT, `draining$mT, `closed$mT ］ ／ `connected^l ならば［ `draining$mT, `closed$mT ］ ／ `draining^l ならば `closed$mT
  ◎ A WebTransport object whose [[State]] is "connecting" must not be garbage collected if [[IncomingBidirectionalStreams]], [[IncomingUnidirectionalStreams]], any WebTransportReceiveStream, or [[Datagrams]].[[Readable]] are locked, or if the ready, draining, or closed promise is being observed. ◎ A WebTransport object whose [[State]] is "connected" must not be garbage collected if [[IncomingBidirectionalStreams]], [[IncomingUnidirectionalStreams]], any WebTransportReceiveStream, or [[Datagrams]].[[Readable]] are locked, or if the draining or closed promise is being observed. ◎ A WebTransport object whose [[State]] is "draining" must not be garbage collected if [[IncomingBidirectionalStreams]], [[IncomingUnidirectionalStreams]], any WebTransportReceiveStream, or [[Datagrams]].[[Readable]] are locked, or if the closed promise is being observed.

• ~AND↓：

  • `~WebTransport~session$を`確立した＠#session-establish$
  • ~networkへ伝送するよう~queueされた~dataがある — この~dataには、 %~transport . `Datagrams$sl . `OutgoingDatagramsQueue$sl 内の~datagramも含まれる。
  ◎ A WebTransport object with an established WebTransport session that has data queued to be transmitted to the network, including datagrams in [[Datagrams]].[[OutgoingDatagramsQueue]], must not be garbage collected.

`WebTransport$I ~objが，その`下層~接続$がまだ~openな間に~garbage収集された場合、 ~UAは，`~WebTransport~sessionを終了する＠~WT-OVERVIEW#terminate-a-session$モノトスル — ( ~error~code 0, ~error~message 空~文字列 ) を与える下で ◎ If a WebTransport object is garbage collected while the underlying connection is still open, the user agent must terminate the WebTransport session with an Application Error Code of 0 and Application Error Message of "".

5.9. 環境設定

dictionary `WebTransportHash@I {
  `DOMString$ `algorithm@mH;
  `BufferSource$I `value@mH;
};

dictionary `WebTransportOptions@I {
  `boolean$ `allowPooling$mb = false;
  `boolean$ `requireUnreliable$mb = false;
  `sequence$<`WebTransportHash$I> `serverCertificateHashes$mb;
  `WebTransportCongestionControl$I `congestionControl$mb = "default";
  [`EnforceRange$] `unsigned short$? `anticipatedConcurrentIncomingUnidirectionalStreams$mb = null;
  [`EnforceRange$] `unsigned short$? `anticipatedConcurrentIncomingBidirectionalStreams$mb = null;
  `sequence$<`DOMString$> `protocols$mb = [];
};

enum `WebTransportCongestionControl@I {
  `default@l,
  `throughput@l,
  `low-latency@l,
};

`WebTransportOptions$I は、［ `~WebTransport~session$がどう確立され，どう利用されるか ］を決定する~parameterたちが成す辞書である。 ◎ WebTransportOptions is a dictionary of parameters that determine how the WebTransport session is established and used.

`allowPooling@mb ◎ allowPooling, of type boolean, defaulting to false

~T に設定されたときは、 当の`~WebTransport~session$を~poolできる — すなわち、 その`下層~接続$は，他の`~WebTransport~session$と共有できるようになる。 ◎ When set to true, the WebTransport session can be pooled, that is, its underlying connection can be shared with other WebTransport sessions.

`requireUnreliable@mb ◎ requireUnreliable, of type boolean, defaulting to false

~T に設定されたときは、 次を行えなくなる ⇒ ~HTTP3`接続$がアリでない場合に， `~WebTransport~session$を~HTTP2`接続$越しに確立する ◎ When set to true, the WebTransport session cannot be established over an HTTP/2 connection if an HTTP/3 connection is not possible.

`serverCertificateHashes@mb ◎ serverCertificateHashes, of type sequence<WebTransportHash>

この~optionは、 専用な接続を利用している~transport用に限り~supportされる。 ◎ This option is only supported for transports using dedicated connections.＼

~UAは、 次に従うモノトスル — 以下における %~hash群 は、 この~fieldに与えた値を表すとする：

• ［ ~transport~protocolが この特能を~supportしない ］~AND［ %~hash群 は空でない ］場合、 `NotSupportedError$E 例外を投出する。

• ［ ~transport~protocolが この特能を~supportする ］~AND［ %~hash群 は空でない ］場合、 ~server証明書は，［ ~AND↓ が満たされる場合，その場合に限り ］信用されるものと判断する：

  • 次の結果 ~EQ ~T ⇒ `証明書~hashを検証yする$( 当の証明書, %~hash群 )
  • 当の証明書は`~custom証明書~要件$を満足する
• %~hash群 を成す各~hashのうち未知な `algorithm$mH を利用するものは無視する。
• %~hash群 は空な場合、 通常の`~fetchする$ 演算~用に利用することになる証明書~検証y手続-を利用する。

◎ For transport protocols that do not support this feature, having this field non-empty SHALL result in a NotSupportedError exception being thrown. ◎ If supported and non-empty, the user agent SHALL deem a server certificate trusted if and only if it can successfully verify a certificate hash against serverCertificateHashes and satisfies custom certificate requirements. The user agent SHALL ignore any hash that uses an unknown algorithm. If empty, the user agent SHALL use certificate verification procedures it would use for normal fetch operations.

これは、 `allowPooling$mb と伴には利用できない。 ◎ This cannot be used with allowPooling.

`congestionControl@mb ◎ congestionControl, of type WebTransportCongestionControl, defaulting to "default"

任意選択で， 次に関する応用の選好を指定する ⇒ ［ ~throughputまたは短い待時間 ］用に調律された輻輳~制御~algoであって， この接続~越しに~dataを送信するとき利用されるもの。 ◎ Optionally specifies an application’s preference for a congestion control algorithm tuned for either throughput or low-latency to be used when sending data over this connection.＼

これは、 ~UA向けの~hintである。 ◎ This is a hint to the user agent.

この環境設定~optionは、 ~browserにおける［ 短い待時間~用に最適化する輻輳~制御~algo ］用の実装の欠如に因り，~risk下にある特能と見なされる — これを書いた時点では。 ◎ This configuration option is considered a feature at risk due to the lack of implementation in browsers of a congestion control algorithm, at the time of writing, that optimizes for low latency.

`anticipatedConcurrentIncomingUnidirectionalStreams@mb ◎ anticipatedConcurrentIncomingUnidirectionalStreams, of type unsigned short, nullable, defaulting to null

［ 同時並行に~openな，`流入~一方向$な~streamたち ］として［ ~serverが作成するものと応用が見越す個数 ］を応用が任意選択で指定できるようにする。 ◎ Optionally lets an application specify the number of concurrently open incoming unidirectional streams it anticipates the server creating.＼

~UAは、 初期~時は， ~serverからの`流入~一方向$な~streamを 100 個以上は許容するモノトスル。 ◎ The user agent MUST initially allow at least 100 incoming unidirectional streams from the server.＼

~NULL でない場合、 ~UAは，［ 自身と~serverとの折衝において `AnticipatedConcurrentIncomingUnidirectionalStreams$sl を考慮に入れる ］ことにより［ 未来の往復-数を抑制するよう試みる ］ベキである。 ◎ If not null, the user agent SHOULD attempt to reduce round-trips by taking [[AnticipatedConcurrentIncomingUnidirectionalStreams]] into consideration in its negotiations with the server.

`anticipatedConcurrentIncomingBidirectionalStreams@mb ◎ anticipatedConcurrentIncomingBidirectionalStreams, of type unsigned short, nullable, defaulting to null

［ 同時並行に~openな，`双方向$な~streamたち ］として［ ~serverが作成するものと応用が見越す個数 ］を応用が任意選択で指定できるようにする。 ◎ Optionally lets an application specify the number of concurrently open bidirectional streams it anticipates a server creating.＼

~UAは、 初期~時は， ~serverが作成する`双方向$な~streamとして 100 個以上は許容するモノトスル。 ◎ The user agent MUST initially allow the server to create at least 100 bidirectional streams.＼

~NULL でない場合、 ~UAは，［ 自身と~serverとの折衝において `AnticipatedConcurrentIncomingBidirectionalStreams$sl を考慮に入れる ］ことにより［ 未来の往復-数を抑制するよう試みる ］ベキである。 ◎ If not null, the user agent SHOULD attempt to reduce round-trips by taking [[AnticipatedConcurrentIncomingBidirectionalStreams]] into consideration in its negotiations with the server.

`protocols@mb ◎ protocols, of type sequence<DOMString>, defaulting to []

応用~levelの `~protocol名@ たちが成す連列 — 省略可能。 ◎ An optionally provided array of application-level protocol names.＼

【空でない場合】 当の接続は、 次が生じた場合に限り，確立されることになる ⇒ ~serverは、［ これらが指示する応用~levelの~protocolのうちいずれか ］を選定して，それを【~clientへ】報告した。 ◎ The connection will only be established if the server reports that it has selected one of these application-level protocols.

`~custom証明書~要件@ は、 次に従うモノトスル： ◎ The custom certificate requirements are as follows:＼

• 当の証明書は、 `RFC5280$r にて定義されるとおり X.509v3 証明書である。 ◎ the certificate MUST be an X.509v3 certificate as defined in [RFC5280],＼
• `Subject Public Key^en ~field内に利用される~keyは、 いずれかの`許容される公開鍵~algo$である。 ◎ the key used in the Subject Public Key field MUST be one of the allowed public key algorithms,＼
• 現在の時刻は、 `RFC5280$r § 4.1.2.5 にて定義されるとおり， 証明書の妥当性~期間（ `validity period^en ）の中にある。 ◎ the current time MUST be within the validity period of the certificate as defined in Section 4.1.2.5 of [RFC5280]＼
• 妥当性~期間を成す総-長さは、 2 週間を超過しない。 ◎ and the total length of the validity period MUST NOT exceed two weeks.＼

~UAは、 当の証明書に対し，追加的な［ `実装定義$な要件 ］を課してもヨイ。 ◎ The user agent MAY impose additional implementation-defined requirements on the certificate.

`Subject Public Key Info^en ~field内 （したがって、 その帰結として， `TLS CertificateVerify^en ~message内） に利用される `許容される公開鍵~algo@ たちが成す正確な~listは、 `実装定義$とする — しかしながら、 それは： ◎ The exact list of allowed public key algorithms used in the Subject Public Key Info field (and, as a consequence, in the TLS CertificateVerify message) is implementation-defined; however,＼

• 相互運用可能な既定を供するためとして、 `ECDSA with the secp256r1 (NIST P-256) named group^en （ `RFC3279$r § 2.3.5, `RFC8422$r ） を含むモノトスル。 ◎ it MUST include ECDSA with the secp256r1 (NIST P-256) named group ([RFC3279], Section 2.3.5; [RFC8422]) to provide an interoperable default.＼
• ~RSA鍵（ `RFC3279$r, § 2.3.1 ）を包含しないモノトスル。 ◎ It MUST NOT contain RSA keys ([RFC3279], Section 2.3.1).

5.10. `WebTransportCloseInfo^I 辞書

`WebTransportCloseInfo$I 辞書は、 `WebTransport$I を~closeする際の~error~codeに関係している情報を含む。 この情報は、 `CONNECTION_CLOSE^ft ~frame用に［ ~error~code, 事由 ］を設定するために利用される。 ◎ The WebTransportCloseInfo dictionary includes information relating to the error code for closing a WebTransport. This information is used to set the error code and reason for a CONNECTION_CLOSE frame.

dictionary `WebTransportCloseInfo@I {
  `unsigned long$ `closeCode$mb = 0;
  `USVString$ `reason$mb = "";
};

この辞書が有する~memberは： ◎ The dictionary SHALL have the following attributes:

`closeCode@mb ◎ closeCode, of type unsigned long, defaulting to 0

相手の端点へ通信される~error~code。 ◎ The error code communicated to the peer.

`reason@mb ◎ reason, of type USVString, defaulting to ""

`WebTransport$I を~closeする際の事由。 ◎ The reason for closing the WebTransport.

5.11. `WebTransportSendStreamOptions^I 辞書

`WebTransportSendStreamOptions$I は、［ `createUnidirectionalStream()$mT ／ `createBidirectionalStream()$mT ］により作成された `WebTransportSendStream$I — 以下 %~stream と記す — がどう挙動するかに影響する~parameterたちが成す辞書である。 ◎ The WebTransportSendStreamOptions is a dictionary of parameters that affect how WebTransportSendStreams created by createUnidirectionalStream and createBidirectionalStream behave.

dictionary `WebTransportSendStreamOptions@I {
  `WebTransportSendGroup$I? `sendGroup$mb = null;
  `long long$ `sendOrder$mb = 0;
  `boolean$ `waitUntilAvailable$mb = false;
};

この辞書が有する~memberは： ◎ The dictionary SHALL have the following attributes:

`sendGroup@mb ◎ sendGroup, of type WebTransportSendGroup, nullable, defaulting to null

~NULL （既定）／ ある `WebTransportSendGroup$I ◎ ↓

~NULL でない場合、 %~stream は，それが表現する`送信-~group$に属する。 ◎ An optional WebTransportSendGroup to group this WebTransportSendStream under, or null.

`sendOrder@mb ◎ sendOrder, of type long long, defaulting to 0

%~stream に与える送信-順序~番号（既定は 0 ） ◎ A send order number that,＼

各 `WebTransportSendStream$I のうち：

• 送信-順序~番号が供されたものは、 `厳密な順序付け@ に関与するようになり【！opts】、 それらに~queueされた~byte列は， 送信-順序~番号が高いものほど先に送信されることになる。
• 送信-順序~番号が供されないものは、［ それと他の `WebTransportSendStream$I ］から~UAが送信する~byte列どうしの相対的な送信-順序は`実装定義$になる。

【 `sendOrder$mb の既定~値は，更新により ~NULL から 0 に改められたため、 上の条件が明示的に 0 を供した場合と省略した場合を区別するのかどうか不明瞭になっている。 】

◎ if provided, opts the created WebTransportSendStream in to participating in strict ordering. Bytes currently queued on strictly ordered WebTransportSendStreams will be sent ahead of bytes currently queued on other strictly ordered WebTransportSendStreams created with lower send order numbers. ◎ If no send order number is provided, then the order in which the user agent sends bytes from it relative to other WebTransportSendStreams is implementation-defined.＼

しかしながら，~UAには、 すべての~streamのうち［ より低い送信-順序~番号により後回されないもの ］の間で帯域幅を公平に分合うことが強く奨励される。 ◎ User agents are strongly encouraged however to divide bandwidth fairly between all streams that aren’t starved by lower send order numbers.

注記： これは、 送信者~側における~dataの優先度化であり， 受信される順序を保証するものではない。 ◎ Note: This is sender-side data prioritization which does not guarantee reception order.

`waitUntilAvailable@mb ◎ waitUntilAvailable, of type boolean, defaulting to false

［ `createUnidirectionalStream()$mT ／ `createBidirectionalStream()$mT ］~callにより返される~promiseは、 この~memberの値に応じて：

• ~T の場合 ⇒ `下層~接続$が次に挙げる いずれかの状態に達しない限り，`決着しない＠~ECMA262#sec-promise-objects$ことになる ⇒＃ ~streamを作成するために足る~flow制御~creditを有する／ 更なる流出~streamを作成することはアリでない
• ~F の場合 ⇒ ~callした時点で可用な~flow制御~窓が無い場合には、 `却下される＠~ECMA262#sec-promise-objects$ことになる。 ◎ If true, the promise returned by the createUnidirectionalStream or createBidirectionalStream call will not be settled until either the underlying connection has sufficient flow control credit to create the stream, or the connection reaches a state in which no further outgoing streams are possible. If false, the promise will be rejected if no flow control window is available at the time of the call.

5.12. `WebTransportConnectionStats^I 辞書

`WebTransportConnectionStats$I 辞書は、 `~WebTransport~session$の`下層~接続$についての~WebTransportに特有な統計を含む。 ◎ The WebTransportConnectionStats dictionary includes information on WebTransport-specific stats about the WebTransport session's underlying connection.

注記： ~pool法が利用されるとき，同じ`接続$に~poolされた複数の`~WebTransport~session$は、 すべて同じ情報を受信する — すなわち、 当の情報は、［ ~poolされた`~WebTransport~session$たちのうち，同じ`~network区分~key$を保持しているもの ］にまたがって開示される。 ◎ Note: When pooling is used, multiple WebTransport sessions pooled on the same connection all receive the same information, i.e. the information is disclosed across pooled sessions holding the same network partition key.

注記： 各種~統計のうち可用でないものは、 `WebTransportConnectionStats$I 辞書~内には`包含され＠~INFRA#map-exists$ない。 ◎ Note: Any unavailable stats will be absent from the WebTransportConnectionStats dictionary.

dictionary `WebTransportConnectionStats@I {
  `unsigned long long$ `bytesSent$mb = 0;
  `unsigned long long$ `packetsSent$mb = 0;
  `unsigned long long$ `bytesLost$mb = 0;
  `unsigned long long$ `packetsLost$mb = 0;
  `unsigned long long$ `bytesReceived$mb = 0;
  `unsigned long long$ `packetsReceived$mb = 0;
  required `DOMHighResTimeStamp$ `smoothedRtt$mb;
  required `DOMHighResTimeStamp$ `rttVariation$mb;
  required `DOMHighResTimeStamp$ `minRtt$mb;
  required `WebTransportDatagramStats$I `datagrams$mb;
  required `unsigned long long$? `estimatedSendRate$mb = null;
  `boolean$ `atSendCapacity$mb = false;
};

この辞書が有する~memberは： ◎ The dictionary SHALL have the following attributes:

`bytesSent@mb ◎ bytesSent, of type unsigned long long, defaulting to 0

当の`下層~接続$上に送信された~byteたちの個数 — 再-伝送も含むが，［ ~UDPその他の外縁~frame法 ］は含まない。 ◎ The number of bytes sent on the underlying connection, including retransmissions. Does not include UDP or any other outer framing.

`packetsSent@mb ◎ packetsSent, of type unsigned long long, defaulting to 0

当の`下層~接続$上に送信された~packetの個数 — 喪失したものと決定されたものも含む。 ◎ The number of packets sent on the underlying connection, including those that are determined to have been lost.

`bytesLost@mb ◎ bytesLost, of type unsigned long long, defaulting to 0

当の`下層~接続$上で喪失した~byteたちの個数 （単調増加しない — 喪失したものと宣言された~packetは，後続に受信され得るので） — 再-伝送も含むが，［ ~UDPその他の外縁~frame法 ］は含まない。 ◎ The number of bytes lost on the underlying connection (does not monotonically increase, because packets that are declared lost can subsequently be received). Does not include UDP or any other outer framing.

`packetsLost@mb ◎ packetsLost, of type unsigned long long, defaulting to 0

当の`下層~接続$上で喪失した~packetの個数 （単調増加しない — 喪失したものと宣言された~packetは，後続に受信され得るので）。 ◎ The number of packets lost on the underlying connection (does not monotonically increase, because packets that are declared lost can subsequently be received).

`bytesReceived@mb ◎ bytesReceived, of type unsigned long long, defaulting to 0

当の`下層~接続$上で受信された総-~byte数 — ［ 各~stream用に重複した~data ］も含むが，［ ~UDPその他の外縁~frame法 ］は含まない。 ◎ The number of total bytes received on the underlying connection, including duplicate data for streams. Does not include UDP or any other outer framing.

`packetsReceived@mb ◎ packetsReceived, of type unsigned long long

当の`下層~接続$上で受信された総-~packet数 — 処理-可能でなかった~packetも含む。 ◎ The number of total packets received on the underlying connection, including packets that were not processable.

`smoothedRtt@mb ◎ smoothedRtt, of type DOMHighResTimeStamp

当の接続~上で現在に観測された `smoothed^en 往復-時間【 `smoothed_rtt^c 】 — `RFC9002$r `§ 5.3＠~RFCx/rfc9002#section-5.3$ にて定義されるとおり。 ◎ The smoothed round-trip time (RTT) currently observed on the connection, as defined in [RFC9002] Section 5.3.

`rttVariation@mb ◎ rttVariation, of type DOMHighResTimeStamp

接続~上で現在に観測された［ 往復-時間 標本 ］たちの平均~変動【 `rttvar^c 】 — `RFC9002$r `§ 5.3＠~RFCx/rfc9002#section-5.3$ にて定義されるとおり。 ◎ The mean variation in round-trip time samples currently observed on the connection, as defined in [RFC9002] Section 5.3.

`minRtt@mb ◎ minRtt, of type DOMHighResTimeStamp

接続~全体~上で観測された最小な往復-時間。 【 `min_rtt^c — `RFC9002$r `§ 5.2＠~RFCx/rfc9002#section-5.2$】 ◎ The minimum round-trip time observed on the entire connection.

`estimatedSendRate@mb ◎ estimatedSendRate, of type unsigned long long, nullable, defaulting to null

［ ~UAが~queueされた~dataを送信することになる~rate ］として見積もられた毎秒あたりの~bit数。 この~rateは、 `~WebTransport~session$を共有するすべての［ ~stream, ~datagram ］に適用され， 輻輳~制御~algo （ `congestionControl$mT により選ばれるそれにもなり得る） により計算される。 ~UAが現在の見積もりを有さない場合、 この~memberの値は， ~NULL にするモノトスル。 この~memberは、 以前の結果では ~NULL でなかった場合でも， ~NULL になり得る。 ◎ The estimated rate at which queued data will be sent by the user agent, in bits per second. This rate applies to all streams and datagrams that share a WebTransport session and is calculated by the congestion control algorithm (potentially chosen by congestionControl). If the user agent does not currently have an estimate, the member MUST be the null value. The member can be null even if it was not null in previous results.

`atSendCapacity@mb ◎ atSendCapacity, of type boolean, defaulting to false

値 ~F は、 `estimatedSendRate$mb は，応用により制限された — すなわち、 当の応用が送信している~dataは，輻輳~制御器が許容するよりも有意に少ない — かもしれないことを指示する。 その間は、［ 輻輳~制御器は，可用な~network容量として拙い見積もりを生産する ］かもしれない。 ◎ A value of false indicates the estimatedSendRate might be application limited, meaning the application is sending significantly less data than the congestion controller allows. A congestion controller might produce a poor estimate of the available network capacity while it is application limited.

値 ~T は、［ 当の応用は，~dataを~network容量ぎりぎりまで送信している ］ので［ `estimatedSendRate$mb は，応用に可用な~network容量を反映する ］ことを指示する。 ◎ A value of true indicates the application is sending data at network capacity, and the estimatedSendRate reflects the network capacity available to the application.

注記： `estimatedSendRate$mb は、 `atSendCapacity$mb が ~T をとる間は［ 応用の送信-~rateが支続される限り，~network条件に順応するよう天井を反映する ］ことになる — しかしながら、 その間でも ~NULL になることは許容される。 ◎ When atSendCapacity is true, the estimatedSendRate reflects a ceiling. As long as the application send rate is sustained, the estimatedSendRate will adapt to network conditions. However, estimatedSendRate is allowed to be null while atSendCapacity is true.

`datagrams@mb ◎

【 この~memberについては、 原文には何も述べられていない。 】

5.13. `WebTransportDatagramStats^I 辞書

`WebTransportDatagramStats$I 辞書は、 `下層~接続$越しの~datagram伝送~上の統計を含む。 ◎ The WebTransportDatagramStats dictionary includes statistics on datagram transmission over the underlying connection.

dictionary `WebTransportDatagramStats@I {
  `unsigned long long$ `droppedIncoming$mbD = 0;
  `unsigned long long$ `expiredIncoming$mbD = 0;
  `unsigned long long$ `expiredOutgoing$mbD = 0;
  `unsigned long long$ `lostOutgoing$mbD = 0;
};

この辞書が有する~memberは： ◎ The dictionary SHALL have the following attributes:

`droppedIncoming@mbD ◎ droppedIncoming, of type unsigned long long, defaulting to 0

流入~datagramのうち，次に該当するものの個数 ⇒ 応用が `datagrams$mT の `readable$mD から読取る前に受信-~queueを~overflowしたことに因り，落とされた ◎ The number of incoming datagrams that were dropped due to the application not reading from datagrams' readable before new datagrams overflow the receive queue.

`expiredIncoming@mbD ◎ expiredIncoming, of type unsigned long long, defaulting to 0

流入~datagramのうち，次に該当するものの個数 ⇒ `incomingMaxAge$mD より旧くなったことに因り， 応用が `datagrams$mT の `readable$mD から読取る前に落とされた ◎ The number of incoming datagrams that were dropped due to being older than incomingMaxAge before they were read from datagrams' readable.

`expiredOutgoing@mbD ◎ expiredOutgoing, of type unsigned long long, defaulting to 0

送信~用に~queueされた~datagramのうち，次に該当するものの個数 ⇒ `outgoingMaxAge$mD より旧くなったことに因り，送信-可能になる前に落とされた ◎ The number of datagrams queued for sending that were dropped due to being older than outgoingMaxAge before they were able to be sent.

`lostOutgoing@mbD ◎ lostOutgoing, of type unsigned long long, defaulting to 0

送信した~datagramのうち，次に該当するものの個数 ⇒ `RFC9002$r `§ 6.1＠~RFCx/rfc9002#section-6.1$ にて定義されるおり， 喪失したものと宣言された ◎ The number of sent datagrams that were declared lost, as defined in [RFC9002] Section 6.1.

6.1. 属性

`sendGroup@mS ◎ sendGroup, of type WebTransportSendGroup, nullable

取得子~手続きは ⇒ ~RET コレの `SendGroup$slS ◎ The getter steps are: • Return this's [[SendGroup]].

設定子~手続きは、 `所与の値$ %値 に対し： ◎ The setter steps, given value, are:

1. ~IF［ %値 ~NEQ ~NULL ］~AND［ %値 . `Transport$slG ~NEQ コレ . `Transport$slS ］ ⇒ ~THROW `InvalidStateError$E ◎ If value is non-null, and value.[[Transport]] is not this.[[Transport]], throw an InvalidStateError.
2. コレ . `SendGroup$slS ~SET %値 ◎ Set this.[[SendGroup]] to value.

`sendOrder@mS ◎ sendOrder, of type long long, nullable

取得子~手続きは ⇒ ~RET コレ . `SendOrder$slS ◎ The getter steps are: • Return this's [[SendOrder]].

設定子~手続きは、 `所与の値$ %値 に対し ⇒ コレ . `SendOrder$slS ~SET %値 ◎ The setter steps, given value, are: • Set this.[[SendOrder]] to value.

6.2. ~method

`getStats()@mS ◎ getStats()

この `WebTransportSendStream$I の処理能に特有な統計を集めて， その結果を非同期的に報告する。 ◎ Gathers stats specific to this WebTransportSendStream's performance, and reports the result asynchronously.

~method手続きは： ◎ When getStats is called, the user agent MUST run the following steps:

1. %~promise ~LET `新たな~promise$ ◎ Let p be a new promise.

2. この段は`並列的$に走らす： ◎ Run the following steps in parallel:

   1. コレ【！この `WebTransportSendStream$I】に特有な統計を集める ◎ Gather the stats specific to this WebTransportSendStream.

   2. `~network~taskを~queueする$( %~transport, 次の手続き ) ◎ Queue a network task with transport to＼

      手続きは： ◎ run the following steps:

      1. %統計 ~LET `新たな$ `WebTransportSendStreamStats$I ~obj ◎ Let stats be a new WebTransportSendStreamStats object＼
      2. %統計 の各~memberを集められた統計を表現するよう設定する ◎ representing the gathered stats.
      3. `~promiseを解決する$( %~promise, %統計 ) ◎ Resolve p with stats.
3. ~RET %~promise ◎ Return p.

`getWriter()@mS

この~methodは、 `WritableStream$I から継承した `getWriter()$ws と同じ方式で実装するモノトスル — ただし、 `WritableStreamDefaultWriter$I を作成する所では， 代わりに `WebTransportWriter$I を`作成する$TWモノトスル。 ◎ This method must be implemented in the same manner as getWriter inherited from WritableStream, except in place of creating a WritableStreamDefaultWriter, it must instead create a WebTransportWriter with this.

6.3. 内部~slot

各 `WebTransportSendStream$I は、 次に挙げる内部~slotを有する — 各項に与える記述は規範的ではない： ◎ A WebTransportSendStream has the following internal slots. ◎ Internal Slot｜Description (non-normative)

`InternalStream@slS

［ `流出~一方向$／`双方向$ ］な`~WebTransport~stream$ ◎ An outgoing unidirectional or bidirectional WebTransport stream.

`PendingOperation@slS

~NULL ／ 処理待ちな［ 書込n／~close ］演算を表現している~promise ◎ A promise representing a pending write or close operation, or null.

`Transport@slS

この `WebTransportSendStream$I を所有する `WebTransport$I ◎ A WebTransport which owns this WebTransportSendStream.

`SendGroup@slS

~NULL （既定）／ ある `WebTransportSendGroup$I ◎ An optional WebTransportSendGroup, or null.

`SendOrder@slS

送信-順序~番号 （既定は 0 ） ◎ An optional send order number, defaulting to 0.

`AtomicWriteRequests@slS

~promiseたちが成す`有順序~集合$ — これは、［ `下層~sink$が処理するものとして~queueされた書込n要請のうち，不可分（ `atomic^en ）なもの ］たちが成す下位集合を追跡し続ける。 ◎ An ordered set of promises, keeping track of the subset of write requests that are atomic among those queued to be processed by the underlying sink.

6.4. 手続-

6.5. ~serverから来ている `STOP_SENDING^ft 通達

6.6. `WebTransportSendStreamStats^I 辞書

`WebTransportSendStreamStats$I 辞書は、 ある `WebTransportSendStream$I に特有な統計の情報を含む。 ◎ The WebTransportSendStreamStats dictionary includes information on stats specific to one WebTransportSendStream.

dictionary `WebTransportSendStreamStats@I {
  `unsigned long long$ `bytesWritten$mbS = 0;
  `unsigned long long$ `bytesSent$mbS = 0;
  `unsigned long long$ `bytesAcknowledged$mbS = 0;
};

この辞書が有する~memberは： ◎ The dictionary SHALL have the following attributes:

`bytesWritten@mbS ◎ bytesWritten, of type unsigned long long, defaulting to 0

当の応用が この `WebTransportSendStream$I に成功裡に書込んだ総~byte数。 この数は、 決して減少しない。 ◎ The total number of bytes the application has successfully written to this WebTransportSendStream. This number can only increase.

`bytesSent@mbS ◎ bytesSent, of type unsigned long long, defaulting to 0

当の応用が この `WebTransportSendStream$I に書込んだ~byte列のうち， 何~byteが一回以上~送信されたかを指示する。 この数は、 決して減少しないことに加え， 常に `bytesWritten$mbS 以下になる。 ◎ An indicator of progress on how many of the application bytes written to this WebTransportSendStream has been sent at least once. This number can only increase, and is always less than or equal to bytesWritten.

注記： この進捗は、 単独の~streamに送信された応用~dataに限られ， ~network~overheadを含まない。 ◎ Note: this is progress of app data sent on a single stream only, and does not include any network overhead.

`bytesAcknowledged@mbS ◎ bytesAcknowledged, of type unsigned long long, defaulting to 0

当の応用が この `WebTransportSendStream$I に書込んだ~byte列のうち， 何~byteが［ 送信され、 ~serverにより受信されるに伴い，~QUICの~ACK用の仕組みを利用して認知されたか ］を指示する。 数えられるのは、［ 認知されなかった最初の~byte ］の直前までに限られる。 この数は、 決して減少しないことに加え， 常に `bytesSent$mbS 以下になる。 ◎ An indicator of progress on how many of the application bytes written to this WebTransportSendStream have been sent and acknowledged as received by the server using QUIC’s ACK mechanism. Only sequential bytes up to, but not including, the first non-acknowledged byte, are counted. This number can only increase and is always less than or equal to bytesSent.

注記： この値は、 ~HTTP2越しの接続においては， `bytesSent$mbS に合致することになる。 ◎ Note: This value will match bytesSent when the connection is over HTTP/2.

7.1. ~method

`getStats()@mG

この`送信-~group$に属するすべての `WebTransportSendStream$I からの統計を集成して， その結果を非同期的に報告する。 ◎ Aggregates stats from all WebTransportSendStreams grouped under this sendGroup, and reports the result asynchronously.

~method手続きは： ◎ When getStats is called, the user agent MUST run the following steps:

1. %p ~LET `新たな~promise$ ◎ Let p be a new promise.
2. %~stream群 ~LET 次を満たす すべての `WebTransportSendStream$I たちが成す集合 ⇒ その `SendGroup$slS ~EQ コレ ◎ Let streams be all WebTransportSendStreams whose [[SendGroup]] is this.

3. この段は`並列的$に走らす： ◎ Run the following steps in parallel:

   1. %統計~data ~LET %~stream群 を成す すべての~streamから~stream統計を集めて集成された~data ◎ Gather stream statistics from all streams in streams.

   2. `~network~taskを~queueする$( %~transport, 次の手続き ) ◎ Queue a network task with transport to＼

      手続きは： ◎ run the following steps:

      1. %統計 ~LET %統計~data を表現している`新たな$ `WebTransportSendStreamStats$I ~obj ◎ Let stats be a new WebTransportSendStreamStats object representing the aggregate numbers of the gathered stats.
      2. `~promiseを解決する$( %p, %統計 ) ◎ Resolve p with stats.
4. ~RET %p ◎ Return p.

7.2. 内部~slot

各 `WebTransportSendGroup$I は、 次に挙げる内部~slotを有する — 各項に与える記述は規範的ではない： ◎ A WebTransportSendGroup has the following internal slots. ◎ Internal Slot｜Description (non-normative)

`Transport@slG

この `WebTransportSendGroup$I を所有している `WebTransport$I ~obj ◎ [[Transport]] The WebTransport object owning this WebTransportSendGroup.

7.3. 手続-

8.1. ~method

`getStats()@mR ◎ getStats()

この `WebTransportReceiveStream$I の処理能に特有な統計を集めて， その結果を非同期的に報告する。 ◎ Gathers stats specific to this WebTransportReceiveStream's performance, and reports the result asynchronously.

~method手続きは： ◎ When getStats is called, the user agent MUST run the following steps:

1. %~promise ~LET `新たな~promise$ ◎ Let p be a new promise.

2. この段は`並列的$に走らす： ◎ Run the following steps in parallel:

   1. コレ【！この `WebTransportReceiveStream$I】に特有な統計を集める ◎ Gather the stats specific to this WebTransportReceiveStream.
   2. 前~段の統計が準備済みになるまで待機する ◎ Wait for the stats to be ready.

   3. `~network~taskを~queueする$( %~transport, 次の手続き ) ◎ Queue a network task with transport to＼

      手続きは： ◎ run the following steps:

      1. %統計 ~LET `新たな$ `WebTransportReceiveStreamStats$I ~obj ◎ Let stats be a new WebTransportReceiveStreamStats object＼
      2. %統計 の各~memberを集められた統計を表現するよう設定する ◎ representing the gathered stats.
      3. `~promiseを解決する$( %~promise, %統計 ) ◎ Resolve p with stats.
3. ~RET %~promise ◎ Return p.

8.2. 内部~slot

各 `WebTransportReceiveStream$I は、 次に挙げる内部~slotを有する — 各項に与える記述は規範的ではない： ◎ A WebTransportReceiveStream has the following internal slots. ◎ Internal Slot｜Description (non-normative)

`InternalStream@slR

［ `流入~一方向$／`双方向$ ］な`~WebTransport~stream$ ◎ An incoming unidirectional or bidirectional WebTransport stream.

`Transport@slR

この `WebTransportReceiveStream$I を所有している `WebTransport$I ~obj ◎ The WebTransport object owning this WebTransportReceiveStream.

8.3. 手続-

8.4. ~serverから来ている `RESET_STREAM^ft 通達

8.5. `WebTransportReceiveStreamStats^I 辞書

`WebTransportReceiveStreamStats$I 辞書は、 ある `WebTransportReceiveStream$I に特有な統計の情報を含む。 ◎ The WebTransportReceiveStreamStats dictionary includes information on stats specific to one WebTransportReceiveStream.

dictionary `WebTransportReceiveStreamStats@I {
  `unsigned long long$ `bytesReceived$mbR = 0;
  `unsigned long long$ `bytesRead$mbR = 0;
};

この辞書が有する~memberは： ◎ The dictionary SHALL have the following attributes:

`bytesReceived@mbR ◎ bytesReceived, of type unsigned long long, defaulting to 0

当の `WebTransportReceiveStream$I 用に意図された~server応用からの~byte列のうち， これまでに何~byteが受信されたかを指示する。 数えられるのは、 最初の欠落な~byteの直前までに限られる。 この数は、 決して減少しない。 ◎ An indicator of progress on how many of the server application’s bytes intended for this WebTransportReceiveStream have been received so far. Only sequential bytes up to, but not including, the first missing byte, are counted. This number can only increase.

注記： この進捗は、 単独の~streamに受信された応用~dataに限られ， ~network~overheadを含まない。 ◎ Note: this is progress of app data received on a single stream only, and does not include any network overhead.

`bytesRead@mbR ◎ bytesRead, of type unsigned long long, defaulting to 0

当の応用が，この `WebTransportReceiveStream$I から成功裡に読取った総-~byte数。 この数は、 決して減少しないことに加え， 常に `bytesReceived$mbR 以下になる。 ◎ The total number of bytes the application has successfully read from this WebTransportReceiveStream. This number can only increase, and is always less than or equal to bytesReceived.

9.1. 内部~slot

各 `WebTransportBidirectionalStream$I は、 次に挙げる内部~slotを有する — 各項に与える記述は規範的ではない： ◎ A WebTransportBidirectionalStream has the following internal slots. ◎ Internal Slot｜Description (non-normative)

`Readable@slB

ある `WebTransportReceiveStream$I ◎ A WebTransportReceiveStream.

`Writable@slB

ある `WebTransportSendStream$I ◎ A WebTransportSendStream.

`Transport@slB

この `WebTransportBidirectionalStream$I を所有している `WebTransport$I ~obj ◎ The WebTransport object owning this WebTransportBidirectionalStream.

9.2. 属性

`readable@mB ◎ readable, of type WebTransportReceiveStream, readonly

取得子~手続きは ⇒ ~RET コレ . `Readable$slB ◎ The getter steps are to return this's [[Readable]].

`writable@mB ◎ writable, of type WebTransportSendStream, readonly

取得子~手続きは ⇒ ~RET コレ . `Writable$slB ◎ The getter steps are to return this's [[Writable]].

9.3. 手続-

10.1. ~method

`atomicWrite(chunk)@dw

この~method【が返す~promise】は、［ 送信~時点における現在の~flow制御~窓 ］の中で %chunk 全体を送信できなかった場合には，却下されることになる。 この挙動は、［ `~flow制御$の~deadlockに敏感な，~dataを不可分的（ `transactional^en ）に送信する~~限定的な応用 ］を満足するために設計された （ `RFC9308$r `§ 4.4＠~RFCx/rfc9308#section-4.4$ ）。 ◎ The atomicWrite method will reject if the chunk given to it could not be sent in its entirety within the flow control window that is current at the time of sending. This behavior is designed to satisfy niche transactional applications sensitive to flow control deadlocks ([RFC9308] Section 4.4).

注記： この~methodは、 送信~後であっても，一部の~dataを却下し得る。 それは、 ~flow制御に関する不可分~性を供するが，他の~errorも生じ得る。 この~methodは、 ~dataが［ 複数の~packetに分割される／他の~dataと前後する ］ことを防止しない。 この~methodが可用な~flow制御~creditの欠如に因り失敗するか否かを知れるのは、 送信者に限られる。 ◎ Note: atomicWrite can still reject after sending some data. Though it provides atomicity with respect to flow control, other errors may occur. atomicWrite does not prevent data from being split between packets or being interleaved with other data. Only the sender learns if atomicWrite fails due to lack of available flow control credit.

注記： 不可分な書込nは、 不可分でない書込nに~~後続して~queueされた場合には，依然として阻まれる。 不可分な書込nが却下された場合、 その時点で それに~~後続して~queueされた書込nもすべて却下されることになる。 この仕方で却下された不可分でない書込nは、 当の~streamを`~errorにする$WSことになる。 したがって、 応用には，不可分な書込nを常に待受けることが奨励される。 ◎ Note: Atomic writes can still block if queued behind non-atomic writes. If the atomic write is rejected, everything queued behind it at that moment will be rejected as well. Any non-atomic writes rejected in this way will error the stream. Applications are therefore encouraged to always await atomic writes.

~method手続きは： ◎ When atomicWrite is called, the user agent MUST run the following steps:

1. %p ~LET コレ上の `write$dw 手続き( %chunk ) ◎ Let p be the result of write(chunk) on WritableStreamDefaultWriter with chunk.
2. %~stream . `AtomicWriteRequests$slS に %p を`付加する$set ◎ Append p to stream.[[AtomicWriteRequests]].

3. ~RET `~promiseに反応する$( %p ) — 次を与える下で：

   • `充足~手続き^i は：

     1. %~stream . `AtomicWriteRequests$slS から %p を`除去する$
     2. ~RET `undefined^jv

   • `却下~手続き^i は、 所与の ( 事由 %r ) に対し：

     1. %~stream . `AtomicWriteRequests$slS から %p を`除去する$
     2. ~RET `却下される~promise$( %r )
   ◎ Return the result of reacting to p with the following steps: • If stream.[[AtomicWriteRequests]] contains p, remove p. • If p was rejected with reason r, then return a promise rejected with r. • Return undefined.

10.2. 手続-

11.1. 内部~slot

各 `WebTransportError$I は、 次に挙げる内部~slotを有する — 各項に与える記述は規範的ではない： ◎ A WebTransportError has the following internal slots. ◎ Internal Slot｜Description (non-normative)

`Source@sl

ある `WebTransportErrorSource$I — この~errorの~sourceを指示する。 ◎ A WebTransportErrorSource indicating the source of this error.

`StreamErrorCode@sl

~NULL ／ この~error用の応用~protocol~error~code ◎ The application protocol error code for this error, or null.

11.2. 構築子

11.3. 属性

`source@mE ◎ source, of type WebTransportErrorSource, readonly

取得子~手続きは ⇒ ~RET コレ . `Source$sl ◎ The getter steps are to return this's [[Source]].

`streamErrorCode@mE ◎ streamErrorCode, of type unsigned long, readonly, nullable

取得子~手続きは ⇒ ~RET コレ . `StreamErrorCode$sl ◎ The getter steps are to return this's [[StreamErrorCode]].

11.4. 直列化

`WebTransportError$I ~objは`直列化-可能$である — その： ◎ WebTransportError objects are serializable objects.＼

• その`直列化~手続き$は、 所与の ( %値, %直列形 ) に対し： ◎ Their serialization steps, given value and serialized, are:

  1. `DOMException$I 用の`直列化~手続き$( %値, %直列形 ) ◎ Run the DOMException serialization steps given value and serialized.
  2. %直列形 . `Source^sl ~SET %値 . `Source$sl ◎ Set serialized.[[Source]] to value.[[Source]].
  3. %直列形 . `StreamErrorCode^sl ~SET %値 . `StreamErrorCode$sl ◎ Set serialized.[[StreamErrorCode]] to value.[[StreamErrorCode]].

• その`逆直列化~手続き$は、 所与の ( %直列形, %値 ) に対し： ◎ Their deserialization steps, given serialized and value, are:

  1. `DOMException$I 用の`逆直列化~手続き$( %直列形, %値 ) ◎ Run the DOMException deserialization steps given serialized and value.
  2. %値 . `Source$sl ~SET %直列形 . `Source^sl ◎ Set value.[[Source]] to serialized.[[Source]].
  3. %値 . `StreamErrorCode$sl ~SET %直列形 . `StreamErrorCode^sl ◎ Set value.[[StreamErrorCode]] serialized.[[StreamErrorCode]].

13.1. 通信の機密性

通信が場を占めている事実は、 ~networkを観測できる敵対者たちからは隠せないので， 公な情報とみなされる。 ◎ The fact that communication is taking place cannot be hidden from adversaries that can observe the network, so this has to be regarded as public information.

この文書~内で述べた~transport~protocolを成すすべては，［ ~TLS `RFC8446$r またはそれと意味論的に等価な~protocol ］を利用するので、 ~TLSを成すすべての~security~propを供する — 流通の［ 機密性と完全性 ］も含めて。 ~HTTP越しの~WebTransportは，`外方＠~HTTPinfra#outbound$への~HTTP要請と同じ［ 証明書~検証y用の仕組み ］を利用するので、 ~remote~serverへの認証は，同じ公開鍵~基盤に依拠している。 ~WebTransportにおいては、 証明書~検証yにおける~errorは致命的であり，［ 証明書~検証を迂回することを許容する抜道 ］として可用なものは無い。 ◎ All of the transport protocols described in this document use either TLS [RFC8446] or a semantically equivalent protocol, thus providing all of the security properties of TLS, including confidentiality and integrity of the traffic. WebTransport over HTTP uses the same certificate verification mechanism as outbound HTTP requests, thus relying on the same public key infrastructure for authentication of the remote server. In WebTransport, certificate verification errors are fatal; no interstitial allowing bypassing certificate validation is available.

13.2. 状態の持続性

~WebTransport自体は、 新たな［ 【利用者に】一意な識別子／ 状態を持続的に格納する仕方 ］を作成するものでも， 既存の持続的な状態を~serverに自動的に公開するものでもない。 一例として、 `WEB-TRANSPORT-HTTP3$r, `WEB-TRANSPORT-HTTP2$r は，どちらも［ ~cookieを送信しない／ ~HTTP認証を~supportしない／ ~cache法を無効~化する仕組みは無い ］。 それらは，~TLSを利用するので、 ~TLSにおける持続的な状態 — ~TLS~session~ticketなど — を継承する。 そのような状態は、 受動的な~network観測者からは可視にならないが， ~serverにより［ 同じ~clientからの異なる接続どうしを相関する ］ためにも利用され得る。 ◎ WebTransport does not by itself create any new unique identifiers or new ways to persistently store state, nor does it automatically expose any of the existing persistent state to the server. For instance, neither [WEB-TRANSPORT-HTTP3] nor [WEB-TRANSPORT-HTTP2] send cookies or support HTTP authentication or caching invalidation mechanisms. Since they do use TLS, they inherit TLS persistent state such as TLS session tickets, which while not visible to passive network observers, could be used by the server to correlate different connections from the same client.

13.3. ~protocol~security

~WebTransportは、 `WEB-TRANSPORT-OVERVIEW$r にて述べられる要件の集合を課す — それは、 次に挙げるものを含む： ◎ WebTransport imposes a set of requirements as described in [WEB-TRANSPORT-OVERVIEW], including:

1. ~remote~serverが［ ~WebTransport~protocolが利用-中にあることを自覚する ］ことを確保することに加え、 ~remote~serverには［ ~WebTransport~protocolを利用する用意がある ］ことを確認すること。 `WEB-TRANSPORT-HTTP3$r は、 ~WebTransport~protocolを識別するために［ ~ALPN `RFC7301$r, `~HTTP3設定＠~HTTPv3#setting$, `:protocol^h `疑似-~header＠~HTTPv3#pseudo-header$ ］が成す組合n利用する。 `WEB-TRANSPORT-HTTP2$r は、 ~WebTransport~protocolを識別するために［ ~ALPN `RFC7301$r, ~HTTP2設定, `:protocol^h 疑似-~header ］が成す組合n利用する。 【疑似-~header `:protocol^h は、 ~RFC 8441 に定義される。】 ◎ Ensuring that the remote server is aware that the WebTransport protocol is in use and confirming that the remote server is willing to use the WebTransport protocol. [WEB-TRANSPORT-HTTP3] uses a combination of ALPN [RFC7301], an HTTP/3 setting, and a :protocol pseudo-header to identify the WebTransport protocol. [WEB-TRANSPORT-HTTP2] uses a combination of ALPN, an HTTP/2 setting, and a :protocol pseudo-header to identify the WebTransport protocol.
2. ［ ~transport~sessionを出生した資源 ］の生成元に基づいて，接続を~filterすることを~serverに許容する。 この情報【生成元】は、 ~session確立~要請の `Origin$h ~header~fieldが運ぶ。 ◎ Allowing the server to filter connections based on the origin of the resource originating the transport session. The Origin header field on the session establishment request carries this information.

関係する~protocol~securityの考慮点は、［ `WEB-TRANSPORT-HTTP3$r `§ ~securityの考慮点＠~WT-HTTP3#security-considerations$, `WEB-TRANSPORT-HTTP2$r `§ ~securityの考慮点＠~WT-HTTP2#security-considerations$ ］にて述べられる。 ◎ Protocol security related considerations are described in the Security Considerations sections of [WEB-TRANSPORT-HTTP3] and [WEB-TRANSPORT-HTTP2].

~networking~APIは、 局所~networkで可用な~hostを走査するために共通的に利用され得るので，［ 指紋収集や他の形を成す攻撃 ］に利用される。 ~WebTransportは、 この問題に対し`~WebSocketによる~approach＠~WEBSOCKET#feedback-from-the-protocol$に従う ⇒ 【~WebTransportに】特有な接続~errorは、 端点が~WebTransport端点であることが検証yされるまでは，返されない。 したがって、 ~Web応用は，所与の端点が［ 存在しないのか, ~Webからの接続を受容する用意がないのか ］を判別し得ない。 ◎ Networking APIs can be commonly used to scan the local network for available hosts, and thus be used for fingerprinting and other forms of attacks. WebTransport follows the WebSocket approach to this problem: the specific connection error is not returned until an endpoint is verified to be a WebTransport endpoint; thus, the Web application cannot distinguish between a non-existing endpoint and the endpoint that is not willing to accept connections from the Web.

13.4. 証明書~hash群を利用している認証

~UAは、 通常は，［ 自身 ↔ ~remote端点 ］間の~TLS接続を［ ~URL内の~server名に対し供された~TLS~server証明書 ］の妥当性を検証yすることにより認証する `RFC9525$r 。 これは、 ~server証明書を［ ~UAにより保守される信用-~anchorのうちいずれか ］へ連鎖することにより成遂げられる — 各~信用-~anchorは、 証明書~内の~server名を認証する責務がある。 この~systemは、 以下では，~Web~PKIと称される。 ◎ Normally, a user agent authenticates a TLS connection between itself and a remote endpoint by verifying the validity of the TLS server certificate provided against the server name in the URL [RFC9525]. This is accomplished by chaining server certificates to one of the trust anchors maintained by the user agent; the trust anchors in question are responsible for authenticating the server names in the certificates. We will refer to this system as Web PKI.

この~APIは， ~remote~network端点へ接続する能力を~web応用に供するが、 端点は［ その~server名ではなく，特定の~server証明書 ］により認証される。 この仕組みは、 長期的な証明書を取得するのは難題になり得るような端点 — その資質において短命な~host （例：その場限りの~virtual~machine）や， 公に~route可能でない~hostを含む — への接続を可能化する。 この仕組みは、 個々の接続~用に［ ~Web~PKIに基づく認証 ］を代用するので， 両者の~security~propを比較する必要がある。 ◎ This API provides web applications with a capability to connect to a remote network endpoint authenticated by a specific server certificate, rather than its server name. This mechanism enables connections to endpoints for which getting long-term certificates can be challenging, including hosts that are ephemeral in nature (e.g. short-lived virtual machines), or that are not publicly routable. Since this mechanism substitutes Web PKI-based authentication for an individual connection, we need to compare the security properties of both.

ある~remote~serverが， ~TLS~handshakeを成功裡に遂行-可能になるのは、［ それが，指定された証明書の公開鍵に対応している秘密鍵を所蔵している【！posess】 ］場合に限られる。 この~APIは、 それらの~hashを利用して証明書を識別する。 それが~secureになるのは、［ 利用された暗号用~hash関数が， 第二原像攻撃に対する耐性（ `second-preimage resistance^en ）を有する場合 ］に限られる。 この文書にて定義される関数は，~SHA-256に限られるが、 この~APIは，［ 新たな~hash関数を導入するための仕方 ］を［ 複数個の［ ( ~algo, ~hash ) が成す~pair ］を指定すること ］を許容することを通して供する。 ◎ A remote server will be able to successfully perform a TLS handshake only if it posesses the private key corresponding to the public key of the certificate specified. The API identifies the certificates using their hashes. That is only secure as long as the cryptographic hash function used has second-preimage resistance. The only function defined in this document is SHA-256; the API provides a way to introduce new hash functions through allowing multiple algorithm-hash pairs to be specified.

重要なこととして、 ~Web~PKIは，~security用に追加的な仕組みを供することに注意 — 単純に［ ある~server名に対し信用が成す連鎖を確立する ］ことに加えて。 それらのうち一つに，証明書~廃止の取扱いがある。 利用される証明書が短命である事例では、 そのような仕組みは必要yでない。 他の事例では、 ~Web応用は，証明書~hashを支給するための仕組みを考慮する必要がある — 一例として、 当の~hashが~cacheされた~HTTP資源として供された場合， 当の~cacheは［ 対応している証明書が，弱体化に因り交替された場合 ］には無効~化される必要がある。 ~Web~PKIにより供される別の~security特能は、 鍵~生成に伴われるある種の課題に抗する防護策である — 弱いことが既知な鍵を伴う証明書を却下するなど。 この仕様は，特有な指導を何も供さないが、 各~browserは，実装定義な挙動の一部として それらを却下してもヨイ。 ◎ It is important to note that Web PKI provides additional security mechanisms in addition to simply establishing a chain of trust for a server name. One of them is handling certificate revocation. In cases where the certificate used is ephemeral, such a mechanism is not necessary. In other cases, the Web application has to consider the mechanism by which the certificate hashes are provisioned; for instance, if the hash is provided as a cached HTTP resource, the cache needs to be invalidated if the corresponding certificate has been rotated due to compromise. Another security feature provided by the Web PKI are safeguards against certain issues with key generation, such as rejecting certificates with known weak keys; while this specification does not provide any specific guidance, browsers MAY reject those as a part of implementation-defined behavior.

~Web~PKIは、 各~証明書に対し，失効~期間~要件を施行する。 この要件は、 鍵が弱体化され得る視野を制限することに加え、［ 鍵~交替を~supportして，それを能動的に遂行する ］よう~systemを設計することを~server運用者に強制する。 この理由から、 ~WebTransportも，類似な失効~要件を課す — 証明書は，短命なことが予期されるので、 失効~期間は 2 週間に制限される。 2 週間の期限は、 次に挙げるものの間で~balanceをとった結果である： ◎ Web PKI enforces an expiry period requirement on the certificates. This requirement limits the scope of potential key compromise; it also forces server operators to design systems that support and actively perform key rotation. For this reason, WebTransport imposes a similar expiry requirement; as the certificates are expected to be ephemeral or short-lived, the expiry period is limited to two weeks. The two weeks limit is a balance between＼

• 鍵~弱体化による帰結を最小~化するため， 失効~期限をアリな限り短く設定する。 ◎ setting the expiry limit as low as possible to minimize consequences of a key compromise,＼
• 各~機器にまたがる時計のずれを収容するに足るまで，長く保守する。 ◎ and maintaining it sufficiently high to accomodate for clock skew across devices,＼
• ［ ~client側 ↔ ~server側 ］間で証明書を同期するための~costを なるべく下げる。 ◎ and to lower the costs of synchronizing certificates between the client and the server side.

~WebTransport~APIは、 応用が複数の証明書~hashをまとめて指定できるようにする。 それは、 次を~clientに許容する ⇒ 新たな証明書が行き渡るまでの期間において， 【それまでの証明書も可用になるよう】 複数の証明書を受容する。 ◎ The WebTransport API lets the application specify multiple certificate hashes at once, allowing the client to accept multiple certificates for a period in which a new certificate is being rolled out.

~WebRTCにおける`類似な仕組み＠~CSP3#webrtc$と違って、 ~WebTransportにおける~server証明書~hash~APIは， ~clientを認証するための手段を何ら供さない — 事実、 ~clientが［ ~server証明書が何であるか／どう `contact^en するか ］を知るだけでは足らない。 応用は、 必要yなら， ~clientの識別情報を帯域内に確立する必要がある。 ◎ Unlike a similar mechanism in WebRTC, the server certificate hash API in WebTransport does not provide any means of authenticating the client; the fact that the client knows what the server certificate is or how to contact it is not sufficient. The application has to establish the identity of the client in-band if necessary.

13.5. 指紋収集と追跡

この~APIは、［ ~network活動を生成する能, この活動の効果を細かく観測する能 ］を~siteに供する。 この仕方で得される情報は， 【利用者を】`識別している＠~INFRA#tracking-vector$かもしれない。 ◎ This API provides sites with the ability to generate network activity and closely observe the effect of this activity. The information obtained in this way might be identifying.

重要なこととして、 他の~web~platform~API — `FETCH$r, `WEBRTC$r など — も，ごく類似な~networking能力を供することを認識すること。 したがって、 ~WebTransport~APIを追加することに因る~privacyへの悪影響は， 実質無いに等しい。 この節における考慮点は、 他の~networking能力にも等しく適用される。 ◎ It is important to recognize that very similar networking capabilities are provided by other web platform APIs (such as fetch and [webrtc]). The net adverse effect on privacy due to adding WebTransport is therefore minimal. The considerations in this section applies equally to other networking capabilities.

~network特性を測定するためには、［ ~networkが利用されていて， その利用度が成す効果が測定される ］ことが要求される — この~APIはどちらも可能化する。 ~WebTransportは、［ ~siteが選んだ~serverへ向けて~network活動を生成する能, その効果を観測する能 ］を~siteに供する。 ［ ~network経路の安定的な~prop, ~network利用度が成す動的な効果 ］どちらも観測nがアリになる。 ◎ Measuring network characteristics requires that the network be used and that the effect of that usage be measured, both of which are enabled by this API. WebTransport provides sites with an ability to generate network activity toward a server of their choice and observe the effects. Observations of both the stable properties of a network path and dynamic effect of network usage are possible.

~networkについての情報は、 次に挙げるものを通して，~serverに可用になる： ◎ Information about the network is available to the server either＼

• ~server自前の~networking~stackを通して直に ◎ directly through its own networking stack,＼
• ~clientにより~dataが［ 消費される／伝送される ］~rateを通して間接的に ◎ indirectly through the rate at which data is consumed or transmitted by the client,＼
• この~APIにより供される統計の一部として （ § `WebTransportConnectionStats^I 辞書 を見よ） ◎ or as part of the statistics provided by the API (see § 5.12 WebTransportConnectionStats Dictionary).＼

その帰結として、［ ~UAにおける情報に対する制約 ］は，［ これらの~privacy~riskを管理するために必要かもしれない仕組み ］として唯一のものではない。 ◎ Consequently, restrictions on information in user agents is not the only mechanism that might be needed to manage these privacy risks.

14.1. ~datagramたちが成す~bufferの送信-法

~datagramたちが成す~bufferの送信は、 `datagrams$mT の `writable$mD 属性を利用して達成できる。 次の例では、 ~datagramたちは， ~transportがそれを送信するに準備済みな場合に限り送信される。 ◎ Sending a buffer of datagrams can be achieved by using the datagrams' writable attribute. In the following example datagrams are only sent if the transport is ready to send.

async function sendDatagrams(%url, %datagrams) {
  const %wt = new WebTransport(%url);
  const %writer = %wt.datagrams.writable.getWriter();
  for (const %bytes of %datagrams) {
    await %writer.ready;
    %writer.write(%bytes).catch(() => {});
  }
}

14.2. 固定的な~rateによる~datagram群の送信-法

~datagram群を［ ~transportがそれを送信するに準備済みか否か ］に関わらず固定的な~rateで送信することは、 単純に［ `datagrams$mT の `writable$mD を利用して， `ready$mT 属性を利用しないこと ］により達成できる。 もっと複階的な局面では、 `ready$mT 属性を用立てれる。 ◎ Sending datagrams at a fixed rate regardless if the transport is ready to send can be achieved by simply using datagrams' writable and not using the ready attribute. More complex scenarios can utilize the ready attribute.

/* 
100 ~milli秒ごとに~datagramを送信する。
◎
Sends datagrams every 100 ms.
 */
async function sendFixedRate(%url, %createDatagram, %ms = 100) {
  const %wt = new WebTransport(%url);
  await %wt.ready;
  const %writer = wt.datagrams.writable.getWriter();
  const %bytes = createDatagram();
  setInterval(() => %writer.write(%bytes).catch(() => {}), %ms);
}

14.3. ~datagramの受信-法

~datagramは、 `datagrams$mT の `readable$mD 属性から読取ることにより受信できる。 ~NULL値は、 ~packetが十分に素早く処理されていないことを指示し得る。 ◎ Datagrams can be received by reading from the transport.datagrams.readable attribute. Null values may indicate that packets are not being processed quickly enough.

async function receiveDatagrams(%url) {
  const %wt = new WebTransport(%url);
  for await (const %datagram of %wt.datagrams.readable) {
    /* 
%datagram を処理する
◎
Process the datagram
 */
  }
}

14.4. ~BYOB読取器による~datagramの受信-法

`datagrams$mT は、 `可読~byte~stream$なので， それ用に`~BYOB読取器$を獲得できる — それは、 複製を避けるために，より精確な［ ~bufferの割振りに対する制御 ］を許容する。 この例は、 ~datagramを 64kB の~memory~bufferの中へ読取る。 ◎ As datagrams are readable byte streams, you can acquire a BYOB reader for them, which allows more precise control over buffer allocation in order to avoid copies. This example reads the datagram into a 64kB memory buffer.

const wt = new WebTransport(%url);

for await (const %datagram of %wt.datagrams.readable) {
  const %reader = %datagram.getReader({ mode: "byob" });

  let %array_buffer = new ArrayBuffer(65536);
  const %buffer = await readInto(%array_buffer);
}

async function readInto(%buffer) {
  let %offset = 0;

  while (%offset < %buffer.byteLength) {
    const {value: %view, %done} = await %reader.read(
        new Uint8Array(%buffer, %offset, %buffer.byteLength - %offset));
    %buffer = %view.buffer;
    if (%done) {
      break;
    }
    %offset += %view.byteLength;
  }

  return %buffer;
}

14.5. ~streamの送信-法

~dataを一方通行な~streamとして送信することは、 `createUnidirectionalStream()$mT 関数から返される~streamの書込器を利用して達成できる。 ◎ Sending data as a one-way stream can be achieved by using the createUnidirectionalStream function and the resulting stream’s writer.

async function sendData(%url, ...%data) {
  const %wt = new WebTransport(%url);
  const %writable = await %wt.createUnidirectionalStream();
  const %writer = %writable.getWriter();
  for (const %bytes of %data) {
    await %writer.ready;
    %writer.write(%bytes).catch(() => {});
  }
  await %writer.close();
}

注記： `write()^c からの~promiseを待受けること（ `await^c ）は、 ~stream仕様により`忌避される＠~STREAMS#example-manual-write-dont-await$。 ◎ The streams spec discourages awaiting the promise from write().

`ReadableStream$I から~pipeを通すことで，符号化も行える — 例えば， `TextEncoderStream$I を利用して。 ◎ Encoding can also be done through pipes from a ReadableStream, for example using TextEncoderStream.

async function sendText(%url, %readableStreamOfTextData) {
  const %wt = new WebTransport(%url);
  const %writable = await %wt.createUnidirectionalStream();
  await %readableStreamOfTextData
    .pipeThrough(new TextEncoderStream("utf-8"))
    .pipeTo(%writable);
}

14.6. 流入~streamの受信-法

流入~streamを読取ることは、 次により達成できる ⇒ `incomingUnidirectionalStreams$mT 属性~上で 各 `WebTransportReceiveStream$I を反復して， そこからの各~chunkを反復して消費する。 ◎ Reading incoming streams can be achieved by iterating over the incomingUnidirectionalStreams attribute, and then consuming each WebTransportReceiveStream by iterating over its chunks.

async function receiveData(%url, %processTheData) {
  const %wt = new WebTransport(%url);
  for await (const %readable of %wt.incomingUnidirectionalStreams) {
    /* 
`IFFEs^en【？】 を個別に利用して各~streamを消費する,
~streamごとに~errorを報告する
◎
consume streams individually using IFFEs, reporting per-stream errors
 */
    ((async () => {
      try {
        for await (const %bytes of readable) {
          processTheData(%bytes);
        }
      } catch (%e) {
        console.error(%e);
      }
    })());
  }
}

新たな `WritableStream$I へ~pipeすることを通して，復号も行える — 例えば， `TextDecoderStream$I を利用して。 この例では、 ~text出力は，他と前後されるべきでない — したがって，回ごとに 1 個の~streamに限り読取る — ものと見做す。 ◎ Decoding can also be done through pipes to new WritableStreams, for example using TextDecoderStream. This example assumes text output should not be interleaved, and therefore only reads one stream at a time.

async function receiveText(%url, %createWritableStreamForTextData) {
  const %wt = new WebTransport(%url);
  for await (const %readable of %wt.incomingUnidirectionalStreams) {
    /* 
出力を他と前後することなく，連列的に消費する。
~errorは~streamごとに報告する。
◎
consume sequentially to not interleave output, reporting per-stream errors
 */
    try {
      await %readable
       .pipeThrough(new TextDecoderStream("utf-8"))
       .pipeTo(%createWritableStreamForTextData());
    } catch (%e) {
      console.error(%e);
    }
  }
}

14.7. ~BYOB読取器による~streamの受信-法

`WebTransportReceiveStream$I は`可読~byte~stream$なので、 それ用に`~BYOB読取器$を獲得できる — それは、 複製を避けるために，より精確な［ ~bufferの割振りに対する制御 ］を許容する。 この例は、 `WebTransportReceiveStream$I から最初の 1024 ~byteを単独の~memory~bufferの中へ読取る。 ◎ As WebTransportReceiveStreams are readable byte streams, you can acquire a BYOB reader for them, which allows more precise control over buffer allocation in order to avoid copies. This example reads the first 1024 bytes from a WebTransportReceiveStream into a single memory buffer.

const %wt = new WebTransport(%url);

const %reader = %wt.incomingUnidirectionalStreams.getReader();
const { value: %recv_stream, %done } = await %reader.read();
const %byob_reader = %recv_stream.getReader({ mode: "byob" });

let %array_buffer = new ArrayBuffer(1024);
const %buffer = await readInto(%array_buffer);

async function readInto(%buffer) {
  let %offset = 0;

  while (%offset < %buffer.byteLength) {
    const {value: %view, %done} = await %reader.read(
        new Uint8Array(%buffer, %offset, %buffer.byteLength - %offset));
    %buffer = %view.buffer;
    if (%done) {
      break;
    }
    %offset += %view.byteLength;
  }

  return %buffer;
}

14.8. ~streamに対する不可分的な~chunkの送信-法

不可分的な一片を成す~dataを［ `~flow制御$により阻まれることなく，一度で行える場合 ］に限り，一方向な~stream上に送信することは、 `getWriter()$mS ~method【！関数】, その結果の書込器（ %writer ）を利用して達成できる。 ◎ Sending a transactional piece of data on a unidirectional stream, only if it can be done entirely without blocking on flow control, can be achieved by using the getWriter function and the resulting writer.

async function sendTransactionalData(%wt, %bytes) {
  const %writable = await %wt.createUnidirectionalStream();
  const %writer = %writable.getWriter();
  await %writer.ready;
  try {
    await writer.atomicWrite(%bytes);
  } catch (%e) {
    if (%e.name != "AbortError") throw %e;
    /* 
~flow制御により阻まれるのを避けるため、
却下される。
%writable は、［
処理待ちな不可分でない書込n
］は無い限りにおいて，~errorしないままにあり続ける。
◎
rejected to avoid blocking on flow control
The writable remains un-errored provided no non-atomic writes are pending
 */
  } finally {
    %writer.releaseLock();
  }
}

14.9. ~server証明書~hashの利用-法

~WebTransport~sessionは、［ ~clientにより遂行される既定の信用-評価 ］を［ ~serverへ供される証明書の~hashに対する検査 ］で上書きし得る。 次の例の %hashValue は、 ~server証明書の~SHA-256 ~hashを包含している `BufferSource$I であり， その妥当~性は`下層~接続$が考慮するべきものである。 ◎ A WebTransport session can override the default trust evaluation performed by the client with a check against the hash of the certificate provided to the server. In the example below, hashValue is a BufferSource containing the SHA-256 hash of a server certificate that the underlying connection should consider to be valid.

const %wt = new WebTransport(%url, {
  serverCertificateHashes: [
    {
      algorithm: "sha-256",
      value: %hashValue,
    }
  ]
});
await %wt.ready;

14.10. 完全な例

この例は、 次について~~説明する： ◎ This example illustrates＼

• ［ ~close時の~promise, 準備済み時の~promise ］の利用 ◎ use of the closed and ready promises,＼
• ［ ~client／~server ］による［ 一方向~stream, 双方向~stream ］の~open法 ◎ opening of uni-directional and bi-directional streams by either the client or the server,＼
• ~datagramの［ 送信-法, 受信-法 ］ ◎ and sending and receiving datagrams.

/* 
~page上の~event~logに~entryを追加する。
【！余計？任意選択で，指定された~CSS~classを適用して】
◎
Adds an entry to the event log on the page, optionally applying a specified CSS class.
 */

let %wt, %streamNumber, %datagramWriter;

connect.onclick = async () => {
  try {
    const %url = document.getElementById('url').value;

    %wt = new WebTransport(%url);
    addToEventLog('接続を起動しています...');
    await %wt.ready;
    addToEventLog(``^${(%wt.reliability == "reliable-only")? "TCP" : "UDP"} 接続は準備済み。``^);
    %wt.closed
      .then(() => addToEventLog('接続は正常に~closeされました。'))
      .catch(() => addToEventLog('接続は中途で~closeされました。', 'error'));

    %streamNumber = 1;
    %datagramWriter = %wt.datagrams.writable.getWriter();

    %readDatagrams();
    %acceptUnidirectionalStreams();
    document.forms.sending.elements.send.disabled = false;
    document.getElementById('connect').disabled = true;
  } catch (%e) {
    addToEventLog(``^接続に失敗しました。 ${%e}``^, 'error');
  }
}

sendData.onclick = async () => {
  const %form = %document.forms.sending.elements;
  const %data = %sending.data.value;
  const %bytes = new TextEncoder('utf-8').encode(%data);
  try {
    switch (%form.sendtype.value) {
      case 'datagram': {
        await %datagramWriter.ready;
        %datagramWriter.write(%bytes).catch(() => {});
        addToEventLog(``^~datagramを送信しました: ${%data} ``^);
        break;
      }
      case 'unidi': {
        const %writable = await %wt.createUnidirectionalStream();
        const %writer = %writable.getWriter();
        %writer.write(%bytes).catch(() => {});
        await %writer.close();
        addToEventLog(``^一方向~streamを~dataと伴に送信しました: ${%data}``^);
        break;
      }
      case 'bidi': {
        const %duplexStream = await %wt.createBidirectionalStream();
        const %n = %streamNumber++;
        readFromIncomingStream(%duplexStream.readable, %n);

        const %writer = %duplexStream.writable.getWriter();
        %writer.write(%bytes).catch(() => {});
        await %writer.close();
        addToEventLog(``^双方向~stream #${%n} を~dataと伴に送信しました: ${%data}``^);
        break;
      }
    }
  } catch (%e) {
    addToEventLog(``^~dataの送信-中に~error: ${%e}``^, 'error');
  }
}

/* 
~EOFに到達するまで、
~datagram群を~event~logの中へ読取る。
◎
Reads datagrams into the event log until EOF is reached.
 */
async function readDatagrams() {
  try {
    const %decoder = new TextDecoderStream('utf-8');

    for await (const %data of %wt.datagrams.readable.pipeThrough(%decoder)) {
      addToEventLog(``^~datagramを受信しました: ${%data}``^);
    }
    addToEventLog('~datagramを読取りました。');
  } catch (%e) {
    addToEventLog(``^~datagramの読取n中に~error: ${%e}``^, 'error');
  }
}

async function acceptUnidirectionalStreams() {
  try {
    for await (const %readable of %wt.incomingUnidirectionalStreams) {
      const %number = %streamNumber++;
      addToEventLog(``^新たな流入~一方向~stream #${%number}``^);
      readFromIncomingStream(%readable, %number);
    }
    addToEventLog('一方向~streamを受容しました。');
  } catch (%e) {
    addToEventLog(``^~stream ${%e} の受容-中に~error。``^, 'error');
  }
}

async function readFromIncomingStream(%readable, %number) {
  try {
    const %decoder = new TextDecoderStream('utf-8');
    for await (const %data of %readable.pipeThrough(%decoder)) {
      addToEventLog(``^~stream #${%number} 上で~dataを受信しました: ${%data}``^);
    }
    addToEventLog(``^~stream #${%number} は~closeされました。``^);
  } catch (%e) {
    addToEventLog(``^~stream #${%number} から読取n中に~error: ${%e}``^, 'error');
    addToEventLog(``^    ${%e.message}``^);
  }
}

function addToEventLog(%text, %severity = 'info') {
  const %log = document.getElementById('event-log');
  const %previous = %log.lastElementChild;
  const %entry = document.createElement('li');
  %entry.innerText = %text;
  %entry.className = ``^`log^-${%severity}``^;
  %log.appendChild(%entry);

  /* 
%log 内のそれまでの~entryが可視であった場合、
新たな要素へ~scrollする。
◎
If the previous entry in the log was visible, scroll to the new element.
 */
  if (%previous &&
      %previous.getBoundingClientRect().top < %log.getBoundingClientRect().bottom) {
    %entry.scrollIntoView();
  }
}