@fluojs/runtime 2.0.1 → 3.0.0

package/dist/multipart.js

@@ -1,11 +1,11 @@
-import { PayloadTooLargeException } from '@fluojs/http';
+import { PayloadTooLargeException } from '@fluojs/http/portable';
 
 /**
  * Represents a single uploaded multipart file buffered in memory.
  */
 
 /**
- * Configures multipart parsing limits for file size, file count, and total payload size.
+ * Configures multipart parsing limits for fields, files, headers, and total payload size.
  */
 
 /**
@@ -16,53 +16,62 @@ import { PayloadTooLargeException } from '@fluojs/http';
  * Describes request-like multipart inputs accepted by the runtime parsers.
  */
 
+/**
+ * A decoded non-file multipart field.
+ */
+
+/**
+ * A multipart file whose bytes are read exactly once from a portable Web stream.
+ */
+
+/**
+ * A typed item yielded by {@link parseMultipartStream}.
+ */
+
+/**
+ * Signals that a multipart body has already been selected for buffered or streaming consumption.
+ */
+export class MultipartBodyConsumedError extends Error {
+  constructor() {
+    super('Multipart request body has already been consumed.');
+    this.name = 'MultipartBodyConsumedError';
+  }
+}
 const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
+const DEFAULT_MAX_FIELD_SIZE = 1 * 1024 * 1024;
+const DEFAULT_MAX_FIELDS = 100;
 const DEFAULT_MAX_FILES = 10;
+const DEFAULT_MAX_HEADER_SIZE = 8 * 1024;
 const DEFAULT_MAX_TOTAL_SIZE = 10 * 1024 * 1024;
 const MULTIPART_BODY_LIMIT_MESSAGE = 'Multipart body exceeds the maximum size of';
 const TEXT_ENCODER = new TextEncoder();
+const TEXT_DECODER = new TextDecoder();
+const CONSUMED_MULTIPART_INPUTS = new WeakSet();
 
 /**
  * Parses a multipart request into string fields and in-memory uploaded files.
  *
  * @param request - Web `Request` or request-like input carrying a multipart body.
- * @param options - Multipart limits for file size, file count, and total payload size.
+ * @param options - Multipart limits for file size, file count, total size, field count, field size, and header size.
  * @returns Parsed string fields plus uploaded files buffered in memory.
- * @throws {PayloadTooLargeException} When the multipart payload, file count, or file size exceeds the configured limits.
+ * @throws {PayloadTooLargeException} When any configured file-size, file-count, total-size, field-count, field-size,
+ * or header-size limit is exceeded.
  */
 export async function parseMultipart(request, options = {}) {
-  const maxFileSize = options.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
-  const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
-  const maxTotalSize = options.maxTotalSize ?? DEFAULT_MAX_TOTAL_SIZE;
-  const formData = await toWebRequest(request, maxTotalSize).formData();
   const fields = {};
   const files = [];
-  let totalSize = 0;
-  for (const [fieldname, value] of formData.entries()) {
-    if (typeof value === 'string') {
-      totalSize += TEXT_ENCODER.encode(value).byteLength;
-      if (totalSize > maxTotalSize) {
-        throw new PayloadTooLargeException(`${MULTIPART_BODY_LIMIT_MESSAGE} ${String(maxTotalSize)} bytes.`);
-      }
-      appendMultipartField(fields, fieldname, value);
+  for await (const part of createMultipartParts(request, options, false)) {
+    if (part.kind === 'field') {
+      appendMultipartField(fields, part.name, part.value);
       continue;
     }
-    totalSize += value.size;
-    if (totalSize > maxTotalSize) {
-      throw new PayloadTooLargeException(`${MULTIPART_BODY_LIMIT_MESSAGE} ${String(maxTotalSize)} bytes.`);
-    }
-    if (files.length >= maxFiles) {
-      throw new PayloadTooLargeException(`Exceeded maximum file count of ${String(maxFiles)}.`);
-    }
-    if (value.size > maxFileSize) {
-      throw new PayloadTooLargeException(`File "${fieldname}" exceeds the maximum size of ${String(maxFileSize)} bytes.`);
-    }
+    const buffer = new Uint8Array(await new Response(part.stream).arrayBuffer());
     files.push({
-      buffer: new Uint8Array(await value.arrayBuffer()),
-      fieldname,
-      mimetype: value.type,
-      originalname: value.name,
-      size: value.size
+      buffer,
+      fieldname: part.name,
+      mimetype: part.contentType,
+      originalname: part.filename,
+      size: buffer.byteLength
     });
   }
   return {
@@ -70,110 +79,663 @@ export async function parseMultipart(request, options = {}) {
     files
   };
 }
-function appendMultipartField(fields, name, value) {
-  const existing = fields[name];
-  if (existing === undefined) {
-    fields[name] = value;
-    return;
+
+/**
+ * Streams multipart fields and file parts from a request body.
+ *
+ * A yielded file stream must finish or be cancelled before requesting the next part. Calling
+ * this function selects the request body for streaming consumption; callers cannot also use
+ * {@link parseMultipart} for the same request body.
+ *
+ * @param request - Web `Request` or request-like input carrying a multipart body.
+ * @param options - Limits enforced while parsing headers, fields, files, and total input bytes.
+ * @returns An async iterator of typed field and file parts.
+ * @throws {MultipartBodyConsumedError} When buffered or streaming parsing already selected the body.
+ */
+export function parseMultipartStream(request, options = {}) {
+  return createMultipartParts(request, options, true);
+}
+function createMultipartParts(request, options, useStreamingDefaults) {
+  markMultipartBodyConsumed(request);
+  return new MultipartPartIterator(new MultipartStreamParser(request, options, useStreamingDefaults));
+}
+
+/**
+ * Marks an input as selected for buffered or streaming multipart consumption.
+ *
+ * @param request - Request input whose body cannot be selected again.
+ * @internal
+ */
+export function markMultipartBodyConsumed(request) {
+  const body = request instanceof Request ? request.body : request.body;
+  const inputs = [request];
+  if (body !== null && typeof body === 'object') {
+    inputs.push(body);
   }
-  if (Array.isArray(existing)) {
-    existing.push(value);
-    return;
+  if (request instanceof Request && request.bodyUsed || inputs.some(input => CONSUMED_MULTIPART_INPUTS.has(input))) {
+    throw new MultipartBodyConsumedError();
+  }
+  for (const input of inputs) {
+    CONSUMED_MULTIPART_INPUTS.add(input);
   }
-  fields[name] = [existing, value];
 }
-function toWebRequest(request, maxTotalSize) {
-  if (request instanceof Request) {
-    return createMultipartRequest(request.url, request.method, new Headers(request.headers), request.body, maxTotalSize);
+class MultipartPartIterator {
+  closed = false;
+  constructor(parser) {
+    this.parser = parser;
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  async next() {
+    if (this.closed) {
+      return {
+        done: true,
+        value: undefined
+      };
+    }
+    const part = await this.parser.nextPart();
+    if (part === undefined) {
+      this.closed = true;
+      return {
+        done: true,
+        value: undefined
+      };
+    }
+    return {
+      done: false,
+      value: part
+    };
+  }
+  async return() {
+    this.closed = true;
+    this.parser.closeIfIncomplete();
+    return {
+      done: true,
+      value: undefined
+    };
   }
-  const method = request.method ?? 'POST';
-  const body = supportsRequestBody(method) ? resolveRequestBody(request) : undefined;
-  return createMultipartRequest(request.url ?? 'http://localhost/', method, normalizeRequestHeaders(request.headers), body, maxTotalSize);
 }
-function resolveRequestBody(request) {
-  if (request.body !== undefined) {
-    return isAsyncIterableBody(request.body) ? createReadableStreamFromAsyncIterable(request.body) : request.body;
+class MultipartStreamParser {
+  activeFile = false;
+  buffer = new Uint8Array();
+  cancellationStarted = false;
+  done = false;
+  failure;
+  fileController;
+  fileDelimiter;
+  initialDelimiter;
+  initialized = false;
+  maxFieldSize;
+  maxFields;
+  maxFileSize;
+  maxFiles;
+  maxHeaderSize;
+  maxTotalSize;
+  reader;
+  readerReadPending = false;
+  released = false;
+  signal;
+  terminalDrained = false;
+  totalSize = 0;
+  fieldCount = 0;
+  fileCount = 0;
+  partEnded = false;
+  constructor(request, options, useStreamingDefaults) {
+    const headers = normalizeRequestHeaders(request.headers);
+    const boundary = extractMultipartBoundary(headers.get('content-type'));
+    this.initialDelimiter = TEXT_ENCODER.encode(`--${boundary}`);
+    this.fileDelimiter = TEXT_ENCODER.encode(`\r\n--${boundary}`);
+    this.maxTotalSize = options.maxTotalSize ?? DEFAULT_MAX_TOTAL_SIZE;
+    this.maxFieldSize = options.maxFieldSize ?? (useStreamingDefaults ? DEFAULT_MAX_FIELD_SIZE : this.maxTotalSize);
+    this.maxFields = options.maxFields ?? (useStreamingDefaults ? DEFAULT_MAX_FIELDS : Number.MAX_SAFE_INTEGER);
+    this.maxFileSize = options.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
+    this.maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+    this.maxHeaderSize = options.maxHeaderSize ?? (useStreamingDefaults ? DEFAULT_MAX_HEADER_SIZE : this.maxTotalSize);
+    this.signal = request instanceof Request ? request.signal : request.signal;
+    this.reader = resolveMultipartStreamBody(request).getReader();
+    this.signal?.addEventListener('abort', this.handleAbort, {
+      once: true
+    });
+    if (this.signal?.aborted) {
+      this.handleAbort();
+    }
+    const contentLengthError = getContentLengthError(headers, this.maxTotalSize);
+    if (contentLengthError) {
+      this.fail(contentLengthError);
+    } else if (this.signal?.aborted) {
+      this.fail(toAbortError(this.signal.reason));
+    }
   }
-  if (typeof request[Symbol.asyncIterator] === 'function') {
-    return createReadableStreamFromAsyncIterable(request);
+  async nextPart() {
+    this.throwIfFailed();
+    if (this.activeFile) {
+      throw new Error('Consume or cancel the active multipart file stream before reading the next part.');
+    }
+    if (!this.initialized) {
+      await this.consumeInitialDelimiter();
+      this.initialized = true;
+    }
+    if (this.done) {
+      await this.drainAfterClosingBoundary();
+      this.release();
+      return undefined;
+    }
+    const headers = await this.readHeaders();
+    let disposition;
+    try {
+      disposition = parseContentDisposition(headers['content-disposition']);
+    } catch (error) {
+      this.fail(error);
+      throw error;
+    }
+    if (disposition.filename === undefined) {
+      this.fieldCount += 1;
+      if (this.fieldCount > this.maxFields) {
+        this.fail(new PayloadTooLargeException(`Exceeded maximum field count of ${String(this.maxFields)}.`));
+        this.throwIfFailed();
+      }
+      const value = await this.readFieldValue();
+      return {
+        headers,
+        kind: 'field',
+        name: disposition.name,
+        value
+      };
+    }
+    this.fileCount += 1;
+    if (this.fileCount > this.maxFiles) {
+      this.fail(new PayloadTooLargeException(`Exceeded maximum file count of ${String(this.maxFiles)}.`));
+      this.throwIfFailed();
+    }
+    this.activeFile = true;
+    return {
+      contentType: headers['content-type'] ?? 'application/octet-stream',
+      filename: disposition.filename,
+      headers,
+      kind: 'file',
+      name: disposition.name,
+      stream: this.createFileStream(disposition.name)
+    };
+  }
+  closeIfIncomplete() {
+    if (!this.failure && (this.activeFile || !this.terminalDrained)) {
+      this.fail(new Error('Multipart parser has been cancelled.'));
+    }
+  }
+  handleAbort = () => {
+    this.fail(toAbortError(this.signal?.reason));
+  };
+  createFileStream(name) {
+    let size = 0;
+    return new ReadableStream({
+      cancel: async reason => {
+        this.fail(reason);
+      },
+      pull: async controller => {
+        this.fileController = controller;
+        try {
+          const chunk = await this.readPartChunk();
+          if (chunk === undefined) {
+            this.activeFile = false;
+            this.fileController = undefined;
+            controller.close();
+            return;
+          }
+          size += chunk.byteLength;
+          if (size > this.maxFileSize) {
+            const error = new PayloadTooLargeException(`File "${name}" exceeds the maximum size of ${String(this.maxFileSize)} bytes.`);
+            this.fail(error);
+            throw error;
+          }
+          controller.enqueue(chunk);
+        } catch (error) {
+          const parserError = toError(error);
+          this.activeFile = false;
+          this.fileController = undefined;
+          controller.error(parserError);
+          throw parserError;
+        }
+      }
+    }, {
+      highWaterMark: 0
+    });
+  }
+  async consumeInitialDelimiter() {
+    await this.ensure(this.initialDelimiter.byteLength + 2);
+    if (!matchesAt(this.buffer, this.initialDelimiter, 0)) {
+      this.fail(new Error('Multipart body does not start with its declared boundary.'));
+      this.throwIfFailed();
+    }
+    this.consume(this.initialDelimiter.byteLength);
+    const ending = this.consume(2);
+    if (equalsBytes(ending, TEXT_ENCODER.encode('--'))) {
+      this.done = true;
+      return;
+    }
+    if (!equalsBytes(ending, TEXT_ENCODER.encode('\r\n'))) {
+      this.fail(new Error('Multipart boundary is malformed.'));
+      this.throwIfFailed();
+    }
+  }
+  async readHeaders() {
+    const headerBytes = await this.readUntil(TEXT_ENCODER.encode('\r\n\r\n'), this.maxHeaderSize, `Multipart part headers exceed the maximum size of ${String(this.maxHeaderSize)} bytes.`);
+    const headers = {};
+    for (const line of TEXT_DECODER.decode(headerBytes).split('\r\n')) {
+      const separator = line.indexOf(':');
+      if (separator <= 0) {
+        this.fail(new Error('Multipart part contains a malformed header.'));
+        this.throwIfFailed();
+      }
+      const name = line.slice(0, separator).trim().toLowerCase();
+      const value = line.slice(separator + 1).trim();
+      if (headers[name] !== undefined) {
+        this.fail(new Error(`Multipart part contains a repeated "${name}" header.`));
+        this.throwIfFailed();
+      }
+      headers[name] = value;
+    }
+    return Object.freeze(headers);
+  }
+  async readFieldValue() {
+    const chunks = [];
+    let size = 0;
+    while (true) {
+      const chunk = await this.readPartChunk();
+      if (chunk === undefined) {
+        break;
+      }
+      size += chunk.byteLength;
+      if (size > this.maxFieldSize) {
+        this.fail(new PayloadTooLargeException(`Field exceeds the maximum size of ${String(this.maxFieldSize)} bytes.`));
+        this.throwIfFailed();
+      }
+      chunks.push(chunk);
+    }
+    return TEXT_DECODER.decode(concatBytes(chunks, size));
+  }
+  async readPartChunk() {
+    if (this.partEnded) {
+      this.partEnded = false;
+      if (this.done) {
+        await this.drainAfterClosingBoundary();
+      }
+      return undefined;
+    }
+    while (true) {
+      this.throwIfFailed();
+      const delimiterIndex = indexOfBytes(this.buffer, this.fileDelimiter);
+      if (delimiterIndex !== -1) {
+        const suffixOffset = delimiterIndex + this.fileDelimiter.byteLength;
+        const suffixLength = 2;
+        if (this.buffer.byteLength < suffixOffset + suffixLength) {
+          if (delimiterIndex > 0) {
+            return this.consume(delimiterIndex);
+          }
+          await this.readMore();
+          continue;
+        }
+        const ending = this.buffer.slice(suffixOffset, suffixOffset + suffixLength);
+        if (equalsBytes(ending, TEXT_ENCODER.encode('--'))) {
+          const chunk = this.consume(delimiterIndex);
+          this.consume(this.fileDelimiter.byteLength + suffixLength);
+          this.done = true;
+          this.partEnded = chunk.byteLength > 0;
+          if (chunk.byteLength === 0) {
+            await this.drainAfterClosingBoundary();
+            return undefined;
+          }
+          return chunk;
+        } else if (equalsBytes(ending, TEXT_ENCODER.encode('\r\n'))) {
+          const chunk = this.consume(delimiterIndex);
+          this.consume(this.fileDelimiter.byteLength + suffixLength);
+          this.partEnded = chunk.byteLength > 0;
+          return chunk.byteLength === 0 ? undefined : chunk;
+        }
+        return this.consume(suffixOffset);
+      }
+      const retainedBytes = this.fileDelimiter.byteLength - 1;
+      if (this.buffer.byteLength > retainedBytes) {
+        return this.consume(this.buffer.byteLength - retainedBytes);
+      }
+      await this.readMore();
+    }
+  }
+  async readUntil(delimiter, limit, message) {
+    while (true) {
+      this.throwIfFailed();
+      const delimiterIndex = indexOfBytes(this.buffer, delimiter);
+      if (delimiterIndex !== -1) {
+        const value = this.consume(delimiterIndex);
+        this.consume(delimiter.byteLength);
+        if (value.byteLength > limit) {
+          this.fail(new PayloadTooLargeException(message));
+          this.throwIfFailed();
+        }
+        return value;
+      }
+      const confirmedSize = this.buffer.byteLength - trailingDelimiterPrefixLength(this.buffer, delimiter);
+      if (confirmedSize > limit) {
+        this.fail(new PayloadTooLargeException(message));
+        this.throwIfFailed();
+      }
+      await this.readMore();
+    }
+  }
+  async ensure(size) {
+    while (this.buffer.byteLength < size) {
+      await this.readMore();
+    }
+  }
+  async readMore(allowEof = false) {
+    this.throwIfFailed();
+    this.readerReadPending = true;
+    let result;
+    try {
+      result = await this.reader.read();
+    } catch (error) {
+      this.fail(error);
+      throw error;
+    } finally {
+      this.readerReadPending = false;
+      if (this.failure) {
+        this.release();
+      }
+    }
+    this.throwIfFailed();
+    if (result.done) {
+      if (allowEof) {
+        return false;
+      }
+      const error = new Error('Multipart body ended before its closing boundary.');
+      this.fail(error);
+      throw error;
+    }
+    const chunk = result.value;
+    this.totalSize += chunk.byteLength;
+    if (this.totalSize > this.maxTotalSize) {
+      this.fail(new PayloadTooLargeException(`${MULTIPART_BODY_LIMIT_MESSAGE} ${String(this.maxTotalSize)} bytes.`));
+      this.throwIfFailed();
+    }
+    this.buffer = concatBytes([this.buffer, chunk], this.buffer.byteLength + chunk.byteLength);
+    return true;
+  }
+  consume(size) {
+    const value = this.buffer.slice(0, size);
+    this.buffer = this.buffer.slice(size);
+    return value;
+  }
+  async drainAfterClosingBoundary() {
+    if (this.terminalDrained) {
+      return;
+    }
+    while (true) {
+      this.buffer = new Uint8Array();
+      if (!(await this.readMore(true))) {
+        this.terminalDrained = true;
+        this.release();
+        return;
+      }
+    }
+  }
+  fail(reason) {
+    if (this.failure) {
+      return;
+    }
+    const error = toError(reason);
+    this.failure = error;
+    this.done = true;
+    this.fileController?.error(error);
+    this.fileController = undefined;
+    this.activeFile = false;
+    this.signal?.removeEventListener('abort', this.handleAbort);
+    if (!this.cancellationStarted) {
+      this.cancellationStarted = true;
+      void this.reader.cancel(reason).then(() => this.release(), () => this.release());
+    }
+    this.release();
+  }
+  release() {
+    if (this.released || this.readerReadPending) {
+      return;
+    }
+    this.released = true;
+    this.signal?.removeEventListener('abort', this.handleAbort);
+    this.reader.releaseLock();
+  }
+  throwIfFailed() {
+    if (this.failure) {
+      throw this.failure;
+    }
+  }
+}
+function extractMultipartBoundary(contentType) {
+  const match = contentType?.match(/(?:^|;)\s*boundary=(?:"([^"]+)"|([^;]+))/i);
+  const boundary = match?.[1] ?? match?.[2]?.trim();
+  if (!boundary) {
+    throw new Error('Multipart requests require a boundary parameter.');
+  }
+  return boundary;
+}
+function parseContentDisposition(value) {
+  if (value === undefined) {
+    throw new Error('Multipart parts require a form-data Content-Disposition header.');
+  }
+  let index = skipWhitespace(value, 0);
+  const dispositionType = readToken(value, index);
+  if (!dispositionType || dispositionType.value.toLowerCase() !== 'form-data') {
+    throw new Error('Multipart parts require a form-data Content-Disposition header.');
+  }
+  index = dispositionType.end;
+  const parameters = new Map();
+  while (index < value.length) {
+    index = skipWhitespace(value, index);
+    if (index === value.length) {
+      break;
+    }
+    if (value[index] !== ';') {
+      throw new Error('Multipart Content-Disposition parameters must be separated by semicolons.');
+    }
+    index = skipWhitespace(value, index + 1);
+    const parameterName = readToken(value, index);
+    if (!parameterName) {
+      throw new Error('Multipart Content-Disposition parameters require token names.');
+    }
+    index = skipWhitespace(value, parameterName.end);
+    if (value[index] !== '=') {
+      throw new Error('Multipart Content-Disposition parameters require values.');
+    }
+    index = skipWhitespace(value, index + 1);
+    const parameterValue = value[index] === '"' ? readQuotedString(value, index) : readToken(value, index);
+    if (!parameterValue) {
+      throw new Error('Multipart Content-Disposition parameters require token or quoted-string values.');
+    }
+    if (!parameters.has(parameterName.value.toLowerCase())) {
+      parameters.set(parameterName.value.toLowerCase(), parameterValue.value);
+    }
+    index = parameterValue.end;
+  }
+  const name = parameters.get('name');
+  if (name === undefined) {
+    throw new Error('Multipart parts require a name parameter.');
+  }
+  return {
+    filename: parameters.get('filename'),
+    name
+  };
+}
+function readQuotedString(value, start) {
+  let index = start + 1;
+  let result = '';
+  while (index < value.length) {
+    const character = value[index];
+    if (character === '\r' || character === '\n') {
+      return undefined;
+    }
+    if (character === '"') {
+      return {
+        end: index + 1,
+        value: result
+      };
+    }
+    if (character === '\\') {
+      index += 1;
+      const escaped = value[index];
+      if (escaped === undefined || escaped === '\r' || escaped === '\n') {
+        return undefined;
+      }
+      result += escaped;
+      index += 1;
+      continue;
+    }
+    result += character;
+    index += 1;
   }
   return undefined;
 }
-function supportsRequestBody(method) {
-  return method !== 'GET' && method !== 'HEAD';
+function readToken(value, start) {
+  let end = start;
+  while (end < value.length && isTokenCharacter(value[end])) {
+    end += 1;
+  }
+  return end === start ? undefined : {
+    end,
+    value: value.slice(start, end)
+  };
 }
-function isAsyncIterableBody(body) {
-  return body !== null && typeof body === 'object' && Symbol.asyncIterator in body;
+function isTokenCharacter(character) {
+  return /^[!#$%&'*+\-.^_`|~0-9A-Za-z]$/.test(character);
 }
-function isStreamingBody(body) {
-  return body instanceof ReadableStream || isAsyncIterableBody(body);
+function skipWhitespace(value, start) {
+  let index = start;
+  while (value[index] === ' ' || value[index] === '\t') {
+    index += 1;
+  }
+  return index;
 }
-function createReadableStreamFromAsyncIterable(source) {
-  const iterator = source[Symbol.asyncIterator]();
-  return new ReadableStream({
-    async cancel() {
-      await iterator.return?.();
-    },
-    async pull(controller) {
-      const {
-        done,
-        value
-      } = await iterator.next();
-      if (done) {
-        controller.close();
-        return;
-      }
-      controller.enqueue(value);
+function resolveMultipartStreamBody(request) {
+  if (request instanceof Request) {
+    if (!request.body) {
+      throw new Error('Multipart requests require a body.');
     }
-  });
+    return request.body;
+  }
+  const body = request.body ?? (typeof request[Symbol.asyncIterator] === 'function' ? request : undefined);
+  if (body instanceof ReadableStream) {
+    return body;
+  }
+  if (body && isAsyncIterableBody(body)) {
+    return createReadableStreamFromAsyncIterable(body);
+  }
+  if (body === undefined || body === null) {
+    throw new Error('Multipart requests require a body.');
+  }
+  const converted = new Request(request.url ?? 'http://localhost/', {
+    body: body,
+    method: request.method ?? 'POST'
+  }).body;
+  if (!converted) {
+    throw new Error('Multipart requests require a body.');
+  }
+  return converted;
 }
-function createMultipartRequest(url, method, headers, body, maxTotalSize) {
+function getContentLengthError(headers, maxTotalSize) {
   const contentLength = headers.get('content-length');
-  if (contentLength !== null) {
-    const parsedContentLength = Number(contentLength);
-    if (Number.isFinite(parsedContentLength) && parsedContentLength > maxTotalSize) {
-      throw new PayloadTooLargeException(`${MULTIPART_BODY_LIMIT_MESSAGE} ${String(maxTotalSize)} bytes.`);
+  if (contentLength === null) {
+    return undefined;
+  }
+  const parsedContentLength = Number(contentLength);
+  if (Number.isFinite(parsedContentLength) && parsedContentLength > maxTotalSize) {
+    return new PayloadTooLargeException(`${MULTIPART_BODY_LIMIT_MESSAGE} ${String(maxTotalSize)} bytes.`);
+  }
+  return undefined;
+}
+function indexOfBytes(input, needle) {
+  if (needle.byteLength === 0 || needle.byteLength > input.byteLength) {
+    return -1;
+  }
+  outer: for (let index = 0; index <= input.byteLength - needle.byteLength; index += 1) {
+    for (let offset = 0; offset < needle.byteLength; offset += 1) {
+      if (input[index + offset] !== needle[offset]) {
+        continue outer;
+      }
     }
+    return index;
   }
-  const init = {
-    headers,
-    method
-  };
-  if (body !== undefined) {
-    const limitedBody = body !== null && isStreamingBody(body) ? createByteLimitedReadableStream(body, maxTotalSize) : body;
-    init.body = limitedBody;
-    if (limitedBody instanceof ReadableStream) {
-      init.duplex = 'half';
+  return -1;
+}
+function matchesAt(input, needle, start) {
+  if (start + needle.byteLength > input.byteLength) {
+    return false;
+  }
+  for (let offset = 0; offset < needle.byteLength; offset += 1) {
+    if (input[start + offset] !== needle[offset]) {
+      return false;
+    }
+  }
+  return true;
+}
+function equalsBytes(left, right) {
+  return left.byteLength === right.byteLength && matchesAt(left, right, 0);
+}
+function concatBytes(chunks, size) {
+  const result = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
+}
+function trailingDelimiterPrefixLength(buffer, delimiter) {
+  const maximum = Math.min(buffer.byteLength, delimiter.byteLength - 1);
+  for (let size = maximum; size > 0; size -= 1) {
+    if (equalsBytes(buffer.slice(buffer.byteLength - size), delimiter.slice(0, size))) {
+      return size;
     }
   }
-  return new Request(url, init);
+  return 0;
 }
-function createByteLimitedReadableStream(stream, maxTotalSize) {
-  const source = stream instanceof ReadableStream ? stream : createReadableStreamFromAsyncIterable(stream);
-  const reader = source.getReader();
-  let totalSize = 0;
+function toAbortError(reason) {
+  return reason instanceof Error ? reason : new Error('Multipart request was aborted.');
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function appendMultipartField(fields, name, value) {
+  const existing = fields[name];
+  if (existing === undefined) {
+    fields[name] = value;
+    return;
+  }
+  if (Array.isArray(existing)) {
+    existing.push(value);
+    return;
+  }
+  fields[name] = [existing, value];
+}
+function isAsyncIterableBody(body) {
+  return body !== null && typeof body === 'object' && Symbol.asyncIterator in body;
+}
+function createReadableStreamFromAsyncIterable(source) {
+  const iterator = source[Symbol.asyncIterator]();
   return new ReadableStream({
-    async cancel(reason) {
-      await reader.cancel(reason);
+    async cancel() {
+      await iterator.return?.();
     },
     async pull(controller) {
       const {
         done,
         value
-      } = await reader.read();
+      } = await iterator.next();
       if (done) {
         controller.close();
         return;
       }
-      totalSize += value.byteLength;
-      if (totalSize > maxTotalSize) {
-        const error = new PayloadTooLargeException(`${MULTIPART_BODY_LIMIT_MESSAGE} ${String(maxTotalSize)} bytes.`);
-        await reader.cancel(error.message);
-        controller.error(error);
-        return;
-      }
       controller.enqueue(value);
     }
+  }, {
+    highWaterMark: 0
   });
 }
 function normalizeRequestHeaders(headers) {