<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE rfc [
  <!ENTITY nbsp    "&#160;">
  <!ENTITY zwsp   "&#8203;">
  <!ENTITY nbhy   "&#8209;">
  <!ENTITY wj     "&#8288;">
]>
<?xml-stylesheet type="text/xsl" href="rfc2629.xslt" ?>
<!-- generated by https://github.com/cabo/kramdown-rfc version 1.7.43 (Ruby 3.4.12) -->
<rfc xmlns:xi="http://www.w3.org/2001/XInclude" ipr="trust200902" docName="draft-spk-httpbis-parallel-upload-01" category="std" consensus="true" submissionType="IETF" tocInclude="true" sortRefs="true" symRefs="true" version="3">
  <!-- xml2rfc v2v3 conversion 3.35.0 -->
  <front>
    <title abbrev="Parallel Resumable Uploads">Parallel Appends for Resumable Uploads</title>
    <seriesInfo name="Internet-Draft" value="draft-spk-httpbis-parallel-upload-01"/>
    <author fullname="Santosh Pallagatti">
      <organization>Zscaler</organization>
      <address>
        <email>santosh.pallagatti@gmail.com</email>
      </address>
    </author>
    <author fullname="Akshat Maheshwari">
      <organization>Zscaler</organization>
      <address>
        <email>akshatmaheshwari1995@gmail.com</email>
      </address>
    </author>
    <author fullname="Yaroslav Rosomakho">
      <organization>Zscaler</organization>
      <address>
        <email>yaroslavros@gmail.com</email>
      </address>
    </author>
    <date year="2026" month="November" day="18"/>
    <area>Web and Internet Transport</area>
    <workgroup>HTTP</workgroup>
    <keyword>resumable upload</keyword>
    <keyword>parallel upload</keyword>
    <keyword>intermediary</keyword>
    <keyword>content inspection</keyword>
    <abstract>
      <?line 63?>

<t>The resumable upload protocol lets a client continue an interrupted
upload, but the upload has to be sent in order, one request at a time.
This document extends that protocol so that a client can send different
parts of the same upload in parallel. Servers and intermediaries can
limit both the number of concurrent requests and the amount of data
that arrives out of order. The document also describes how
intermediaries that inspect uploads (for data loss prevention or
malware scanning, say) can continue to do so, and how the extension
behaves over HTTP/1.1, HTTP/2, and HTTP/3.</t>
    </abstract>
    <note removeInRFC="true">
      <name>About This Document</name>
      <t>
        The latest revision of this draft can be found at <eref target="https://santoshpallagatti.github.io/draft-spk-httpbis-parallel-upload/draft-spk-httpbis-parallel-upload.html"/>.
        Status information for this document may be found at <eref target="https://datatracker.ietf.org/doc/draft-spk-httpbis-parallel-upload/"/>.
      </t>
      <t>
        Discussion of this document takes place on the
        HTTP Working Group mailing list (<eref target="mailto:ietf-http-wg@w3.org"/>),
        which is archived at <eref target="https://lists.w3.org/Archives/Public/ietf-http-wg/"/>.
      </t>
      <t>Source for this draft and an issue tracker can be found at
        <eref target="https://github.com/santoshpallagatti/draft-spk-httpbis-parallel-upload"/>.</t>
    </note>
  </front>
  <middle>
    <?line 76?>

<section anchor="introduction">
      <name>Introduction</name>
      <t>The resumable upload protocol <xref target="RESUMABLE"/> lets a client continue an
interrupted upload instead of starting over. Its state is a single
offset: all bytes before the offset have been stored, and each append
has to start exactly at that offset. <xref section="4.6" sectionFormat="of" target="RESUMABLE"/>
forbids a client from transferring data for the same upload in
parallel.</t>
      <t>HTTP has had a standard mechanism for parallel downloads since
HTTP/1.1: a client requests different byte ranges of the same resource
at the same time using the Range header field
(<xref section="14.2" sectionFormat="of" target="RFC9110"/>), and download managers and cloud storage
clients rely on it. Uploads have no counterpart.
<xref section="14.5" sectionFormat="of" target="RFC9110"/> describes
Content-Range in a PUT request but leaves its handling undefined, and
<xref target="RESUMABLE"/> requires appends to be sequential.</t>
      <t>Parallel uploads are nevertheless widely deployed in service-specific
forms: cloud storage APIs, and the Concatenation extension of the tus
protocol <xref target="TUS"/>, upload parts as separate resources and join them at
the end. What is missing is a standard way for a client to send several
byte ranges of one upload at the same time. The Byte Range PATCH draft
<xref target="BYTERANGE"/> mentions parallel uploads and leaves them for "a later
document".</t>
      <t>This document defines such an extension for <xref target="RESUMABLE"/>. A client
asks for parallel mode when it creates the upload (<xref target="negotiation"/>) and
then sends appends for different byte ranges at the same time, within a
window (<xref target="appends"/>). The server reports which ranges it has in a new
response field (<xref target="upload-received"/>), and <xref target="completion"/> says when the
upload is complete. Requirements for servers and for intermediaries are
in <xref target="server-reqs"/> and <xref target="intermediary-reqs"/>.</t>
      <t>Unless this document says otherwise (<xref target="updates"/>), all rules of
<xref target="RESUMABLE"/> still apply. A client or server that does not implement
this extension simply keeps using the sequential protocol.</t>
      <section anchor="use-cases">
        <name>Use Cases</name>
        <t>The main motivation is large uploads over paths where a single
connection cannot use the available bandwidth: video and audio, disk
images and backups, and datasets or model files that often run to
several gigabytes. <xref target="h2h3"/> explains which parts of the gain come from
parallel appends on one connection and which need several
connections.</t>
        <t>Uploads to AI services are a growing case. Users attach documents,
recordings, and video for a model to analyze, and the model cannot
start until the upload has finished, so upload time shows up directly
as waiting time. For small files the gain from parallel appends is
small, because connection setup and round trips dominate. For large
inputs it can be significant.</t>
        <t>The same trend affects organizations that inspect outbound uploads,
including uploads to AI services, to keep sensitive data from leaving
their networks. Their proxies have to handle more and larger uploads
with limited memory, and must not let a file be committed before it
has been checked. <xref target="inspecting"/> describes how they can do that.</t>
        <t>Mobile clients benefit as well. Their connections drop and change
often, and with this extension only the missing ranges need to be sent
again.</t>
      </section>
    </section>
    <section anchor="conventions-and-definitions">
      <name>Conventions and Definitions</name>
      <t>The key words "<bcp14>MUST</bcp14>", "<bcp14>MUST NOT</bcp14>", "<bcp14>REQUIRED</bcp14>", "<bcp14>SHALL</bcp14>", "<bcp14>SHALL
NOT</bcp14>", "<bcp14>SHOULD</bcp14>", "<bcp14>SHOULD NOT</bcp14>", "<bcp14>RECOMMENDED</bcp14>", "<bcp14>NOT RECOMMENDED</bcp14>",
"<bcp14>MAY</bcp14>", and "<bcp14>OPTIONAL</bcp14>" in this document are to be interpreted as
described in BCP 14 <xref target="RFC2119"/> <xref target="RFC8174"/> when, and only when, they
appear in all capitals, as shown here.</t>
      <?line -18?>

<t>This document uses the terms "upload resource", "append", "upload
creation", "offset retrieval", and "upload cancellation" as defined in
<xref target="RESUMABLE"/>, and the terms "client", "server", "intermediary",
"proxy", and "gateway" as defined in <xref target="RFC9110"/>. Structured Field
types (Boolean, Integer, Token, List, Inner List, Dictionary) are
defined in <xref target="RFC9651"/>.</t>
      <t>The following terms are also used:</t>
      <dl>
        <dt>Parallel mode:</dt>
        <dd>
          <t>The mode of an upload for which the extension defined in this
document has been negotiated.</t>
        </dd>
        <dt>Contiguous offset (C):</dt>
        <dd>
          <t>The number of bytes, starting at byte 0, that have been received
without a gap. This is the value that <xref target="RESUMABLE"/> conveys in the
Upload-Offset field.</t>
        </dd>
        <dt>Reorder window (W):</dt>
        <dd>
          <t>The maximum distance, in bytes, beyond the contiguous offset at which
an append may end. See <xref target="window"/>.</t>
        </dd>
        <dt>Received ranges:</dt>
        <dd>
          <t>The set of byte ranges of the upload that the server has received and
stored.</t>
        </dd>
        <dt>Tail append:</dt>
        <dd>
          <t>The append that carries Upload-Complete set to true. With explicit
commit it is an empty append at the upload length. With automatic
commit it is normally the data append that ends at the upload length,
although an empty append at the upload length is also accepted (see
<xref target="completion"/>). Without it the upload cannot complete.</t>
        </dd>
        <dt>Inspecting intermediary:</dt>
        <dd>
          <t>An intermediary that examines the content of an upload before
allowing it to reach or be committed at the server, typically to
apply data loss prevention (DLP) or malware scanning policy.</t>
        </dd>
      </dl>
      <t>Byte ranges in this document are written as [start, end), meaning the
range includes start and excludes end. "MiB" means 1,048,576 bytes.</t>
    </section>
    <section anchor="overview">
      <name>Overview</name>
      <t>A client asks for parallel mode when it creates an upload. The server,
and any intermediary on the path, answer with the limits they accept:
how many appends may be in progress at once, how large the reorder
window is, or both. Intermediaries can only make these limits stricter.</t>
      <t>The client then sends several appends at the same time, each covering
its own byte range. Every append has to end within the reorder window,
which starts at the contiguous offset. As gaps at the start of the
window fill, the contiguous offset advances and the window slides
forward. The server reports the ranges it holds in the Upload-Received
field, so a client that loses an append re-sends only the missing
range. The upload completes when the received ranges cover the whole
upload.</t>
      <figure anchor="fig-window">
        <name>The Reorder Window</name>
        <artwork type="ascii-art"><![CDATA[
 0                 C                              C+W        Length
 |=================|----+=====+------+=====+------|----------|
   all received     gap  recv   gap    recv  gap    outside
                   |<------ reorder window ------>|  window
]]></artwork>
      </figure>
      <t><xref target="fig-overview"/> shows a 12 MiB upload sent as 2 MiB appends with a
window of 6 MiB and at most three appends in progress.</t>
      <figure anchor="fig-overview">
        <name>Parallel Upload Overview</name>
        <artwork type="ascii-art"><![CDATA[
Client                                   Server
  |  POST /files                            |
  |  Upload-Parallel: ?1                    |
  |  Upload-Length: 12582912                |
  |---------------------------------------->|
  |  201 Created                            |
  |  Location: /uploads/abc                 |
  |  Upload-Limit: max-parallel=3,          |
  |                reorder-window=6291456   |
  |<----------------------------------------|
  |  PATCH, Upload-Offset: 0         ------>|  \
  |  PATCH, Upload-Offset: 2097152   ------>|   > concurrent,
  |  PATCH, Upload-Offset: 4194304   ------>|  /  window [0, 6 MiB)
  |<------------------ 204 (three times) ---|
  |  PATCH, Upload-Offset: 6291456   ------>|  \
  |  PATCH, Upload-Offset: 8388608   ------>|   > window slid to
  |  PATCH, Upload-Offset: 10485760  ------>|  /  [6 MiB, 12 MiB)
  |         Upload-Complete: ?1             |
  |<----------- 204, 204, 201 Created ------|  upload complete
]]></artwork>
      </figure>
      <t>Inspecting intermediaries use the same window to process content in
order with bounded memory, and hold the tail append until they reach a
verdict (<xref target="inspecting"/>).</t>
    </section>
    <section anchor="negotiation">
      <name>Negotiating Parallel Mode</name>
      <section anchor="upload-parallel">
        <name>The Upload-Parallel Request Field</name>
        <t>The Upload-Parallel request header field is a Boolean <xref target="RFC9651"/>. A
client sends it with the value true in an upload creation request to
ask for parallel mode:</t>
        <sourcecode type="http-message"><![CDATA[
Upload-Parallel: ?1
]]></sourcecode>
        <t>A client that sends Upload-Parallel with the value true <bcp14>MUST</bcp14> also send
Upload-Length in the same request. Parallel mode requires the total
length to be known before appends arrive out of order. A server that
receives Upload-Parallel without Upload-Length <bcp14>MUST</bcp14> treat the upload as
sequential.</t>
        <t>A client <bcp14>MAY</bcp14> create the upload with an empty body: a POST carrying
Upload-Parallel, Upload-Length, Upload-Complete set to false, and no
content. The response gives the client the Location of the upload
resource and the Upload-Limit field, so it knows the upload URI and the
limits that apply, that is how many appends may be in flight, the
reorder window, any alignment, and the commit mode, before it sends any
content. All content is then sent in appends.</t>
        <sourcecode type="http-message"><![CDATA[
POST /files HTTP/1.1
Host: example.com
Upload-Parallel: ?1
Upload-Length: 12582912
Upload-Complete: ?0
Content-Length: 0

HTTP/1.1 201 Created
Location: /uploads/abc
Upload-Limit: max-parallel=3, reorder-window=6291456
]]></sourcecode>
        <t>This is <bcp14>RECOMMENDED</bcp14> when HTTP/1.1 is used, because <xref target="RESUMABLE"/>
otherwise carries the upload URI in a 104 (Upload Resumption Supported)
interim response, which some intermediaries do not forward
(<xref target="http11"/>).</t>
      </section>
      <section anchor="limits">
        <name>Upload-Limit Parameters</name>
        <t>This document defines the following parameters for the Upload-Limit
response field of <xref target="RESUMABLE"/>:</t>
        <dl newline="true">
          <dt>max-parallel:</dt>
          <dd>
            <t>An Integer. The maximum number of appends to this upload that may be
in progress at the same time. A value of 1 in the upload creation
response means the upload is sequential (<xref target="fallback"/>). If the
parameter is absent, this field places no limit on the number of
appends; concurrency is then bounded only by the reorder window and by
what the server accepts at the time (<xref target="server-window"/>).</t>
          </dd>
          <dt>reorder-window:</dt>
          <dd>
            <t>An Integer. The reorder window W in bytes. If absent, the window is
unlimited, that is, equal to the upload length.</t>
          </dd>
          <dt>append-alignment:</dt>
          <dd>
            <t>An Integer. The offset of every append, and the length of every
append except the tail append, <bcp14>MUST</bcp14> be a multiple of this value. If
absent, no alignment applies.</t>
          </dd>
          <dt>commit:</dt>
          <dd>
            <t>A Token, either "auto" or "explicit". See <xref target="completion"/>. If absent,
the value is "auto".</t>
          </dd>
        </dl>
        <t>A server that accepts parallel mode <bcp14>MUST</bcp14> include at least one of
max-parallel with a value greater than 1, or reorder-window, in the
Upload-Limit field of the upload creation response, and <bcp14>MUST</bcp14> include
its current values of these parameters in every later Upload-Limit
field it sends for the upload, including in offset retrieval
responses. A server that cares only about how much
out-of-order data it has to hold can send reorder-window alone; one
that cares only about the number of concurrent requests can send
max-parallel alone.</t>
      </section>
      <section anchor="tightening">
        <name>Tightening by Intermediaries</name>
        <t>An intermediary <bcp14>MAY</bcp14> modify the Upload-Limit field in a response it
forwards, but only in ways that make the limits stricter:</t>
        <ul spacing="normal">
          <li>
            <t>it <bcp14>MAY</bcp14> lower max-parallel, or add it if absent;</t>
          </li>
          <li>
            <t>it <bcp14>MAY</bcp14> lower reorder-window, or add it if absent;</t>
          </li>
          <li>
            <t>it <bcp14>MAY</bcp14> replace append-alignment with a multiple of the current value,
or add it if absent;</t>
          </li>
          <li>
            <t>it <bcp14>MAY</bcp14> change commit from "auto" to "explicit".</t>
          </li>
        </ul>
        <t>An intermediary <bcp14>MUST NOT</bcp14> raise max-parallel or reorder-window, remove
any of these parameters, or change commit from "explicit" to "auto".
Because each hop can only tighten the limits, the values a client
receives are the strictest on the path.</t>
        <t>Only the party that has to satisfy a limit can raise it. Replacing
append-alignment with a multiple of its current value is a further
restriction on the client, not a new permission, which is why an
intermediary may do it. Raising max-parallel or reorder-window would
commit the server to work it has not agreed to, so an intermediary
cannot do that even though it could reassemble the data itself. An
intermediary that takes over parallel mode on the client-facing hop
(<xref target="translation"/>) is a different case: there it acts as the server, and
it <bcp14>MAY</bcp14> advertise its own limits, including larger ones, because it
services them itself.</t>
        <t>An intermediary that tightens a limit <bcp14>MUST</bcp14> enforce the value it
advertised. The server knows only its own limits, so it would accept an
append that breaks a tighter one. The intermediary therefore rejects or
delays such an append itself, in the same way a server does
(<xref target="server-window"/>, <xref target="h2h3-flow"/>).</t>
        <t>Changing commit from "auto" to "explicit" works with any server that
implements this document, because such a server accepts an empty
append as the tail append in either mode (<xref target="completion"/>). An
intermediary that makes this change tracks which ranges the server has
received and applies the explicit-commit rules toward the client: if
the client sends the commit request while ranges are still missing, the
intermediary responds with 409 (Conflict) and "incomplete-ranges"
instead of forwarding it (<xref target="commit-explicit"/>).</t>
      </section>
      <section anchor="fallback">
        <name>Falling Back to Sequential Uploads</name>
        <t>An upload is in parallel mode if, and only if, the client sent
Upload-Parallel with the value true and the Upload-Limit field in the
response to upload creation contains either max-parallel with a value
greater than 1, or reorder-window without max-parallel. A max-parallel
value of 1 in that response always means sequential, even when
reorder-window is also present. In every other case, client and server
<bcp14>MUST</bcp14> follow <xref target="RESUMABLE"/> without the changes in this document. This is
the only rule that decides the mode; other sections refer to it.</t>
        <t>The mode is fixed when the upload is created, but the limits can change
during the upload. Any response for the upload resource, whether to an
append or to offset retrieval, <bcp14>MAY</bcp14> carry a different Upload-Limit. Each
Upload-Limit field carries the complete current values: a parameter that
is absent from it has the default meaning given in <xref target="limits"/>, not its
previous value. A server <bcp14>MAY</bcp14> raise or lower its own limits. An
intermediary recomputes its values from each new value it receives from
upstream and still only tightens it (<xref target="tightening"/>). A client <bcp14>MUST</bcp14>
apply the most recent values to appends it starts after receiving them,
and a change never invalidates an append already in progress
(<xref target="server-window"/>). A later max-parallel of 1 limits the client to one
append at a time but does not end parallel mode; Upload-Received and the
other rules of this document still apply.</t>
      </section>
    </section>
    <section anchor="appends">
      <name>Parallel Appends</name>
      <section anchor="window">
        <name>The Reorder Window</name>
        <t>Let C be the contiguous offset, L the upload length, and W the reorder
window. In parallel mode, an append that covers bytes [o, o + n),
where n is the length of its content, is inside the window if and only
if:</t>
        <artwork type="ascii-art"><![CDATA[
    o + n <= min(C + W, L)
]]></artwork>
        <t>A client <bcp14>MUST NOT</bcp14> start an append that is outside the window as
computed from the most recent Upload-Offset it has received. Because C
only grows, an append that was inside the window when it started stays
inside it.</t>
        <t>A window equal to L allows unrestricted parallelism. A window equal to
the size of one append results in sequential behavior while still
permitting a new append to start as soon as the previous one
completes.</t>
      </section>
      <section anchor="append-requests">
        <name>Append Requests</name>
        <t>Appends in parallel mode use the PATCH method and the
application/partial-upload media type, as defined in <xref target="RESUMABLE"/>. The
Upload-Offset request field carries the offset o at which the content
starts; the content length gives n.</t>
        <t>In parallel mode, Upload-Offset in an append request is not required to
equal the server's current offset. It is the start of the byte range
the append writes. A client <bcp14>MUST</bcp14> send Content-Length on every append in
parallel mode, so that a recipient knows the full range before the
content arrives.</t>
        <t>If max-parallel is present, a client <bcp14>MUST NOT</bcp14> have more than that many
appends to the same upload in progress at once. An append is in
progress from when its request starts until its response is received
or the request is abandoned.</t>
        <t>A client <bcp14>SHOULD</bcp14> include a Content-Digest field <xref target="RFC9530"/> on each
append so that the server and intermediaries can verify each range on
its own.</t>
        <sourcecode type="http-message"><![CDATA[
PATCH /uploads/abc HTTP/1.1
Host: example.com
Content-Type: application/partial-upload
Upload-Offset: 4194304
Upload-Complete: ?0
Content-Length: 2097152
Content-Digest: sha-256=:(base64-encoded SHA-256 of the content):

[2097152 bytes]
]]></sourcecode>
      </section>
      <section anchor="overlap">
        <name>Overlapping and Repeated Ranges</name>
        <t>An append may overlap ranges the server has already received, for
example when a client retries an append whose response it did not
receive. Retrying a range with identical content is always safe.</t>
        <t>A server <bcp14>MAY</bcp14> discard overlapping bytes without comparing them. If a
server detects that overlapping bytes differ from the stored bytes
(using Content-Digest, say), it <bcp14>MUST</bcp14> reject the append with status 409
(Conflict) and the problem type "range-conflict" (<xref target="problems"/>).</t>
        <t>Two appends in flight for the same range with identical content are
not a conflict. The server treats the newer one as a retry of the older
(see below), and the range is stored once. The problem type
"range-conflict" applies only when overlapping bytes differ.</t>
        <t>If a new append overlaps a range that is being written by an append
still in progress, the server <bcp14>SHOULD</bcp14> terminate the older append before
processing the new one. This applies the rule of
<xref section="4.6" sectionFormat="of" target="RESUMABLE"/> per byte range instead of per upload: the
newer request is taken to be a retry of the older one. Bytes the older
append stored before termination remain received.</t>
      </section>
      <section anchor="interrupted">
        <name>Interrupted Appends</name>
        <t>When an append is interrupted, the server <bcp14>MAY</bcp14> keep the bytes it
received as a received range, as in <xref target="RESUMABLE"/>. In parallel mode,
this can leave a gap after the kept bytes. The client learns about the
gap through offset retrieval (<xref target="upload-received"/>) and re-sends only
the missing bytes.</t>
      </section>
    </section>
    <section anchor="upload-received">
      <name>Reporting Received Ranges</name>
      <t>The Upload-Received response header field is a List of Inner Lists
<xref target="RFC9651"/>. Each Inner List contains exactly two Integers, the start
and end of a received range [start, end):</t>
      <sourcecode type="http-message"><![CDATA[
Upload-Offset: 1048576
Upload-Received: (0 1048576), (2097152 6291456)
]]></sourcecode>
      <t>The ranges <bcp14>MUST</bcp14> be listed in ascending order and <bcp14>MUST NOT</bcp14> overlap or
touch; adjacent ranges are merged. If the contiguous offset is greater
than 0, the first range starts at 0 and ends at the contiguous offset.</t>
      <t>In parallel mode, a server <bcp14>MUST</bcp14> include Upload-Received in every offset
retrieval response and <bcp14>SHOULD</bcp14> include it in responses to appends. The
Upload-Offset field keeps the meaning defined in <xref target="RESUMABLE"/>: it is
the contiguous offset, and it never decreases.</t>
      <t>A server <bcp14>MUST NOT</bcp14> list a range it has not stored. A server <bcp14>MAY</bcp14> omit
ranges beyond the contiguous offset, for example to limit the size of
the field; the client then re-sends those bytes, which is safe
(<xref target="overlap"/>).</t>
    </section>
    <section anchor="completion">
      <name>Upload Completion</name>
      <t>In parallel mode an upload is complete when its received ranges cover
[0, L) and the server has received the tail append. The tail append is
the append that carries Upload-Complete with the value true. Every
other append <bcp14>MUST</bcp14> carry Upload-Complete with the value false.</t>
      <section anchor="commit-auto">
        <name>Automatic Commit</name>
        <t>When commit is "auto", the tail append is normally the data append that
ends at L. A client <bcp14>MUST</bcp14> set Upload-Complete to true on the append that
ends at L and on no other append. A server that receives Upload-Complete
set to true on an append that does not end at L <bcp14>MUST</bcp14> reject it with
status 400 (Bad Request).</t>
        <t>In either commit mode, a server <bcp14>MUST</bcp14> also accept an empty append at
offset L carrying Upload-Complete set to true as the tail append, if it
has not already received one. <xref target="RESUMABLE"/> already allows such an
append to complete an upload whose content has all arrived; accepting
it in automatic mode is what lets an intermediary change the commit
mode (<xref target="tightening"/>).</t>
        <t>If gaps remain when the tail append has been received, the server
responds to the tail append with 204 (No Content) and the current
Upload-Offset and Upload-Received. The upload completes when the last
gap is filled. The append that fills it receives the final response for
the upload, as described in <xref target="RESUMABLE"/>. Other appends receive 204
(No Content).</t>
      </section>
      <section anchor="commit-explicit">
        <name>Explicit Commit</name>
        <t>When commit is "explicit", every data append, including the one that
ends at L, carries Upload-Complete set to false. After the client has
received successful responses for all ranges, it sends an append with
empty content, Upload-Offset set to L, and Upload-Complete set to true.
That empty append is the tail append and receives the final response.</t>
        <t>If the server receives the tail append while gaps remain, it <bcp14>MUST</bcp14>
reject it with status 409 (Conflict), the problem type
"incomplete-ranges", and the Upload-Received field.</t>
        <t>Explicit commit separates receiving the data from committing it. It
lets a client check the whole representation, using Repr-Digest
<xref target="RFC9530"/>, before committing. It also keeps the tail append small,
which helps intermediaries that hold it (<xref target="hold-tail"/>).</t>
      </section>
    </section>
    <section anchor="updates">
      <name>Changes to Resumable Upload Rules in Parallel Mode</name>
      <t>For uploads in parallel mode only, this document changes the following
rules of <xref target="RESUMABLE"/>. Section numbers refer to version 13 of that
draft; each rule is also described in words, so that it can be found if
the numbering changes. All other rules apply unchanged.</t>
      <table anchor="tab-updates">
        <name>Rules Changed in Parallel Mode</name>
        <thead>
          <tr>
            <th align="left">Rule in RESUMABLE</th>
            <th align="left">Change in parallel mode</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td align="left">Section 4.6: a client must not transfer data for one upload in parallel</td>
            <td align="left">Several appends may be in progress, within the limits of <xref target="limits"/> (<xref target="append-requests"/>).</td>
          </tr>
          <tr>
            <td align="left">Section 4.6: a new request terminates the older one</td>
            <td align="left">Applies per overlapping byte range (<xref target="overlap"/>).</td>
          </tr>
          <tr>
            <td align="left">Section 4.4.2: Upload-Offset must match the current offset, otherwise 409</td>
            <td align="left">Any append inside the reorder window is accepted (<xref target="window"/>).</td>
          </tr>
          <tr>
            <td align="left">Upload-Complete marks the final append</td>
            <td align="left">Marks the tail append; completion requires full coverage (<xref target="completion"/>).</td>
          </tr>
        </tbody>
      </table>
      <t><xref target="RESUMABLE"/> is sequential for a good reason. Without negotiation, a
server cannot tell a deliberate concurrent append from a stale request
that the client gave up on, such as one left behind on a half-open
connection. Negotiating parallel mode removes that ambiguity, and
applying the termination rule per range keeps the protection against
stale requests.</t>
    </section>
    <section anchor="client-reqs">
      <name>Client Behavior</name>
      <ul spacing="normal">
        <li>
          <t>A client <bcp14>SHOULD</bcp14> choose append sizes that are multiples of
append-alignment and small enough that several fit inside the reorder
window.</t>
        </li>
        <li>
          <t>A client <bcp14>SHOULD</bcp14> keep the append that starts at the contiguous offset
in progress at all times, because the window cannot slide until that
range arrives.</t>
        </li>
        <li>
          <t>If the append at the contiguous offset is much slower than the
others, a client <bcp14>MAY</bcp14> replace it by sending the same range again on
another stream or connection. Because the server terminates the older
of two appends for the same range (<xref target="overlap"/>), the new request
replaces the old one rather than racing it, so the client <bcp14>SHOULD</bcp14>
cancel the old request when it sends the new one. Only the new request
then counts against max-parallel.</t>
        </li>
        <li>
          <t>After any failed or abandoned append, a client <bcp14>SHOULD</bcp14> perform offset
retrieval and re-send only ranges missing from Upload-Received.</t>
        </li>
        <li>
          <t>A client that receives status 409 with the problem type
"offset-outside-window" <bcp14>MUST</bcp14> wait until the contiguous offset has
advanced before retrying that range.</t>
        </li>
        <li>
          <t>A client <bcp14>SHOULD</bcp14> send Repr-Digest <xref target="RFC9530"/> for the whole
representation, either at upload creation or on the tail append.</t>
        </li>
        <li>
          <t>If a request for the upload resource fails with 404 (Not Found) or
410 (Gone), the upload no longer exists (<xref target="server-failure"/>) and a
client <bcp14>MUST</bcp14> create a new one rather than continue sending ranges.</t>
        </li>
      </ul>
    </section>
    <section anchor="server-reqs">
      <name>Server Requirements</name>
      <section anchor="server-state">
        <name>Upload State</name>
        <t>A server that supports parallel mode <bcp14>MUST</bcp14> track the received ranges of
each upload in parallel mode, and update them atomically: a range is
either fully recorded or not recorded at all. Offset retrieval
responses <bcp14>MUST</bcp14> reflect every range recorded before the request was
received.</t>
        <t>When requests for one upload can reach different server instances, for
example behind a load balancer, all instances <bcp14>MUST</bcp14> share a consistent
view of the received ranges, or requests for an upload <bcp14>MUST</bcp14> be routed
to a single instance.</t>
      </section>
      <section anchor="server-window">
        <name>Enforcing Limits</name>
        <t>A server <bcp14>MUST</bcp14> reject an append that is outside the reorder window with
status 409 (Conflict), the problem type "offset-outside-window", and
the current Upload-Offset, unless it delays the append as described in
<xref target="h2h3-flow"/>.</t>
        <t>A server <bcp14>MAY</bcp14> reject an append with status 429 (Too Many Requests), the
problem type "too-many-parallel", and a Retry-After field when accepting
it would exceed max-parallel or, if max-parallel is absent, the number
of concurrent appends the server can currently handle.</t>
        <t>A server <bcp14>MUST</bcp14> reject an append whose offset or length violates
append-alignment with status 400 (Bad Request) and the problem type
"misaligned-append".</t>
        <t>A server <bcp14>MAY</bcp14> raise or lower its limits during an upload, for example as
its load changes, and signals new values in its next responses
(<xref target="fallback"/>). It <bcp14>MUST NOT</bcp14> reject an append that was inside the limits
it last advertised when the append started solely because the limits
changed.</t>
      </section>
      <section anchor="server-storage">
        <name>Storage and Visibility</name>
        <t>A server <bcp14>MAY</bcp14> write ranges directly into a single sparse object or store
them separately and join them on completion. The choice is not visible
to clients.</t>
        <t>Until an upload is complete, a server <bcp14>MUST NOT</bcp14> make its content
available as the representation of any target resource, and <bcp14>MUST NOT</bcp14>
fill gaps with placeholder bytes that could be mistaken for uploaded
content. An upload that is cancelled or expires <bcp14>MUST</bcp14> be discarded
without being committed.</t>
        <t>If a Repr-Digest was provided, the server <bcp14>SHOULD</bcp14> verify it against the
joined content before committing and <bcp14>MUST NOT</bcp14> commit on a mismatch.</t>
      </section>
      <section anchor="server-resources">
        <name>Resource Management</name>
        <t>The reorder window bounds how much out-of-order data a server has to
buffer per upload. A server that buffers in memory <bcp14>SHOULD</bcp14> choose
reorder-window and max-parallel according to its memory budget, and
<bcp14>SHOULD</bcp14> also limit the number of concurrent uploads per client.</t>
      </section>
      <section anchor="server-failure">
        <name>Expiry, Failure, and Loss of State</name>
        <t>Uploads expire as described in <xref target="RESUMABLE"/>, and a server <bcp14>SHOULD</bcp14> state
its expiry through the max-age parameter of Upload-Limit so that
clients and intermediaries can bound how long they keep state for an
upload. An upload that expires or is cancelled <bcp14>MUST</bcp14> be discarded
without being committed (<xref target="server-storage"/>).</t>
        <t>Upload-Offset never decreases, and Upload-Received lists only ranges
the server holds. A server that loses recorded ranges, for example when
an instance without shared state restarts, therefore <bcp14>MUST NOT</bcp14> report a
smaller contiguous offset or fewer ranges for that upload. It <bcp14>MUST</bcp14>
instead fail subsequent requests for the upload resource with 404 (Not
Found) or 410 (Gone), so that the client creates a new upload rather
than completing one with missing bytes.</t>
      </section>
    </section>
    <section anchor="intermediary-reqs">
      <name>Intermediary Requirements</name>
      <section anchor="all-intermediaries">
        <name>All Intermediaries</name>
        <t>Appends in parallel mode are ordinary HTTP requests. An intermediary
that does not implement this document forwards them without change,
and parallel mode works through it.</t>
        <t>An intermediary that implements this document:</t>
        <ul spacing="normal">
          <li>
            <t><bcp14>MAY</bcp14> tighten Upload-Limit as described in <xref target="tightening"/>, and <bcp14>MUST
NOT</bcp14> loosen it;</t>
          </li>
          <li>
            <t><bcp14>MAY</bcp14> force sequential behavior by removing Upload-Parallel from an
upload creation request or by setting max-parallel to 1 in the upload
creation response (<xref target="fallback"/>);</t>
          </li>
          <li>
            <t><bcp14>MUST</bcp14> enforce any limit it tightens (<xref target="tightening"/>);</t>
          </li>
          <li>
            <t><bcp14>MUST NOT</bcp14> remove or alter Upload-Received, except as described in
<xref target="hold-tail-retrieval"/>;</t>
          </li>
          <li>
            <t>when it balances load across servers, <bcp14>MUST</bcp14> meet the consistency
requirement of <xref target="server-state"/>, for example by routing all requests
for an upload resource to the same server.</t>
          </li>
        </ul>
        <t>Responses to appends and to offset retrieval are not cacheable, as
specified in <xref target="RESUMABLE"/>; this is unchanged.</t>
      </section>
      <section anchor="translation">
        <name>Terminating Parallel Mode at an Intermediary</name>
        <t>An intermediary <bcp14>MAY</bcp14> accept parallel mode from clients while forwarding
the upload to the server sequentially, for example because the server
does not support this extension or is reached over a different HTTP
version. Such an intermediary acts as the server for parallel mode on
the client-facing hop: it <bcp14>MUST</bcp14> meet the requirements of
<xref target="server-reqs"/> for that hop, buffer out-of-order data within the
window it advertises, and forward bytes upstream in order as the
contiguous offset advances.</t>
      </section>
      <section anchor="inspecting">
        <name>Inspecting Intermediaries</name>
        <t>An inspecting intermediary examines upload content before it reaches,
or is committed at, the server. Such intermediaries only see content
where they already terminate TLS, usually under an enterprise policy.
This document does not change that.</t>
        <section anchor="in-order">
          <name>In-Order Processing</name>
          <t>Many inspection engines need content in order: file types are
recognized from the first bytes, and patterns can span append
boundaries. An inspecting intermediary that processes content in
order:</t>
          <ul spacing="normal">
            <li>
              <t><bcp14>SHOULD</bcp14> advertise a reorder-window no larger than the buffer it can
dedicate to the upload;</t>
            </li>
            <li>
              <t>buffers appends that arrive ahead of the contiguous offset and passes
bytes to its engines in order as gaps fill;</t>
            </li>
            <li>
              <t><bcp14>MUST NOT</bcp14> evaluate appends only in isolation when its policy can match
content that spans appends;</t>
            </li>
            <li>
              <t><bcp14>MAY</bcp14> use Content-Digest to recognize a retried range it has already
inspected and skip inspecting it again.</t>
            </li>
          </ul>
          <t>In-order inspection needs a single view of the whole upload. When
several instances of an intermediary share the load, all requests for
one upload resource <bcp14>MUST</bcp14> reach the same instance, or the instances <bcp14>MUST</bcp14>
share the buffered and inspection state of the upload. An instance that
receives an append for an upload whose earlier content it has not
inspected, and cannot obtain that state, <bcp14>MUST</bcp14> treat this as lost state
(<xref target="inspect-failure"/>).</t>
          <t>Some formats can only be analyzed as a whole, such as archives that
keep their index at the end. For those, an intermediary keeps the
content as it passes and inspects the complete content before releasing
the tail. This needs storage for the whole upload but not a larger
reorder window, since the content still arrives in order within the
window; an intermediary <bcp14>MUST NOT</bcp14> raise reorder-window for this purpose
(<xref target="tightening"/>).</t>
        </section>
        <section anchor="forwarding">
          <name>Forwarding Strategies</name>
          <t>The <bcp14>RECOMMENDED</bcp14> approach is to forward every append as soon as it
arrives, inspect the content in order alongside, and hold back only the
tail append until there is a verdict (<xref target="hold-tail"/>). Upload throughput
is unaffected; the only added delay is the time needed to inspect the
last data received.</t>
          <t>The simplest way to do this is to set commit to "explicit" when
tightening limits (<xref target="tightening"/>). Every append then reaches the
server unchanged, and the only request the intermediary holds is the
empty commit request at the end, which it forwards once its verdict
allows the content.</t>
          <t>An intermediary that does not want the server to store uninspected
bytes at all can instead forward each range only after inspecting it,
at the cost of more delay. It can also forward the upload sequentially,
as described in <xref target="translation"/>.</t>
        </section>
        <section anchor="hold-tail">
          <name>Holding the Tail Append</name>
          <t>Whatever forwarding strategy it uses, an inspecting intermediary <bcp14>MUST
NOT</bcp14> forward the tail append to the server before its verdict for the
upload is that the content is allowed. Since a server cannot complete
an upload without its tail append (<xref target="completion"/>), this is enough to
keep uninspected content from being committed, even if the server
knows nothing about inspection or about this document.</t>
          <t>The intermediary always knows which append is the tail: it carries
Upload-Complete set to true and, with automatic commit, ends at the
upload length. With explicit commit the tail append is the empty commit
request, so holding it delays nothing but the commit itself. That is
the same rule as the strategy in <xref target="forwarding"/>, not an alternative to
it.</t>
          <t>With automatic commit the tail append can be large. The intermediary
<bcp14>MAY</bcp14> forward all of it except a final part, as an append with
Upload-Complete set to false, and hold only that final part as the tail
it forwards later. The forwarded part is not a tail append, so if
append-alignment applies it <bcp14>MUST</bcp14> end at a multiple of append-alignment:
the intermediary forwards up to the largest such multiple that is less
than the upload length and holds the rest. If no such multiple lies
within the tail append, the intermediary holds all of it. With explicit
commit the tail append is empty and nothing needs to be split.</t>
        </section>
        <section anchor="hold-tail-retrieval">
          <name>Offset Retrieval While Holding</name>
          <t>With automatic commit, the held tail carries content the server has
not yet received. While it holds it, the intermediary <bcp14>SHOULD</bcp14> answer
offset retrieval requests for the upload itself, or modify the server's
response, so that the held range is reported as received and the
Upload-Inspection field (<xref target="upload-inspection"/>) is included. Otherwise
the client would see a gap at the end and re-send the tail, which is
safe but wasteful. With explicit commit no content is held, and the
intermediary only adds Upload-Inspection to these responses.</t>
        </section>
        <section anchor="verdicts">
          <name>Verdicts</name>
          <dl newline="true">
            <dt>Allowed:</dt>
            <dd>
              <t>The intermediary forwards the tail append. It relays the server's
final response to the client and adds Upload-Inspection with state
"clean".</t>
            </dd>
            <dt>Blocked:</dt>
            <dd>
              <t>The intermediary <bcp14>MUST NOT</bcp14> forward the tail append. It <bcp14>SHOULD</bcp14> cancel
the upload at the server using upload cancellation as defined in
<xref target="RESUMABLE"/>, and responds to the client with status 403 (Forbidden)
and the problem type "upload-blocked". Later requests for the upload
receive the same response.</t>
            </dd>
            <dt>Pending:</dt>
            <dd>
              <t>If inspection takes longer than the intermediary is willing to hold
the request, it <bcp14>MAY</bcp14> respond to the tail append with status 202
(Accepted), a Retry-After field, and Upload-Inspection with state
"scanning". The client then uses offset retrieval until the response
shows the upload as complete or blocked.</t>
            </dd>
          </dl>
        </section>
        <section anchor="upload-inspection">
          <name>The Upload-Inspection Response Field</name>
          <t>The Upload-Inspection response header field is a Dictionary
<xref target="RFC9651"/> that an inspecting intermediary uses to report progress:</t>
          <sourcecode type="http-message"><![CDATA[
Upload-Inspection: state=scanning, scanned=7340032
]]></sourcecode>
          <dl>
            <dt>state:</dt>
            <dd>
              <t>A Token: "scanning", "clean", or "blocked".</t>
            </dd>
            <dt>scanned:</dt>
            <dd>
              <t>An Integer, optional: the offset up to which content has been
inspected.</t>
            </dd>
          </dl>
          <t>Only inspecting intermediaries set this field. A client <bcp14>MUST NOT</bcp14> treat
it as a statement by the server, and <bcp14>MAY</bcp14> use it to explain delays to
users. Unknown keys <bcp14>MUST</bcp14> be ignored.</t>
        </section>
        <section anchor="inspect-failure">
          <name>Timeouts and Failures</name>
          <t>An intermediary <bcp14>SHOULD</bcp14> bound how long it holds a tail append. If it
cannot reach a verdict, because an inspection engine is unavailable or
the upstream server is failing, it <bcp14>MUST NOT</bcp14> forward the tail. It
<bcp14>SHOULD</bcp14> cancel the upload at the server and fail the client's request,
so that content that was never inspected is not left stored and cannot
be committed later.</t>
          <t>An intermediary that abandons an upload, for example when the client
disconnects or the intermediary itself restarts, <bcp14>SHOULD</bcp14> cancel the
upload at the server rather than rely on expiry.</t>
          <t>An intermediary that loses its buffered or inspection state for an
upload, for example after a restart, cannot recover by inspecting again.
The content before the contiguous offset is already at the server and
will not be sent again, and in-order engines would also miss the start
of the content, where file types are recognized. The intermediary
therefore <bcp14>MUST NOT</bcp14> forward the tail append for that upload. It <bcp14>MUST</bcp14>
cancel the upload at the server and respond to the client's requests for
it with 410 (Gone), so that the client creates a new upload
(<xref target="client-reqs"/>). An intermediary that terminates parallel mode
(<xref target="translation"/>) acts as the server on the client-facing hop and
follows <xref target="server-failure"/> in the same way.</t>
          <t>If forwarding a held tail append fails because the upload has expired
or the server has lost it, the intermediary reports the failure to the
client and discards the held content.</t>
        </section>
        <section anchor="verdict-cache">
          <name>Reusing Earlier Verdicts</name>
          <t>If the client sends Repr-Digest at upload creation, an inspecting
intermediary <bcp14>MAY</bcp14> look up an earlier verdict for that digest under the
same policy. A digest known to be blocked can be refused at upload
creation, before any content is transferred. For a digest known to be
allowed, the intermediary <bcp14>MAY</bcp14> skip its inspection engines, but <bcp14>MUST</bcp14>
still compute the digest of the content as it passes and treat a
mismatch as blocked.</t>
        </section>
      </section>
    </section>
    <section anchor="versions">
      <name>HTTP Version Considerations</name>
      <section anchor="h2h3">
        <name>HTTP/2 and HTTP/3</name>
        <t>Over HTTP/2 <xref target="RFC9113"/> and HTTP/3 <xref target="RFC9114"/>, each append is a
request on its own stream, and several appends can share one
connection. Parallel appends on one connection already remove the idle
round trip that sequential appends spend waiting for each response, and
a slow append no longer holds up the ranges after it. With HTTP/3, a
lost packet also delays only the stream it belongs to; with HTTP/2 it
delays every stream on the connection.</t>
        <t>Parallel appends on one connection do not raise that connection's
throughput limit, however. All streams on a connection share one
congestion controller, whether the transport is TCP or QUIC, so on a
path with a long round-trip time or packet loss a single connection can
still use only part of the available capacity. Only additional
connections, each with its own congestion controller, lift that limit.
A client <bcp14>MAY</bcp14> therefore spread appends over more than one connection
when a single connection does not use the available capacity, subject
to <xref target="fairness"/>. The total number of appends in progress still stays
within max-parallel when it is present.</t>
        <section anchor="h2h3-priority">
          <name>Priorities</name>
          <t>A client <bcp14>SHOULD</bcp14> use the Priority field <xref target="RFC9218"/> to give the append
that starts at the contiguous offset a lower urgency value (that is,
higher importance) than appends further into the window, for example
u=1 for the first and u=3 to u=5 for later ones. Servers and
intermediaries <bcp14>MAY</bcp14> send PRIORITY_UPDATE frames to adjust this.
Delivering the start of the window first lets the window slide sooner
and reduces the data buffered out of order. Priorities are hints; the
protocol works without them.</t>
        </section>
        <section anchor="h2h3-flow">
          <name>Flow Control</name>
          <t>A request's header section, which carries Upload-Offset and
Content-Length, arrives before its content. A recipient therefore knows
the range of an append before any of its content arrives, and can use
per-stream flow control to delay an append that is outside the window
instead of rejecting it:</t>
          <ul spacing="normal">
            <li>
              <t>For an append inside the window, the recipient grants flow control
credit as usual (WINDOW_UPDATE in HTTP/2, MAX_STREAM_DATA <xref target="RFC9000"/>
in HTTP/3).</t>
            </li>
            <li>
              <t>For an append outside the window, the recipient withholds credit
beyond the initial stream window until the window reaches the append.
The sender pauses on that stream only.</t>
            </li>
            <li>
              <t>The recipient <bcp14>MUST</bcp14> continue to grant connection-level credit to other
streams, so that a delayed stream does not stall them.</t>
            </li>
            <li>
              <t>A recipient <bcp14>MAY</bcp14> reject an append that has been delayed longer than it
is willing to wait, as described in <xref target="server-window"/>.</t>
            </li>
          </ul>
          <t>A delayed stream can still send up to its initial stream window before
pausing. A recipient that delays appends can lower its initial stream
window to bound that data.</t>
          <figure anchor="fig-flow">
            <name>Delaying an Append with Flow Control (W = 6 MiB)</name>
            <artwork type="ascii-art"><![CDATA[
Client                           Recipient
  | HEADERS 1, Upload-Offset: 0       |  C = 0,
  | HEADERS 3, Upload-Offset: 2097152 |  window [0, 6 MiB)
  | HEADERS 5, Upload-Offset: 8388608 |
  |---------------------------------->|
  |      WINDOW_UPDATE streams 1, 3   |  stream 5 is outside
  |<----------------------------------|  the window: no
  | DATA streams 1, 3                 |  further credit
  |---------------------------------->|
  |                                   |  C reaches 4 MiB,
  |      WINDOW_UPDATE stream 5       |  window [4, 10 MiB)
  |<----------------------------------|
  | DATA stream 5                     |
  |---------------------------------->|
]]></artwork>
          </figure>
        </section>
        <section anchor="h2h3-other">
          <name>Cancellation and Early Data</name>
          <t>A client cancels a redundant or abandoned append with RST_STREAM in
HTTP/2 or by resetting the stream in HTTP/3. The server treats it as an
interrupted append (<xref target="interrupted"/>).</t>
          <t>Upload creation and appends <bcp14>MUST NOT</bcp14> be sent in TLS early data. A
server that receives them in early data responds with status 425 (Too
Early) <xref target="RFC8470"/>.</t>
        </section>
      </section>
      <section anchor="http11">
        <name>HTTP/1.1</name>
        <t>Over HTTP/1.1 <xref target="RFC9112"/>, parallel appends use separate connections,
one append per connection at a time. The following rules apply:</t>
        <ul spacing="normal">
          <li>
            <t>If max-parallel is present, a client <bcp14>MUST NOT</bcp14> use more connections
for appends to one upload than that value. Browsers are additionally
limited by their per-origin connection limits.</t>
          </li>
          <li>
            <t>HTTP/1.1 has no per-request flow control. A client <bcp14>MUST NOT</bcp14> start an
append outside the window, and a recipient <bcp14>SHOULD</bcp14> reject such an
append with 409 and "offset-outside-window" rather than delay it.</t>
          </li>
          <li>
            <t>HTTP/1.1 has no priorities. A client keeps the append at the
contiguous offset in progress first and <bcp14>MAY</bcp14> replace it with a new
request on another connection if it stalls (<xref target="client-reqs"/>).</t>
          </li>
          <li>
            <t>Some intermediaries do not forward informational responses. A client
<bcp14>MUST NOT</bcp14> depend on receiving 104 (Upload Resumption Supported) and
<bcp14>SHOULD</bcp14> create the upload with an empty body, taking the upload
resource and limits from the final response.</t>
          </li>
          <li>
            <t>A client <bcp14>MUST NOT</bcp14> pipeline requests.</t>
          </li>
          <li>
            <t>Appends in parallel mode carry Content-Length (<xref target="append-requests"/>)
and therefore do not use chunked transfer coding.</t>
          </li>
          <li>
            <t>A client <bcp14>MAY</bcp14> send Expect: 100-continue, and <bcp14>MUST</bcp14> continue if no 100
(Continue) response arrives, as described in <xref target="RFC9110"/>.</t>
          </li>
        </ul>
        <t>If the upload is not in parallel mode (<xref target="fallback"/>), client and server
use the sequential behavior of <xref target="RESUMABLE"/> unchanged.</t>
      </section>
      <section anchor="fairness">
        <name>Congestion Control and Fairness</name>
        <t>An upload that uses several connections can take more than one
connection's share of a bottleneck it shares with other traffic.
Additional connections are meant for paths where a single connection is
limited by round-trip time or loss, not for gaining a larger share of a
congested link. Therefore:</t>
        <ul spacing="normal">
          <li>
            <t>A client <bcp14>SHOULD</bcp14> start with one connection and open additional
connections only while doing so increases the upload's throughput. It
<bcp14>SHOULD</bcp14> stop adding connections when it does not.</t>
          </li>
          <li>
            <t>A client <bcp14>SHOULD NOT</bcp14> use more connections for one upload than it
needs, and <bcp14>MUST</bcp14> stay within max-parallel when it is present.</t>
          </li>
          <li>
            <t>Servers and intermediaries can limit concurrency for an upload with
max-parallel, and can reject excess appends with 429 (Too Many
Requests) (<xref target="server-window"/>).</t>
          </li>
          <li>
            <t>Each connection runs the congestion control specified for its
transport. This document does not change congestion control.</t>
          </li>
        </ul>
        <t>Multipath extensions to QUIC, under development in the IETF, could
offer a single connection with a separate congestion controller for
each path. This document does not depend on them.</t>
      </section>
    </section>
    <section anchor="problems">
      <name>Problem Types</name>
      <t>Error responses defined in this document use Problem Details
<xref target="RFC9457"/> with the following problem types. Each type URI has the
form https://iana.org/assignments/http-problem-types#NAME.</t>
      <table anchor="tab-problems">
        <name>Problem Types</name>
        <thead>
          <tr>
            <th align="left">Name</th>
            <th align="left">Status</th>
            <th align="left">Meaning</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td align="left">offset-outside-window</td>
            <td align="left">409</td>
            <td align="left">The append ends beyond the reorder window. The response includes Upload-Offset.</td>
          </tr>
          <tr>
            <td align="left">range-conflict</td>
            <td align="left">409</td>
            <td align="left">The append overlaps received bytes with different content.</td>
          </tr>
          <tr>
            <td align="left">incomplete-ranges</td>
            <td align="left">409</td>
            <td align="left">An explicit commit was sent while gaps remain. The response includes Upload-Received.</td>
          </tr>
          <tr>
            <td align="left">misaligned-append</td>
            <td align="left">400</td>
            <td align="left">The offset or length violates append-alignment.</td>
          </tr>
          <tr>
            <td align="left">too-many-parallel</td>
            <td align="left">429</td>
            <td align="left">More appends are in progress than max-parallel allows, or than the server can currently handle.</td>
          </tr>
          <tr>
            <td align="left">upload-blocked</td>
            <td align="left">403</td>
            <td align="left">An inspecting intermediary blocked the upload by policy.</td>
          </tr>
        </tbody>
      </table>
      <t>A repeated append for a range that is already stored, or for one that
another append is still writing, is not a conflict when the content is
identical; see <xref target="overlap"/>.</t>
      <t>Problem details for "upload-blocked" <bcp14>MUST NOT</bcp14> identify the inspection
engine, signature, or policy rule that matched.</t>
    </section>
    <section anchor="security-considerations">
      <name>Security Considerations</name>
      <t>The security considerations of <xref target="RESUMABLE"/> apply to this extension as
well.</t>
      <t>A client cannot get more parallelism than every party on the path
allows: intermediaries can only tighten the limits, and they enforce the
limits they tighten (<xref target="tightening"/>), so a client that ignores them
cannot overrun an intermediary's buffers.</t>
      <t>An inspecting intermediary controls whether an upload is committed by
holding its tail append (<xref target="hold-tail"/>). This relies on the intermediary
seeing all of the upload's content in order. An attacker could try to
break that view, for example by steering appends for one upload to
different instances of a load-balanced intermediary, or by provoking a
restart partway through an upload. An intermediary therefore keeps
each upload on one instance or shares its state (<xref target="in-order"/>), and
cancels any upload it cannot inspect completely rather than releasing
it (<xref target="inspect-failure"/>).</t>
      <t>An attacker may try to split content across appends so that no single
append matches an inspection policy. Processing appends in order,
across append boundaries (<xref target="in-order"/>), handles this. Evaluating each
append on its own does not.</t>
      <t>A digest sent by the client is only a claim. Servers and intermediaries
can use it to detect errors or to look up earlier verdicts, but have to
verify it against the actual content before relying on it
(<xref target="verdict-cache"/>).</t>
      <t>The reorder window bounds how much out-of-order data is buffered per
upload, but an attacker can still open many uploads. Servers and
intermediaries need to limit the number of uploads per client, the
total amount of buffered data, and how long they hold delayed appends.
They can respond with 429 (Too Many Requests) when overloaded.</t>
      <t>Incomplete uploads contain gaps and possibly uninspected data. They are
never exposed as the representation of a resource (<xref target="server-storage"/>),
and gaps are never filled with bytes that could reveal other stored
data.</t>
      <t>Detailed inspection results would help an attacker adjust content until
it passes. For that reason Upload-Inspection and "upload-blocked"
responses carry only coarse information (<xref target="problems"/>).</t>
      <t>Parallel mode sends the upload resource URI over more connections. As
in <xref target="RESUMABLE"/>, the URI needs to be hard to guess, and access to it
needs to be tied to the client's authorization.</t>
      <t>Appends are not sent in TLS early data (<xref target="h2h3-other"/>), and repeating
an append with the same content has no effect, so replay does not cause
harm.</t>
    </section>
    <section anchor="iana-considerations">
      <name>IANA Considerations</name>
      <section anchor="http-field-names">
        <name>HTTP Field Names</name>
        <t>IANA is asked to register the following fields in the "Hypertext
Transfer Protocol (HTTP) Field Name Registry" established by
<xref target="RFC9110"/>:</t>
        <table anchor="tab-iana-fields">
          <name>Field Registrations</name>
          <thead>
            <tr>
              <th align="left">Field Name</th>
              <th align="left">Status</th>
              <th align="left">Structured Type</th>
              <th align="left">Reference</th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td align="left">Upload-Parallel</td>
              <td align="left">permanent</td>
              <td align="left">Item</td>
              <td align="left">
                <xref target="upload-parallel"/> of this document</td>
            </tr>
            <tr>
              <td align="left">Upload-Received</td>
              <td align="left">permanent</td>
              <td align="left">List</td>
              <td align="left">
                <xref target="upload-received"/> of this document</td>
            </tr>
            <tr>
              <td align="left">Upload-Inspection</td>
              <td align="left">permanent</td>
              <td align="left">Dictionary</td>
              <td align="left">
                <xref target="upload-inspection"/> of this document</td>
            </tr>
          </tbody>
        </table>
      </section>
      <section anchor="upload-limit-parameters">
        <name>Upload-Limit Parameters</name>
        <t><xref target="RESUMABLE"/> does not establish a registry for Upload-Limit
parameters, so the parameters max-parallel, reorder-window,
append-alignment, and commit are defined in <xref target="limits"/> of this document
without a registration. If such a registry is created, IANA is asked to
add these four parameters to it, with a reference to <xref target="limits"/>.</t>
      </section>
      <section anchor="http-problem-types">
        <name>HTTP Problem Types</name>
        <t>IANA is asked to register the problem types listed in <xref target="tab-problems"/>
in the "HTTP Problem Types" registry established by <xref target="RFC9457"/>, each
with a reference to <xref target="problems"/> of this document.</t>
      </section>
    </section>
  </middle>
  <back>
    <references anchor="sec-combined-references">
      <name>References</name>
      <references anchor="sec-normative-references">
        <name>Normative References</name>
        <reference anchor="RESUMABLE">
          <front>
            <title>Resumable Uploads for HTTP</title>
            <author fullname="Marius Kleidl" initials="M." surname="Kleidl">
              <organization>Transloadit</organization>
            </author>
            <author fullname="Guoye Zhang" initials="G." surname="Zhang">
              <organization>Apple Inc.</organization>
            </author>
            <author fullname="Lucas Pardue" initials="L." surname="Pardue">
              <organization>Apple</organization>
            </author>
            <date day="2" month="November" year="2026"/>
            <abstract>
              <t>   HTTP data transfers can encounter interruption due to reasons such as
   canceled requests or dropped connections.  If the intended recipient
   can indicate how much of the data was processed prior to
   interruption, a sender can resume data transfer at that point instead
   of attempting to transfer all of the data again.  HTTP range requests
   support this concept of resumable downloads from server to client.
   This document describes a mechanism that supports resumable uploads
   from client to server using HTTP.

              </t>
            </abstract>
          </front>
          <seriesInfo name="Internet-Draft" value="draft-ietf-httpbis-resumable-upload-15"/>
        </reference>
        <reference anchor="RFC9000">
          <front>
            <title>QUIC: A UDP-Based Multiplexed and Secure Transport</title>
            <author fullname="J. Iyengar" initials="J." role="editor" surname="Iyengar"/>
            <author fullname="M. Thomson" initials="M." role="editor" surname="Thomson"/>
            <date month="May" year="2021"/>
            <abstract>
              <t>This document defines the core of the QUIC transport protocol. QUIC provides applications with flow-controlled streams for structured communication, low-latency connection establishment, and network path migration. QUIC includes security measures that ensure confidentiality, integrity, and availability in a range of deployment circumstances. Accompanying documents describe the integration of TLS for key negotiation, loss detection, and an exemplary congestion control algorithm.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="9000"/>
          <seriesInfo name="DOI" value="10.17487/RFC9000"/>
        </reference>
        <reference anchor="RFC9110">
          <front>
            <title>HTTP Semantics</title>
            <author fullname="R. Fielding" initials="R." role="editor" surname="Fielding"/>
            <author fullname="M. Nottingham" initials="M." role="editor" surname="Nottingham"/>
            <author fullname="J. Reschke" initials="J." role="editor" surname="Reschke"/>
            <date month="June" year="2022"/>
            <abstract>
              <t>The Hypertext Transfer Protocol (HTTP) is a stateless application-level protocol for distributed, collaborative, hypertext information systems. This document describes the overall architecture of HTTP, establishes common terminology, and defines aspects of the protocol that are shared by all versions. In this definition are core protocol elements, extensibility mechanisms, and the "http" and "https" Uniform Resource Identifier (URI) schemes.</t>
              <t>This document updates RFC 3864 and obsoletes RFCs 2818, 7231, 7232, 7233, 7235, 7538, 7615, 7694, and portions of 7230.</t>
            </abstract>
          </front>
          <seriesInfo name="STD" value="97"/>
          <seriesInfo name="RFC" value="9110"/>
          <seriesInfo name="DOI" value="10.17487/RFC9110"/>
        </reference>
        <reference anchor="RFC9112">
          <front>
            <title>HTTP/1.1</title>
            <author fullname="R. Fielding" initials="R." role="editor" surname="Fielding"/>
            <author fullname="M. Nottingham" initials="M." role="editor" surname="Nottingham"/>
            <author fullname="J. Reschke" initials="J." role="editor" surname="Reschke"/>
            <date month="June" year="2022"/>
            <abstract>
              <t>The Hypertext Transfer Protocol (HTTP) is a stateless application-level protocol for distributed, collaborative, hypertext information systems. This document specifies the HTTP/1.1 message syntax, message parsing, connection management, and related security concerns.</t>
              <t>This document obsoletes portions of RFC 7230.</t>
            </abstract>
          </front>
          <seriesInfo name="STD" value="99"/>
          <seriesInfo name="RFC" value="9112"/>
          <seriesInfo name="DOI" value="10.17487/RFC9112"/>
        </reference>
        <reference anchor="RFC9113">
          <front>
            <title>HTTP/2</title>
            <author fullname="M. Thomson" initials="M." role="editor" surname="Thomson"/>
            <author fullname="C. Benfield" initials="C." role="editor" surname="Benfield"/>
            <date month="June" year="2022"/>
            <abstract>
              <t>This specification describes an optimized expression of the semantics of the Hypertext Transfer Protocol (HTTP), referred to as HTTP version 2 (HTTP/2). HTTP/2 enables a more efficient use of network resources and a reduced latency by introducing field compression and allowing multiple concurrent exchanges on the same connection.</t>
              <t>This document obsoletes RFCs 7540 and 8740.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="9113"/>
          <seriesInfo name="DOI" value="10.17487/RFC9113"/>
        </reference>
        <reference anchor="RFC9114">
          <front>
            <title>HTTP/3</title>
            <author fullname="M. Bishop" initials="M." role="editor" surname="Bishop"/>
            <date month="June" year="2022"/>
            <abstract>
              <t>The QUIC transport protocol has several features that are desirable in a transport for HTTP, such as stream multiplexing, per-stream flow control, and low-latency connection establishment. This document describes a mapping of HTTP semantics over QUIC. This document also identifies HTTP/2 features that are subsumed by QUIC and describes how HTTP/2 extensions can be ported to HTTP/3.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="9114"/>
          <seriesInfo name="DOI" value="10.17487/RFC9114"/>
        </reference>
        <reference anchor="RFC9457">
          <front>
            <title>Problem Details for HTTP APIs</title>
            <author fullname="M. Nottingham" initials="M." surname="Nottingham"/>
            <author fullname="E. Wilde" initials="E." surname="Wilde"/>
            <author fullname="S. Dalal" initials="S." surname="Dalal"/>
            <date month="July" year="2023"/>
            <abstract>
              <t>This document defines a "problem detail" to carry machine-readable details of errors in HTTP response content to avoid the need to define new error response formats for HTTP APIs.</t>
              <t>This document obsoletes RFC 7807.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="9457"/>
          <seriesInfo name="DOI" value="10.17487/RFC9457"/>
        </reference>
        <reference anchor="RFC9530">
          <front>
            <title>Digest Fields</title>
            <author fullname="R. Polli" initials="R." surname="Polli"/>
            <author fullname="L. Pardue" initials="L." surname="Pardue"/>
            <date month="February" year="2024"/>
            <abstract>
              <t>This document defines HTTP fields that support integrity digests. The Content-Digest field can be used for the integrity of HTTP message content. The Repr-Digest field can be used for the integrity of HTTP representations. Want-Content-Digest and Want-Repr-Digest can be used to indicate a sender's interest and preferences for receiving the respective Integrity fields.</t>
              <t>This document obsoletes RFC 3230 and the Digest and Want-Digest HTTP fields.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="9530"/>
          <seriesInfo name="DOI" value="10.17487/RFC9530"/>
        </reference>
        <reference anchor="RFC9651">
          <front>
            <title>Structured Field Values for HTTP</title>
            <author fullname="M. Nottingham" initials="M." surname="Nottingham"/>
            <author fullname="P-H. Kamp" surname="P-H. Kamp"/>
            <date month="September" year="2024"/>
            <abstract>
              <t>This document describes a set of data types and associated algorithms that are intended to make it easier and safer to define and handle HTTP header and trailer fields, known as "Structured Fields", "Structured Headers", or "Structured Trailers". It is intended for use by specifications of new HTTP fields.</t>
              <t>This document obsoletes RFC 8941.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="9651"/>
          <seriesInfo name="DOI" value="10.17487/RFC9651"/>
        </reference>
        <reference anchor="RFC8470">
          <front>
            <title>Using Early Data in HTTP</title>
            <author fullname="M. Thomson" initials="M." surname="Thomson"/>
            <author fullname="M. Nottingham" initials="M." surname="Nottingham"/>
            <author fullname="W. Tarreau" initials="W." surname="Tarreau"/>
            <date month="September" year="2018"/>
            <abstract>
              <t>Using TLS early data creates an exposure to the possibility of a replay attack. This document defines mechanisms that allow clients to communicate with servers about HTTP requests that are sent in early data. Techniques are described that use these mechanisms to mitigate the risk of replay.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="8470"/>
          <seriesInfo name="DOI" value="10.17487/RFC8470"/>
        </reference>
        <reference anchor="RFC9218">
          <front>
            <title>Extensible Prioritization Scheme for HTTP</title>
            <author fullname="K. Oku" initials="K." surname="Oku"/>
            <author fullname="L. Pardue" initials="L." surname="Pardue"/>
            <date month="June" year="2022"/>
            <abstract>
              <t>This document describes a scheme that allows an HTTP client to communicate its preferences for how the upstream server prioritizes responses to its requests, and also allows a server to hint to a downstream intermediary how its responses should be prioritized when they are forwarded. This document defines the Priority header field for communicating the initial priority in an HTTP version-independent manner, as well as HTTP/2 and HTTP/3 frames for reprioritizing responses. These share a common format structure that is designed to provide future extensibility.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="9218"/>
          <seriesInfo name="DOI" value="10.17487/RFC9218"/>
        </reference>
        <reference anchor="RFC2119">
          <front>
            <title>Key words for use in RFCs to Indicate Requirement Levels</title>
            <author fullname="S. Bradner" initials="S." surname="Bradner"/>
            <date month="March" year="1997"/>
            <abstract>
              <t>In many standards track documents several words are used to signify the requirements in the specification. These words are often capitalized. This document defines these words as they should be interpreted in IETF documents. This document specifies an Internet Best Current Practices for the Internet Community, and requests discussion and suggestions for improvements.</t>
            </abstract>
          </front>
          <seriesInfo name="BCP" value="14"/>
          <seriesInfo name="RFC" value="2119"/>
          <seriesInfo name="DOI" value="10.17487/RFC2119"/>
        </reference>
        <reference anchor="RFC8174">
          <front>
            <title>Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words</title>
            <author fullname="B. Leiba" initials="B." surname="Leiba"/>
            <date month="May" year="2017"/>
            <abstract>
              <t>RFC 2119 specifies common key words that may be used in protocol specifications. This document aims to reduce the ambiguity by clarifying that only UPPERCASE usage of the key words have the defined special meanings.</t>
            </abstract>
          </front>
          <seriesInfo name="BCP" value="14"/>
          <seriesInfo name="RFC" value="8174"/>
          <seriesInfo name="DOI" value="10.17487/RFC8174"/>
        </reference>
      </references>
      <references anchor="sec-informative-references">
        <name>Informative References</name>
        <reference anchor="BYTERANGE">
          <front>
            <title>Byte Range PATCH</title>
            <author fullname="Austin Wright" initials="A." surname="Wright">
         </author>
            <date day="2" month="November" year="2026"/>
            <abstract>
              <t>   This document specifies a media type for PATCH payloads that
   overwrites a specific byte range, facilitating random access writes
   and segmented uploads of resources.

              </t>
            </abstract>
          </front>
          <seriesInfo name="Internet-Draft" value="draft-ietf-httpapi-patch-byterange-05"/>
        </reference>
        <reference anchor="TUS" target="https://tus.io/protocols/resumable-upload">
          <front>
            <title>tus resumable upload protocol, version 1.0.0</title>
            <author>
              <organization>tus project</organization>
            </author>
            <date year="2016" month="March" day="25"/>
          </front>
        </reference>
      </references>
    </references>
    <?line 1157?>

<section numbered="false" anchor="acknowledgments">
      <name>Acknowledgments</name>
      <t>This document builds on the work of the authors of <xref target="RESUMABLE"/> and
<xref target="BYTERANGE"/>, and on the tus protocol <xref target="TUS"/>.</t>
    </section>
  </back>
  <!-- ##markdown-source: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-->

</rfc>
