WebTransport

1. stream を、以下を持つ 新しい WebTransportDatagramsWritable とする:

   [[OutgoingDatagramsQueue]]

   空のキュー

   [[Transport]]

   transport

   [[SendGroup]]

   sendGroup

   [[SendOrder]]

   sendOrder

2. writeDatagramsAlgorithm を、writeDatagrams を transport と stream で実行するアクションとする。

3. セットアップ stream で writeAlgorithm を writeDatagramsAlgorithm に設定する。

4. stream を返す。

writeDatagrams アルゴリズムはtransportおよびwritableをパラメータ、dataを入力とし、次の手順で定義されます：

1. timestampを現在を表すタイムスタンプとする。

2. data が BufferSource オブジェクトでない場合、TypeError で却下された promiseを返す。

3. datagramsをtransport.[[Datagrams]]とする。

4. datagrams.[[OutgoingMaxDatagramSize]] がdataの[[ByteLength]]より小さい場合、undefinedでresolveされたpromiseを返す。

5. promiseを新しいpromiseとする。

6. bytesをdataが表すバイトのコピーとする。

7. chunkをbytes、timestamp、promiseのタプルとする。

8. writable.[[OutgoingDatagramsQueue]] にchunkをエンキューする。

9. writable.[[OutgoingDatagramsQueue]] の長さが datagrams.[[OutgoingMaxBufferedDatagrams]] 未満なら、promiseをundefinedで解決する。

10. promiseを返す。

注: 関連するWritableStream は、そのストリームでwriteDatagramsによって返されたpromiseが全て解決されたときのみwriteDatagramsを呼び出します。したがって、タイムスタンプと有効期限は、ウェブ開発者が WritableStreamDefaultWriter.ready に注意を払う場合のみ適切に動作します。

sendDatagrams するには、WebTransport オブジェクトtransportと WebTransportDatagramsWritable オブジェクトwritableで、ネットワークタスクをキューし transportで以下のステップを実行します：

1. queueをwritable.[[OutgoingDatagramsQueue]] のコピーとする。

   注: 上記のコピーおよびネットワークタスクのキューは最適化できます。

2. maxSizeをtransport.[[Datagrams]].[[OutgoingMaxDatagramSize]] とする。

3. durationをtransport.[[Datagrams]].[[OutgoingDatagramsExpirationDuration]] とする。

4. durationがnullなら、durationを実装定義値に設定する。

5. 次のステップを並行して実行：

   1. queueが空でない間：

      1. bytes、timestamp、promiseをqueueの先頭要素から取得する。

      2. timestampからdurationミリ秒以上経過している場合：

         1. queueの先頭要素を削除する。

         2. ネットワークタスクをキューしtransportでpromiseをundefinedで解決する。

      3. それ以外の場合、このループを終了する。

   2. transport.[[State]] が"connected"でなければ、何もせず終了する。

   3. queueが空でない間：

      1. bytes、timestamp、promiseをqueueの先頭要素から取得する。

      2. bytesの長さがmaxSize以下の場合：

         1. bytesを即座にネットワークに送信できない場合、このループを終了する。

         2. データグラムの送信をtransport.[[Session]] とbytesで行う。

      3. queueの先頭要素を削除する。

      4. ネットワークタスクをキューし transportでpromiseをundefinedで解決する。

1. stream を 新しい WebTransportDatagramDuplexStream として次のように初期化する：

   [[Transport]]

   transport

   [[Readable]]

   readable

   [[ReadableType]]

   readableType

   [[Writables]]

   空の 順序付き集合

   [[IncomingDatagramsQueue]]

   空のキュー

   [[IncomingDatagramsPullPromise]]

   null

   [[IncomingMaxBufferedDatagrams]]

   実装依存の値

   [[IncomingDatagramsExpirationDuration]]

   null

   [[OutgoingMaxBufferedDatagrams]]

   実装依存の値

   この実装依存の値は、適切なスループットを確保しつつ、 伝送データの迅速性を損なわないように調整されるべき

   [[OutgoingDatagramsExpirationDuration]]

   null

   [[OutgoingMaxDatagramSize]]

   実装依存の整数値

2. stream を返す

createWritable(options)

WebTransportDatagramsWritable を作成する。 呼び出されたとき、ユーザーエージェントは 次の手順を実行しなければならない：

1. transport を、this に関連付けられた WebTransport オブジェクトとする。

2. sendGroup を options の sendGroup とする。

3. sendGroup が null でなく、かつ sendGroup.[[Transport]] が this.[[Transport]] でない場合、 TypeError を投げる。

4. transport.[[State]] が "closed" または "failed" の場合、 InvalidStateError を投げる。

5. sendOrder を options の sendOrder とする。

6. transport、sendGroup、および sendOrder で WebTransportDatagramsWritable を作成する結果を返す。

1. baseURL を、this の 関連設定オブジェクトの API ベース URL とする。

2. url を、baseURL を用いて url を構文解析した結果の URL レコードとする。

3. url が失敗である場合、SyntaxError 例外を投げる。

4. url の スキームが https でない場合、SyntaxError 例外を投げる。

5. url の フラグメントが null でない場合、SyntaxError 例外を投げる。

6. newConnection を、options の allowPooling が true である場合は "no"、そうでなければ "yes-and-dedicated" とする。

7. serverCertificateHashes を、options の serverCertificateHashes とする。

8. newConnection が "no" であり、かつ serverCertificateHashes が空でない場合、NotSupportedError 例外を投げる。

9. requireUnreliable を、options の requireUnreliable とする。

10. congestionControl を、options の congestionControl とする。

11. congestionControl が "default" でなく、かつユーザーエージェントが [RFC9002] Section 7 で許可されるように、 congestionControl に最適化される輻輳制御アルゴリズムを 何もサポートしていない場合、 congestionControl を "default" に設定する。

12. protocols を、options の protocols とする。

13. protocols 内の値のいずれかが複数回出現する場合、WebTransport プロトコルで定義される、 交渉されるアプリケーションプロトコルの値を構成する要素の要件に 合致しない場合、または同型符号化された 長さが 0 もしくは 512 を超える場合、SyntaxError 例外を投げる。 [WEB-TRANSPORT-OVERVIEW] Section 3.1.

14. anticipatedConcurrentIncomingUnidirectionalStreams を、options の anticipatedConcurrentIncomingUnidirectionalStreams とする。

15. anticipatedConcurrentIncomingBidirectionalStreams を、options の anticipatedConcurrentIncomingBidirectionalStreams とする。

16. datagramsReadableType を、options の datagramsReadableType とする。

17. incomingDatagrams を、新しい ReadableStream とする。

18. transport を、次を持つ、新たに構築された WebTransport オブジェクトとする:

    [[SendStreams]]

    空の順序付き集合

    [[ReceiveStreams]]

    空の順序付き集合

    [[IncomingBidirectionalStreams]]

    新しい ReadableStream

    [[IncomingUnidirectionalStreams]]

    新しい ReadableStream

    [[State]]

    "connecting"

    [[Ready]]

    新しい promise

    [[Reliability]]

    "pending"

    [[CongestionControl]]

    congestionControl

    [[AnticipatedConcurrentIncomingUnidirectionalStreams]]

    anticipatedConcurrentIncomingUnidirectionalStreams

    [[AnticipatedConcurrentIncomingBidirectionalStreams]]

    anticipatedConcurrentIncomingBidirectionalStreams

    [[ResponseHeaders]]

    null

    [[Protocol]]

    空文字列

    [[Closed]]

    新しい promise

    [[Draining]]

    新しい promise

    [[Datagrams]]

    undefined

    [[Session]]

    null

    [[NewConnection]]

    newConnection

    [[RequireUnreliable]]

    requireUnreliable

19. transport.[[Datagrams]] を、transport、incomingDatagrams、および datagramsReadableType を用いて WebTransportDatagramDuplexStream を作成した結果に設定する。

20. pullDatagramsAlgorithm を、transport を用いて pullDatagrams を実行する動作とする。

    注: データグラムでは 64 キビバイトのバッファーを使用することが推奨される。 これは、有効な最大 WebTransport データグラムフレームサイズが、QUIC 最大データグラムフレーム サイズの上限を持ち、その値は 64 キビバイトであることが推奨されるためである（[QUIC-DATAGRAM] Section 3 を参照）。 これにより、データグラムがバッファーより大きいことによってストリームがエラーにならないことが保証される。

21. datagramsReadableType が "bytes" である場合、incomingDatagrams をバイト読み取りサポート付きで 設定し、pullAlgorithm を pullDatagramsAlgorithm に設定し、 highWaterMark を 0 に設定する。そうでなければ、incomingDatagrams を 設定し、 pullAlgorithm を pullDatagramsAlgorithm に設定し、 highWaterMark を 0 に設定する。

22. pullBidirectionalStreamAlgorithm を、transport を用いて pullBidirectionalStream を実行する動作とする。

23. transport.[[IncomingBidirectionalStreams]] を設定し、 pullAlgorithm を pullBidirectionalStreamAlgorithm に設定し、 highWaterMark を 0 に設定する。

24. pullUnidirectionalStreamAlgorithm を、transport を用いて pullUnidirectionalStream を実行する動作とする。

25. transport.[[IncomingUnidirectionalStreams]] を設定し、 pullAlgorithm を pullUnidirectionalStreamAlgorithm に設定し、 highWaterMark を 0 に設定する。

26. client を、transport の関連設定オブジェクトとする。

27. origin を、client のオリジンとする。

28. request を、新しいリクエストとする。その URL は url、client は client、service-workers mode は "none"、 referrer は "no-referrer"、mode は "webtransport"、 credentials mode は "omit"、 cache mode は "no-store"、 policy container は client の policy container、destination は ""、 origin は origin、WebTransport-hash list は serverCertificateHashes、そしてredirect mode は "error" である。

    注: リダイレクトは追跡されない。リダイレクトによって引き起こされるネットワーク エラーは、意図的に他のネットワークエラーと区別できない。クロスオリジンコンテキストでは、これは 通常 CORS によってブロックされる情報を明らかにしてしまう。同一オリジンコンテキストでは、 ハンドシェイクを情報受け渡しのベクトルとして濫用するようアプリケーションを 助長する可能性がある。

29. request のmethod を "CONNECT" に設定し、 method に関連付けられた :protocol 疑似ヘッダーを "webtransport" に設定する。

30. headers を、options["headers"] で埋められた新しい Headers オブジェクトとする。

31. requestHeaders を、新しい Headers オブジェクトとする。そのヘッダーリストは request のヘッダーリストであり、ガードは "request" である。

32. headers のヘッダーリスト内の各 header について:

    1. header の名前を ASCII 小文字化したものが "wt-available-protocols" である場合、 TypeError を投げる。

    2. header を requestHeaders に追加する。

    注: ヘッダーは Fetch の 禁止リクエストヘッダー 制限の対象となる。

33. protocols が空でない場合、(WT-Available-Protocols, protocols 内の 構造化ヘッダー文字列項目を順にメンバーとする 構造化ヘッダーリスト) を用いて、request の ヘッダーリスト内に構造化フィールド値を設定する。

34. request をフェッチし、useParallelQueue を true に設定し、processResponse を、response が与えられたときの次の手順に設定する:

    1. response および transport を用いて、WebTransport fetch response を処理する。

35. transport を返す。

1. transport を、request に関連付けられた WebTransport オブジェクトとする。

2. url を、request の現在の URL とする。

3. newConnection を、transport.[[NewConnection]] とする。

4. requireUnreliable を、transport.[[RequireUnreliable]] とする。

5. webTransportHashes を、request のWebTransport-hash list 内の値とする。

6. connection を、networkPartitionKey、url、false、 newConnection、requireUnreliable、および webTransportHashes を用いて接続を取得する結果とする。

7. connection が失敗である場合、失敗を返す。

8. connection が最初の SETTINGS フレームを受信するまで待機し、 settings を、その SETTINGS フレームを表す辞書とする。

9. settings が値 1 の SETTINGS_ENABLE_CONNECT_PROTOCOL を含まない場合 （HTTP/2 については 0x08、Section 3 of [RFC8441] を参照。HTTP/3 については 0x08、 Section 3 of [RFC9220] を参照）、失敗を返す。

10. settings が WebTransport に対するサーバーサポートを示さない場合、失敗を返す。 [WEB-TRANSPORT-OVERVIEW] Section 4.1.

    • HTTP/3 では、サポートには 0 より大きい値の SETTINGS_WT_ENABLED、 および値 1 の SETTINGS_H3_DATAGRAM が必要である。[WEB-TRANSPORT-HTTP3] Section 3.1.

    • HTTP/2 では、潜在的なサポートは上記の SETTINGS_ENABLE_CONNECT_PROTOCOL によってすでに示されている。 [WEB-TRANSPORT-HTTP2] Section 3.1.

11. connection を返す。

1. response が ネットワークエラーの場合、残りの手順を中止し ネットワークタスクをキューして transport に以下を実行：

   1. transport.[[State]] が "closed" または "failed" の場合、これ以降の手順を中止。

   2. error を新しく create exception した WebTransportError とする。source は "session"。

   3. Cleanup transport に error を指定して行う。

2. connection を response に関連付けられた下層接続とする。

3. [WEB-TRANSPORT-OVERVIEW] Section 4.1 の制約に従い WebTransport セッション確立 を connection とサーバーの response で行い、 session を得る。 得られた下層トランスポートストリームはセッションの CONNECTストリーム と呼ぶ。

   注記: この手順は [QUIC-DATAGRAM] の トランスポートパラメータ交換も完結させる。

4. 前ステップが失敗した場合、残りの手順を中止し ネットワークタスクをキューし transport で以下を実行：

   1. transport.[[State]] が "closed" または "failed" の場合、これ以降の手順を中止。

   2. error を新しく create exception した WebTransportError とする。source は "session"。

   3. Cleanup transport に error を指定して行う。

5. ユーザーエージェントが複数の輻輳制御アルゴリズムに対応している場合は、 この connection の送信に transport の [[CongestionControl]] に適したものを選ぶ。

6. ネットワークタスクをキューして transport に以下を実行：

   1. アサート: this の [[Datagrams]] の [[OutgoingMaxDatagramSize]] は整数である。

   2. transport.[[State]] が "connecting" でない場合：

      1. 並列処理で terminate session を行う。

      2. これ以降の手順を中止。

   3. transport.[[State]] を "connected" に設定。

   4. transport.[[Session]] を session に設定。

   5. responseHeaders を response の header list のコピーにする。

   6. Delete "wt-protocol" を responseHeaders から削除。

   7. transport.[[ResponseHeaders]] を新しい Headers オブジェクトに設定。header list は responseHeaders、guard は "immutable"。

   8. transport.[[Protocol]] を、WebTransport Protocol Framework [WEB-TRANSPORT-OVERVIEW] Section 3.1 に従い、協議されたアプリケーションプロトコルの文字列値が存在すればそれ、なければ "" に設定する。

   9. 接続がHTTP/3の場合、transport.[[Reliability]] を "supports-unreliable" に設定。

   10. 接続が HTTP/2 ([WEB-TRANSPORT-HTTP2]) の場合は transport の [[Reliability]] を "reliable-only" に設定。

   11. resolve transport.[[Ready]] を undefined で解決する。

1. transport.[[State]] が "connecting" なら transport.[[Ready]] の fulfillment時に 以下の手順を実行しその結果を返す：

   1. pullBidirectionalStream を transport で実行した結果を返す。

2. transport.[[State]] が "connected" でなければ、 新しい reject promise を InvalidStateError で返す。

3. session を transport.[[Session]] とする。

4. p を新しい promise とする。

5. 並列処理で以下を行う：

   1. session で 双方向ストリーム受信可能になるまで待つ。

   2. internalStream を 双方向ストリーム受信 の結果とする。

   3. ネットワークタスクをキューし transport に以下実行：

      1. stream を bidirectionalStream作成 の結果 (引数 internalStream, transport) とする。

      2. Enqueue stream を transport.[[IncomingBidirectionalStreams]] に追加。

      3. resolve p を undefined で解決する。

6. p を返す。

1. transport.[[State]] が "connecting" なら transport.[[Ready]] の fulfillment時に 以下の手順を実行しその結果を返す：

   1. pullUnidirectionalStream を transport で実行した結果を返す。

2. transport.[[State]] が "connected" でなければ、 新しい reject promise を InvalidStateError で返す。

3. session を transport.[[Session]] とする。

4. p を新しい promise とする。

5. 並列処理で以下を行う：

   1. session で 単方向ストリーム受信可能 になるまで待つ。

   2. internalStream を 単方向ストリーム受信 の結果とする。

   3. ネットワークタスクをキューし transport に以下実行：

      1. stream を WebTransportReceiveStream作成 の結果 (internalStream, transport) とする。

      2. Enqueue stream を transport.[[IncomingUnidirectionalStreams]] に追加。

      3. resolve p を undefined で解決する。

6. p を返す。

close(closeInfo)

WebTransport オブジェクトに関連付けられた WebTransport セッションを終了する。 呼び出されたとき、ユーザーエージェントは次の手順を実行しなければならない：

1. transport を this とする。

2. transport.[[State]] が "closed" または "failed" である場合、これらの手順を中止する。

3. transport.[[State]] が "connecting" である場合：

   1. error を、新たに 作成された WebTransportError とし、その source は "session" とする。

   2. error を用いて transport を クリーンアップする。

   3. これらの手順を中止する。

4. session を transport.[[Session]] とする。

5. code を closeInfo.closeCode とする。

6. reasonString を、 closeInfo.reason の最大の 符号単位接頭辞であって、その接頭辞を UTF-8 符号化したものの 長さが 1024 を超えないものとする。

7. reason を、reasonString を UTF-8 符号化したものとする。

8. 並列に、code と reason を用いて session を終了する。

   注：これはまた、 transport.[[SendStreams]] および [[ReceiveStreams]] に含まれる WebTransport ストリーム上の 送信を中止するか、または 受信を 中止する。

9. AbortError および closeInfo を用いて transport をクリーンアップする。

getStats()

この WebTransport の 下位接続に関する統計を収集し、 結果を非同期に報告する。

呼び出されたとき、ユーザーエージェントは次の手順を実行しなければならない：

1. transport を this とする。

2. p を新しい promise とする。

3. transport.[[State]] が "failed" である場合、p を InvalidStateError で拒否し、これらの手順を中止する。

4. 次の手順を並列に実行する：

   1. transport.[[State]] が "connecting" である場合、それが変化するまで待つ。

   2. transport.[[State]] が "failed" である場合、 p を InvalidStateError で拒否するため、transport で ネットワークタスクをキューに入れた後、 これらの手順を中止する。

   3. transport.[[State]] が "closed" である場合、 p をその接続について利用可能な最新の統計で 解決するため、transport で ネットワークタスクをキューに入れた後、 これらの手順を中止する。それらの統計が収集される正確な時点は 実装定義である。

   4. gatheredStats を、 WebTransportConnectionStats および WebTransportDatagramStats の辞書メンバーを正確に埋めるために必要な、 下位接続に固有の統計の リストとする。

   5. transport.[[NewConnection]] が "no" である場合、 gatheredStats から、プールされた 接続統計としてマークされていないすべての統計を削除する。

   6. transport でネットワークタスクをキューに入れ、 次の手順を実行する：

      1. stats を新しい WebTransportConnectionStats オブジェクトとする。

      2. datagramStats を新しい WebTransportDatagramStats オブジェクトとする。

      3. stats["datagrams"] を datagramStats に設定する。

      4. ユーザーエージェントが公開したい stats および datagramStats の各メンバー member について、 member を gatheredStats 内の対応する エントリに 設定する。

      5. p を stats で解決する。

5. p を返す。

exportKeyingMaterial(BufferSource label, BufferSource context, unsigned long outputLength)

この WebTransport の 下位接続に一意に関連付けられた TLS セッションについて、 TLS Keying Material Exporter から鍵材料をエクスポートする。 呼び出されたとき、ユーザーエージェントは次の手順を実行しなければならない：

1. labelLength を label.byte length とする。

2. labelLength が 255 より大きい場合、 RangeError で拒否された promiseを返す。

3. contextLength を context.byte length とする。

4. contextLength が 255 より大きい場合、 RangeError で拒否された promiseを返す。

5. outputLength が 0、または 4096 以上で実装定義の値—​その値は少なくとも 4096 で なければならない—​より大きい場合、 RangeError で拒否された promiseを返す。

6. this.[[State]] が "closed" または "failed" である場合、 InvalidStateError で拒否された promiseを返す。

7. transport を this とする。

8. p を新しい promise とする。

9. 次の手順を並列に実行する。ただし、transport の [[State]] が "closed" または "failed" になると 中止し、代わりに p を InvalidStateError で拒否するため、transport で ネットワークタスクをキューに入れる：

   1. keyingMaterial を、[WEB-TRANSPORT-OVERVIEW] セクション 4.1 で定義されるとおり、label、context、および outputLength を用いて TLS 鍵エクスポーターを呼び出すことによって生成される Uint8Array とする。

   2. p を keyingMaterial で解決するため、transport で ネットワークタスクをキューに入れる。

10. p を返す。

createBidirectionalStream(options)

送信用の双方向ストリームのための WebTransportBidirectionalStream オブジェクトを作成する。ストリームを単に作成しただけでは、 データ送信に使用されるまで、ピアにはすぐには見えないことに注意。

注： サーバーは、データがその上で送信されるまで、そのストリームを認識することは期待されない。

呼び出されたとき、ユーザーエージェントは次の手順を実行しなければならない：

1. sendGroup を options の sendGroup とする。

2. sendGroup が null でなく、かつ sendGroup.[[Transport]] が this でない場合、 TypeError で拒否された promiseを返す。

3. this.[[State]] が "closed" または "failed" である場合、 InvalidStateError で拒否された promiseを返す。

4. sendOrder を options の sendOrder とする。

5. waitUntilAvailable を options の waitUntilAvailable とする。

6. p を新しい promise とする。

7. transport を this とする。

8. 次の手順を並列に実行する。ただし、transport の [[State]] が "closed" または "failed" になると 中止し、代わりに p を InvalidStateError で拒否するため、transport で ネットワークタスクをキューに入れる：

   1. streamId を、[QUIC] セクション 19.11で定義されるとおり、 transport.[[Session]] に対して有効かつ一意である新しいストリーム ID とする。枯渇によりそれが すぐに利用可能でない場合、waitUntilAvailable が true なら利用可能になるまで待ち、 waitUntilAvailable が false なら、 p を、requested と quota がどちらも null である QuotaExceededError で拒否するため、transport で ネットワークタスクをキューに入れた後、 これらの手順を中止する。

   2. internalStream を、 transport.[[Session]] と streamId を用いて双方向 ストリームを作成する結果とする。

   3. transport でネットワークタスクをキューに入れ、 次の手順を実行する：

      1. transport.[[State]] が "closed" または "failed" である場合、 p を InvalidStateError で拒否し、 これらの手順を中止する。

      2. stream を、 internalStream、transport、 sendGroup、および sendOrder を用いて WebTransportBidirectionalStream を作成する結果とする。

      3. p を stream で解決する。

9. p を返す。

createUnidirectionalStream(options)

送信用の単方向ストリームのための WebTransportSendStream を作成する。ストリームを単に作成しただけでは、データ送信に使用されるまで、 サーバーにはすぐには見えないことに注意。

注： サーバーは、データがその上で送信されるまで、そのストリームを認識することは期待されない。

呼び出されたとき、ユーザーエージェントは次の手順を実行しなければならない：

1. sendGroup を options の sendGroup とする。

2. sendGroup が null でなく、かつ sendGroup.[[Transport]] が this でない場合、 TypeError で拒否された promiseを返す。

3. this.[[State]] が "closed" または "failed" である場合、 InvalidStateError で拒否された promiseを返す。

4. sendOrder を options の sendOrder とする。

5. waitUntilAvailable を options の waitUntilAvailable とする。

6. p を新しい promise とする。

7. transport を this とする。

8. 次の手順を並列に実行する。ただし、transport の [[State]] が "closed" または "failed" になると 中止し、代わりに p を InvalidStateError で拒否するため、transport で ネットワークタスクをキューに入れる：

   1. streamId を、[QUIC] セクション 19.11で定義されるとおり、 transport.[[Session]] に対して有効かつ一意である新しいストリーム ID とする。枯渇によりそれが すぐに利用可能でない場合、waitUntilAvailable が true なら利用可能になるまで待ち、 waitUntilAvailable が false なら、 p を QuotaExceededError で拒否するため、transport で ネットワークタスクをキューに入れた後、 これらの手順を中止する。

   2. internalStream を、 transport.[[Session]] と streamId を用いて送信用の 単方向ストリームを作成する結果とする。

   3. transport でネットワークタスクをキューに入れ、 次の手順を実行する：

      1. transport.[[State]] が "closed" または "failed" である場合、 p を InvalidStateError で拒否し、 これらの手順を中止する。

      2. stream を、 internalStream、transport、sendGroup、 および sendOrder を用いて WebTransportSendStream を作成する結果とする。

      3. p を stream で解決する。

9. p を返す。

1. sendStreams を transport.[[SendStreams]] のコピーとする。

2. receiveStreams を transport.[[ReceiveStreams]] のコピーとする。

3. outgoingDatagramWritables を transport.[[Datagrams]].[[Writables]] とする。

4. incomingDatagrams を transport.[[Datagrams]].[[Readable]] とする。

5. ready を transport.[[Ready]] とする。

6. closed を transport.[[Closed]] とする。

7. incomingBidirectionalStreams を transport.[[IncomingBidirectionalStreams]] とする。

8. incomingUnidirectionalStreams を transport.[[IncomingUnidirectionalStreams]] とする。

9. transport.[[SendStreams]] を空の 集合に設定する。

10. transport.[[ReceiveStreams]] を空の 集合に設定する。

11. transport.[[Datagrams]].[[OutgoingDatagramsQueue]] を空の キューに設定する。

12. transport.[[Datagrams]].[[IncomingDatagramsQueue]] を空の キューに設定する。

13. closeInfo が与えられている場合、transport.[[State]] を "closed" に設定する。 そうでない場合、transport.[[State]] を "failed" に設定する。

14. sendStreams 内の各 stream について 反復し、次の手順を実行する：

    1. stream.[[PendingOperation]] が null でない場合、stream.[[PendingOperation]] を error で拒否する。

    2. stream を error でエラーにする。

15. receiveStreams 内の各 stream について 反復し、stream を error でエラーにする。

    注：スクリプト作者は、Promise 解決時に 同期的に実行されるコードを挿入できる。したがって ここからは、transport に触れてはならない。スクリプトによって予測不能な形で変更される可能性があるためである。 これは、この手続きを呼び出すロジックにも適用される。

16. closeInfo が与えられている場合：

    1. closed を closeInfo で解決する。

    2. 表明：ready はsettledしている。

    3. incomingBidirectionalStreams を閉じる。

    4. incomingUnidirectionalStreams を 閉じる。

    5. outgoingDatagramWritables 内の各 writable について、writable を閉じる。

    6. incomingDatagrams を閉じる。

17. そうでない場合：

    1. closed を error で拒否する。

    2. closed.[[PromiseIsHandled]] を true に設定する。

    3. ready を error で拒否する。

    4. ready.[[PromiseIsHandled]] を true に設定する。

    5. incomingBidirectionalStreams を error でエラーにする。

    6. incomingUnidirectionalStreams を error でエラーにする。

    7. outgoingDatagramWritables 内の各 writable について、writable を error でエラーにする。

    8. incomingDatagrams を error でエラーにする。

WebTransport transport と一連の手順 steps を用いてネットワークタスクをキューに入れるには、次の手順を実行する：

1. steps を実行するために、transport の 関連するグローバルオブジェクトを用いて、 ネットワークタスクソース上で グローバルタスクをキューに入れる。

1. transport で ネットワークタスクをキューに入れ、 次の手順を実行する：

   1. transport.[[State]] が "closed" または "failed" である場合、これらの手順を中止する。

   2. error を、新たに 作成された WebTransportError とし、その source は "session" とする。

   3. closeInfo を新しい WebTransportCloseInfo とする。

   4. code が与えられている場合、closeInfo の closeCode を code に設定する。

   5. reasonBytes が与えられている場合、closeInfo の reason を、reasonBytes を UTF-8 復号したものに設定する。

      注：reasonBytes には、 言語または書字方向のメタデータは利用できない。 値を表示するときの書字方向には First-strong ヒューリスティックを 使用できる。

   6. error および closeInfo を用いて transport をクリーンアップする。

1. transport で ネットワークタスクをキューに入れ、 次の手順を実行する：

   1. transport.[[State]] が "closed" または "failed" である場合、これらの手順を中止する。

   2. error を、新たに 作成された WebTransportError とし、その source は "session" とする。

   3. error を用いて transport をクリーンアップする。

証明書ハッシュを計算するために、certificate を与え、次の手順を実行する:

1. cert を certificate とし、[RFC5280] で定義される Certificate メッセージの DER エンコーディングとして表現する。

2. cert の SHA-256 ハッシュを計算し、計算された値を返す。

証明書ハッシュを検証するために、certificate chain とハッシュ配列 hashes を与え、次の手順を実行する:

1. certificate を certificate chain の最初の証明書（リーフ証明書）とする。

2. referenceHash を、certificate を用いて証明書ハッシュを計算した結果とする。

3. hashes 内のすべてのハッシュ hash について:

   1. もし hash.value が null でなく、かつ hash.algorithm が "sha-256" とASCII 大文字小文字非区別で一致するなら:

      1. hashValue を、hash.value が表すバイト列とする。

      2. もし hashValue が referenceHash に等しいなら、true を返す。

4. false を返す。

getStats()

この WebTransportSendStream の 性能に固有の統計を収集し、 結果を非同期に報告する。

呼び出されたとき、ユーザーエージェントは次の手順を実行しなければならない：

1. transport を this.[[Transport]] とする。

2. p を新しい promise とする。

3. 次の手順を並列に実行する：

   1. gatheredStats を、 WebTransportSendStreamStats の辞書メンバーを正確に埋めるために必要な、 this WebTransportSendStream に固有の統計の リストとする。

   2. transport でネットワークタスクをキューに入れ、 次の手順を実行する：

      1. stats を新しい WebTransportSendStreamStats オブジェクトとする。

      2. ユーザーエージェントが公開したい stats の各メンバー member について、 member を gatheredStats 内の対応する エントリに設定する。

      3. p を stats で解決する。

4. p を返す。

getWriter()

this ストリーム用の WebTransportWriter を作成する。

getWriter が呼び出されたとき、 this を用いて WebTransportWriter を作成する結果を返す。

作成するには、 WebTransportSendStream を、送信単方向または双方向 WebTransportストリーム internalStream、WebTransport transport、sendGroup、sendOrderを指定し、次の手順を実行する：

1. stream を 新しい WebTransportSendStream として次のように初期化する：

   [[InternalStream]]

   internalStream

   [[PendingOperation]]

   null

   [[Transport]]

   transport

   [[SendGroup]]

   sendGroup

   [[SendOrder]]

   sendOrder

   [[AtomicWriteRequests]]

   空の順序付き集合のpromise

   [[InsideSynchronousAtomicWrite]]

   false

   [[BytesWritten]]

   0

   [[CommittedOffset]]

   0

2. writeAlgorithm を write chunk を stream に書き込むアクション（chunkを指定）とする。

3. closeAlgorithm を close stream とするアクションとする。

4. abortAlgorithm を abort reason を指定して stream を中断するアクションとする。

5. セットアップ stream に、 writeAlgorithm を writeAlgorithm に、 closeAlgorithm を closeAlgorithm に、 abortAlgorithm を abortAlgorithm に設定して実行する。

6. abortSignal を stream の [[controller]].[[abortController]].[[signal]] とする。

7. Add 以下の手順を abortSignal に追加する：

   1. pendingOperation を stream.[[PendingOperation]] とする。

   2. pendingOperation が null ならこれ以降中止。

   3. stream.[[PendingOperation]] を null に設定。

   4. reason を abortSignal の abort reasonとする。

   5. promise を abort stream に reason を指定した結果とする。

   6. fulfillment時に promise がresolveされたら reject pendingOperation を reason で返す。

8. append stream を transport.[[SendStreams]] に追加する。

9. stream を返す。

1. transport を stream.[[Transport]] とする。

2. chunk が BufferSource でない場合、 TypeError で拒否された promiseを返す。

3. promise を新しい promise とする。

4. bytes を、chunk が表す バイト シーケンスのコピーとする。

5. bytes の長さが 0 である場合、 promise を undefined で解決し、 promise を返す。

6. stream.[[PendingOperation]] を promise に設定する。

7. inFlightWriteRequest を stream.inFlightWriteRequest とする。

8. atomic を、stream.[[AtomicWriteRequests]] が inFlightWriteRequest を含むか、または stream.[[InsideSynchronousAtomicWrite]] が true である場合は true、そうでなければ false とする。

9. 次の手順を並列に実行する：

   1. atomic が true であり、現在のフロー 制御ウィンドウが、bytes を全体として送信するには小さすぎる場合、 残りの手順を中止し、transport で ネットワークタスクをキューに入れ、 次の副手順を実行する：

      1. stream.[[PendingOperation]] を null に設定する。

      2. stream 上のすべての アトミック書き込みリクエストを中止する。

   2. そうでない場合、stream.[[InternalStream]] 上で bytes を送信し、 その操作の完了を待つ。 この送信は送信順序規則に従わなければならない。

      ユーザーエージェントは、転送性能を向上させるためにバッファを持ってもよい。そのようなバッファは、 WebTransportSendStream の利用者へバックプレッシャー情報を伝えるため、固定された上限を持つべきである。

      ここでは stream.[[SendOrder]] に並列にアクセスする。 ユーザーエージェントは送信中、これらの値のライブ更新に応答するべきであるが、 詳細は実装定義である。

      注：再送信の順序付けは 実装定義であるが、 ユーザーエージェントには、より高い [[SendOrder]] 値を持つデータの再送信を優先することが強く推奨される。

      この送信は、フロー制御上の理由またはエラーを除き、 他の送信を飢餓状態にしてはならない。

      ユーザーエージェントは、飢餓状態でないすべてのストリーム間で帯域幅を公平に分割するべきである。

      注：ここでの公平性の定義は 実装定義である。

   3. 前の手順がネットワークエラーにより失敗した場合、残りの手順を中止する。

      注：ここでは promise を拒否しない。これは、ネットワークエラーを別の箇所で処理し、 それらの手順が stream.[[PendingOperation]] を拒否するためである。

   4. そうでない場合、transport でネットワークタスクをキューに入れ、 次の手順を実行する：

      1. stream.[[PendingOperation]] を null に設定する。

      2. bytes の長さを stream.[[BytesWritten]] に加算する。

      3. stream.[[AtomicWriteRequests]] が inFlightWriteRequest を含む場合、inFlightWriteRequest を削除する。

      4. promise を undefined で解決する。

10. promise を返す。

注：このアルゴリズム（または write(chunk)） から返される promise の履行は、 その chunk がサーバーによって ack されたことを必ずしも意味しない [QUIC]。単にその chunk がバッファに追加されたことを意味するだけの場合がある。 chunk がサーバーに到達したことを確認するには、サーバーがアプリケーションレベルの確認応答メッセージを送る必要がある。

1. transport を stream.[[Transport]] とする。

2. promise を新しい promise とする。

3. stream を transport.[[SendStreams]] から削除する。

4. stream.[[PendingOperation]] を promise に設定する。

5. 次の手順を並列に実行する：

   1. stream.[[InternalStream]] 上で FIN を送信し、 その操作の完了を待つ。

   2. stream.[[InternalStream]] が「すべてのデータがコミット済み」状態に入るまで待つ。[QUIC]

   3. transport でネットワークタスクをキューに入れ、 次の手順を実行する：

      1. stream.[[PendingOperation]] を null に設定する。

      2. promise を undefined で解決する。

6. promise を返す。

1. transport を stream.[[Transport]] とする。

2. promise を新しい promise とする。

3. code を 0 とする。

4. stream を transport.[[SendStreams]] から削除する。

5. reason が WebTransportError であり、かつ reason.[[StreamErrorCode]] が null でない場合、code を reason.[[StreamErrorCode]] に設定する。

6. code < 0 の場合、code を 0 に設定する。

7. code > 4294967295 の場合、code を 4294967295 に設定する。

8. committedOffset を stream.[[CommittedOffset]] とする。

   注：code の有効な値は 0 から 4294967295 まで（両端を含む）である。下位接続が HTTP/3 を使用している場合、その code は [WEB-TRANSPORT-HTTP3] に記述されているように、[0x52e4a40fa8db, 0x52e5ac983162] 内の数値へ符号化される。

9. 次の手順を並列に実行する：

   1. code および committedOffset を用いて、 stream.[[InternalStream]] 上の送信を中止する。

   2. promise を undefined で解決するため、 transport でネットワークタスクをキューに入れる。

10. promise を返す。

1. writeRequests を stream.writeRequests とする。

2. requestsToAbort を stream.[[AtomicWriteRequests]] とする。

3. writeRequests が、requestsToAbort 内にない promise を含む場合、 AbortError を用いて stream をエラーにし、 これらの手順を中止する。

4. stream.[[AtomicWriteRequests]] を空にする。

5. requestsToAbort 内の各 promise について反復し、 promise を AbortError で拒否する。

6. 並列に、requestsToAbort 内の各 promise について反復し、 promise に関連付けられたバイトの 送信を中止する。

1. transport を stream.[[Transport]] とする。

2. code を、受信中止シグナルに付加されたアプリケーションプロトコルエラーコードとする。

   注：code の有効な値は 0 から 4294967295 まで（両端を含む）である。下位接続が HTTP/3 を使用している場合、その code は [WEB-TRANSPORT-HTTP3] に記述されているように、[0x52e4a40fa8db, 0x52e5ac983162] 内の数値へ符号化される。

3. transport で ネットワークタスクをキューに入れ、 次の手順を実行する：

   1. transport.[[State]] が "closed" または "failed" である場合、これらの手順を中止する。

   2. stream を transport.[[SendStreams]] から削除する。

   3. error を、新たに 作成された WebTransportError とし、その source は "stream" であり、 streamErrorCode は code であるものとする。

   4. stream.[[PendingOperation]] が null でない場合、stream.[[PendingOperation]] を error で拒否する。

   5. stream を error でエラーにする。

getStats()

this sendGroup の下にグループ化されたすべての WebTransportSendStream から統計を集約し、その結果を非同期に報告する。

呼び出されたとき、ユーザーエージェントは次の手順を実行しなければならない：

1. transport を this.[[Transport]] とする。

2. p を新しい promise とする。

3. streams を、その [[SendGroup]] が this であるすべての WebTransportSendStream とする。

4. 次の手順を並列に実行する：

   1. gatheredStats を、 WebTransportSendStreamStats の辞書メンバーを正確に埋めるために必要な、 streams 内のすべてのストリームから集約された統計の リストとする。

   2. transport でネットワークタスクをキューに入れ、 次の手順を実行する：

      1. stats を新しい WebTransportSendStreamStats オブジェクトとする。

      2. ユーザーエージェントが公開したい stats の各メンバー member について、 member を gatheredStats 内の対応する エントリに設定する。

      3. p を stats で解決する。

5. p を返す。

SendGroup を作成するには、 WebTransportSendGroup と WebTransport transport を用いて、以下の手順を実行する：

1. sendGroup を 新しい WebTransportSendGroup とし、次のように初期化する：

   [[Transport]]

   transport

2. sendGroup を返す。

getStats()

この WebTransportReceiveStream の 性能に固有の統計を収集し、 結果を非同期に報告する。

呼び出されたとき、ユーザーエージェントは次の手順を実行しなければならない：

1. transport を this.[[Transport]] とする。

2. p を新しい promise とする。

3. 次の手順を並列に実行する：

   1. gatheredStats を、 WebTransportReceiveStreamStats の辞書メンバーを正確に埋めるために必要な、 this WebTransportReceiveStream に固有の統計の リストとする。

   2. transport でネットワークタスクをキューに入れ、 次の手順を実行する：

      1. stats を新しい WebTransportReceiveStreamStats オブジェクトとする。

      2. ユーザーエージェントが公開したい stats の各メンバー member について、 member を gatheredStats 内の対応する エントリに設定する。

      3. p を stats で解決する。

4. p を返す。

受信用単方向または双方向の WebTransport ストリーム internalStream と、WebTransport transport を用いて、 WebTransportReceiveStream を作成するには、次の手順を実行する：

1. stream を、次を持つ新しい WebTransportReceiveStream とする：

   [[InternalStream]]

   internalStream

   [[Transport]]

   transport

2. pullAlgorithm を、stream からバイトをプルする動作とする。

3. cancelAlgorithm を、reason が与えられたときに reason で stream をキャンセルする動作とする。

4. stream をバイト読み取りサポート付きで セットアップし、 pullAlgorithm を pullAlgorithm に設定し、 cancelAlgorithm を cancelAlgorithm に設定する。

5. stream を transport.[[ReceiveStreams]] に追加する。

6. stream を返す。

WebTransportReceiveStream stream からバイトをプルするには、次の手順を実行する。

1. transport を stream.[[Transport]] とする。

2. internalStream を stream.[[InternalStream]] とする。

3. promise を新しい promise とする。

4. buffer、offset、および maxBytes を null とする。

5. stream に対する stream の現在の BYOB リクエストビューが null でない場合：

   1. offset を stream の現在の BYOB リクエスト ビュー.[[ByteOffset]] に設定する。

   2. maxBytes を stream の現在の BYOB リクエスト ビューの byte lengthに設定する。

   3. buffer を stream の現在の BYOB リクエスト ビューの 下位バッファに設定する。

6. そうでない場合：

   1. offset を 0 に設定する。

   2. maxBytes を実装定義のサイズに設定する。

   3. buffer を、maxBytes サイズを持つ新しい ArrayBuffer とする。ArrayBuffer の割り当てに失敗した場合、 RangeError で拒否された promiseを返す。

7. 次の手順を並列に実行する：

   1. internalStream から読み取られたバイトを、 offset のオフセットで buffer に、最大 maxBytes バイトまで書き込む。少なくとも 1 バイトが読み取られるか、 FIN が受信されるまで待つ。read を読み取られたバイト数とし、 hasReceivedFIN を FIN が伴っていたかどうかとする。

      ユーザーエージェントは、転送性能を向上させるためにバッファを持ってもよい。そのようなバッファは、 サーバーにバックプレッシャー情報を伝えるため、固定された上限を持つべきである。

      注：この操作は、 buffer 全体を埋める前に返る場合がある。

   2. 前の手順が失敗した場合、残りの手順を中止する。

      注：ここでは promise を拒否しない。これは、ネットワークエラーを別の箇所で処理し、 それらの手順が stream をエラーにし、このプルを待っているすべての read リクエストを拒否するためである。

   3. transport でネットワークタスクをキューに入れ、 次の手順を実行する：

      注：上で説明したバッファが、 この手続きが実行されているイベントループで利用可能である場合、 次の手順はただちに実行されることがある。

      1. read > 0 の場合：

         1. view を、buffer、offset、および read を持つ新しい Uint8Array とする。

         2. view を stream にキュー投入する。

      2. hasReceivedFIN が true の場合：

         1. stream を transport.[[ReceiveStreams]] から削除する。

         2. stream を閉じる。

      3. promise を undefined で解決する。

8. promise を返す。

WebTransportReceiveStream stream を reason でキャンセルするには、次の 手順を実行する。

1. transport を stream.[[Transport]] とする。

2. internalStream を stream.[[InternalStream]] とする。

3. promise を新しい promise とする。

4. code を 0 とする。

5. reason が WebTransportError であり、かつ reason.[[StreamErrorCode]] が null でない場合、code を reason.[[StreamErrorCode]] に設定する。

6. code < 0 の場合、code を 0 に設定する。

7. code > 4294967295 の場合、code を 4294967295 に設定する。

   注：code の有効な値は 0 から 4294967295 まで（両端を含む）である。下位接続が HTTP/3 を使用している場合、その code は [WEB-TRANSPORT-HTTP3] に記述されているように、[0x52e4a40fa8db, 0x52e5ac983162] 内の数値へ符号化される。

8. stream を transport.[[SendStreams]] から削除する。

9. 次の手順を並列に実行する：

   1. code を用いて internalStream 上の 受信を中止する。

   2. transport でネットワークタスクをキューに入れ、 次の手順を実行する：

      注：上で説明したバッファが、 この手続きが実行されているイベントループで利用可能である場合、 次の手順はただちに実行されることがある。

      1. stream を transport.[[ReceiveStreams]] から削除する。

      2. promise を undefined で解決する。

10. promise を返す。

1. transport を stream.[[Transport]] とする。

2. code を、送信中止シグナルに付加されたアプリケーションプロトコルエラーコードとする。

   注：code の有効な値は 0 から 4294967295 まで（両端を含む）である。下位接続が HTTP/3 を使用している場合、その code は [WEB-TRANSPORT-HTTP3] に記述されているように、[0x52e4a40fa8db, 0x52e5ac983162] 内の数値へ符号化される。

3. transport で ネットワークタスクをキューに入れ、 次の手順を実行する：

   1. transport.[[State]] が "closed" または "failed" である場合、これらの手順を中止する。

   2. stream を transport.[[ReceiveStreams]] から削除する。

   3. error を、新たに 作成された WebTransportError とし、その source は "stream" であり、 streamErrorCode は code であるものとする。

   4. stream を error でエラーにする。

1. readable を WebTransportReceiveStream の生成 （引数 internalStream, transport） の結果とする。

2. writable を WebTransportSendStream の生成 （引数 internalStream, transport, sendOrder） の結果とする。

3. stream を 新しい WebTransportBidirectionalStream （以下のスロットを持つ）とする：

   [[Readable]]

   readable

   [[Writable]]

   writable

   [[Transport]]

   transport

4. stream を返す。

atomicWrite(chunk)

atomicWrite メソッドは、それに与えられた chunk を、送信時点で現在の フロー制御 ウィンドウ内で全体として送信できなかった場合に拒否する。この挙動は、 フロー制御 デッドロックに敏感なニッチなトランザクション用途を満たすよう設計されている （[RFC9308] セクション 4.4）。

注：atomicWrite は、一部のデータを送信した後でも拒否される可能性がある。これは フロー制御に関してアトミック性を提供するが、他のエラーが発生することもある。 atomicWrite は、データがパケット間で分割されたり、 他のデータとインターリーブされたりすることを防がない。 利用可能なフロー制御クレジットの不足により atomicWrite が失敗したかどうかを知るのは送信側だけである。

注：アトミック書き込みは、 非アトミック書き込みの後ろにキュー投入されている場合、依然としてブロックされることがある。 そのアトミック書き込みが拒否された場合、その時点でその後ろにキュー投入されているものは すべて同様に拒否される。このように拒否された非アトミック書き込みはすべて、 ストリームをエラーにする。したがってアプリケーションには、 常にアトミック書き込みを await することが推奨される。

呼び出されたとき、ユーザーエージェントは次の手順を実行しなければならない：

1. stream を this.stream とする。

2. stream が undefined である場合、 TypeError で拒否された promiseを返す。

3. stream.[[InsideSynchronousAtomicWrite]] を true に設定する。

4. p を、chunk を this に書き込む結果とする。

5. stream.[[InsideSynchronousAtomicWrite]] を false に設定する。

6. p を stream.[[AtomicWriteRequests]] に追加する。

7. 次の手順で p に反応する結果を返す：

   1. stream.[[AtomicWriteRequests]] が p を含む場合、 p を削除する。

   2. p が理由 r で拒否された場合、 r で拒否された promiseを返す。

   3. undefined を返す。

commit()

commit メソッドはストリームの [[CommittedOffset]] を、そのストリームに書き込んだバイト数 （[[BytesWritten]]） に更新します。 これにより、書き込み中断後（stream の abort による 送信中断）でも そのバイトはピアに確実に配送されます。 この仕組みは [RELIABLE-RESET] で解説されています。

注記: これは接続障害時の配送は保証せず、 ストリームの 送信中断 時のみ保証します。

commit が stream で呼ばれた時、ユーザーエージェントは次を実行する：

1. stream.[[CommittedOffset]] を stream.[[BytesWritten]] の値に更新する。

WebTransportWriter を、 WebTransportWriter、 WebTransportSendStream stream でもって作成するには、次の手順を実行する：

1. writer を 新しい WebTransportWriter とする。

2. stream 用に writer を設定する。

3. writer を返す。

new WebTransportError(message, options) コンストラクタ手順：

1. this の name を "WebTransportError" に設定する。

2. this の message を message に設定する。

3. this の内部スロットを次のように設定：

   [[Source]]

   options.source

   [[StreamErrorCode]]

   options.streamErrorCode

   注記: この name には従来コードへの対応付けがないため、 this の code は 0 になる。