@johntalton/http-util 6.1.0 → 7.0.2

package/README.md

@@ -64,7 +64,7 @@ All responders take in a `stream` as well as a metadata object to hint on server
 - [`sendGone`](#responsegone)
 - [`sendImATeapot`](#)
 - [`sendInsufficientStorage`](#)
-- [`sendJSON_Encoded`](#responsejson) - Standard Ok response with encoding
+- [`sendJSON`](#responsejson) - Standard Ok response with encoding
 - [`sendMovedPermanently`](#responsemovedpermanently)
 - [`sendMultipleChoices`](#)
 - [`sendNoContent`](#responsenocontent)

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@johntalton/http-util",
-  "version": "6.1.0",
+  "version": "7.0.2",
   "license": "MIT",
   "type": "module",
+  "sideEffects": false,
   "imports": {
     "#util": "./src/headers/util/index.js"
   },

package/src/body.js

@@ -1,3 +1,5 @@
+import { Readable } from 'node:stream'
+
 import {
 	CHARSET_UTF8,
 	MIME_TYPE_MULTIPART_FORM_DATA,
@@ -8,7 +10,6 @@ import { Multipart } from './headers/multipart.js'
 export const BYTE_PER_K = 1024
 export const DEFAULT_BYTE_LIMIT = BYTE_PER_K * BYTE_PER_K //
 
-/** @import { Readable } from 'node:stream' */
 /** @import { ContentTypeItem } from './headers/content-type.js' */
 
 /**
@@ -24,7 +25,7 @@ export const DEFAULT_BYTE_LIMIT = BYTE_PER_K * BYTE_PER_K //
  * @property {number} duration
  * @property {ReadableStream} body
  * @property {ContentTypeItem|undefined} contentType
- * @property { (mimetype: string) => Promise<Blob> } blob
+ * @property { (mimetype?: string | undefined) => Promise<Blob> } blob
  * @property { () => Promise<ArrayBufferLike> } arrayBuffer
  * @property { () => Promise<Uint8Array> } bytes
  * @property { () => Promise<string> } text
@@ -38,6 +39,8 @@ export const DEFAULT_BYTE_LIMIT = BYTE_PER_K * BYTE_PER_K //
  * @returns {BodyFuture}
  */
 export function requestBody(stream, options) {
+	if(!(stream instanceof Readable)) { throw new Error('stream is not Readable') }
+
 	const signal = options?.signal
 	const byteLimit = options?.byteLimit ?? DEFAULT_BYTE_LIMIT
 	const contentLength = options?.contentLength
@@ -93,7 +96,7 @@ export function requestBody(stream, options) {
 
 			const listener = () => {
 				stats.closed = true
-				controller.error(new Error('Abort Signal'))
+				controller.error(new Error(`Abort Signal (${signal?.reason})`))
 			}
 
 			signal?.addEventListener('abort', listener, { once: true })
@@ -101,7 +104,7 @@ export function requestBody(stream, options) {
 			stream.on('data', chunk => {
 				if(signal?.aborted) {
 					console.log('body reader aborted')
-					controller.error(new Error('Chunk read Abort Signal Timed out'))
+					controller.error(new Error(`Chunk read Abort Signal (${signal.reason})`))
 					stats.closed = true
 					return
 				}
@@ -114,8 +117,9 @@ export function requestBody(stream, options) {
 
 				// chunk is a node Buffer (which is a TypedArray)
 				if(!ArrayBuffer.isView(chunk)) {
-					controller.error('invalid chunk type')
+					controller.error(new Error('invalid chunk type'))
 					stats.closed = true
+					return
 				}
 
 				stats.byteLength += chunk.byteLength
@@ -157,6 +161,7 @@ export function requestBody(stream, options) {
 
 		cancel(reason) {
 			console.log('body reader canceled', reason)
+			// super.cancel(reason)
 		}
 	}
 
@@ -190,7 +195,7 @@ export function requestBody(stream, options) {
 		get body() { return makeReader() },
 		get contentType() { return contentType },
 
-		blob: (/** @type {string | undefined} */ mimetype) => wrap(reader => bodyBlob(reader, mimetype ?? contentType?.mimetype)),
+		blob: (/** @type {string | undefined} */ mimetype = undefined) => wrap(reader => bodyBlob(reader, mimetype ?? contentType?.mimetype)),
 		arrayBuffer: () => wrap(reader => bodyArrayBuffer(reader)),
 		bytes: () => wrap(reader => bodyUint8Array(reader)),
 		text: () => wrap(reader => bodyText(reader, charset)),

package/src/defs.js

@@ -1,3 +1,5 @@
+/** @import { Readable } from 'node:stream' */
+/** @import { ReadableStream } from 'node:stream/web' */
 
 export const HTTP_HEADER_ORIGIN = 'origin'
 export const HTTP_HEADER_USER_AGENT = 'user-agent'
@@ -26,9 +28,14 @@ export const RANGE_UNITS_BYTES = 'bytes'
 /** @type {'none'} */
 export const RANGE_UNITS_NONE = 'none'
 
+/** @description joiner used for concatenating multiple of the same headers into one */
+export const COMMON_LIST_HEADER_JOINER_COMMA = ', '
+
+/** @description joiner used for concatenating multiple values of single header */
+export const COMMON_LIST_VALUE_JOINER_COMMA = ','
 
 /** @import { TimingsInfo } from './headers/server-timing.js' */
-/** @import { EtagItem, IMFFixDateInput,  } from './headers/conditional.js' */
+/** @import { EtagItem, IMFFixDateInput } from './headers/conditional.js' */
 /** @import { CacheControlOptions } from './headers/cache-control.js' */
 /** @import { ContentRangeDirective } from './headers/content-range.js' */
 /** @import { RateLimitPolicyInfo, RateLimitInfo } from './headers/rate-limit.js' */
@@ -44,7 +51,7 @@ export const RANGE_UNITS_NONE = 'none'
  * @property {Array<TimingsInfo>} performance
  * @property {string|undefined} servername
  * @property {string|undefined} origin
- * @property {Array<[ CustomHeaderKey, string ]>|undefined} [customHeaders]
+ * @property {Array<[ CustomHeaderKey, string | Array<string> ]>|undefined} [customHeaders]
  */
 
 /**
@@ -53,7 +60,9 @@ export const RANGE_UNITS_NONE = 'none'
  * @property {boolean} [bom]
  */
 
-/** @typedef {ArrayBufferLike|ArrayBufferView|ReadableStream|string} SendBody */
+/** @typedef {NodeJS.TypedArray<ArrayBuffer>} TypedArray */
+/** @typedef {ArrayBuffer | TypedArray | string} SendBodyTypes */
+/** @typedef { SendBodyTypes | ReadableStream<SendBodyTypes> | Readable } SendBody */
 
 /**
  * @typedef {Object} SendContent
@@ -70,8 +79,8 @@ export const RANGE_UNITS_NONE = 'none'
 /**
  * @typedef {Object} SendInfo
  * @property {Array<string>} supportedMethods
- * @property {Array<string>|string} supportedTypes
- * @property {Array<string>|string} acceptableMediaType
+ * @property {Array<string>|string} supportedTypes for content negotiation failures
+ * @property {Array<string>|string} acceptableMediaType for incoming post/put unsupported types
  * @property {AcceptRangeUnits|undefined} acceptRanges
  * @property {Array<string>|undefined} supportedQueryTypes
  * @property {RateLimitInfo} limitInfo

package/src/headers/accept-encoding.js

@@ -18,6 +18,8 @@ export class AcceptEncoding {
 	}
 
 	/**
+	 * @deprecated
+	 * @see {@link AcceptEncoding.selectItemFrom}
 	 * @param {string|undefined} acceptEncodingHeader
 	 * @param {Array<string>} supportedTypes
 	 */
@@ -27,24 +29,45 @@ export class AcceptEncoding {
 	}
 
 	/**
-	 * @param {Array<AcceptStyleItem>} acceptEncodings
-	 * @param {Array<string>} supportedTypes
+	 * @param {Array<AcceptStyleItem>} acceptEncodings (descending quality order)
+	 * @param {Array<string>} supportedTypes (descending preferred order)
+	 * @returns {AcceptStyleItem | undefined}
 	 */
-	static selectFrom(acceptEncodings, supportedTypes) {
+	static selectItemFrom(acceptEncodings, supportedTypes) {
+		if(acceptEncodings === undefined) { return undefined }
+		if(!Array.isArray(acceptEncodings)) { return undefined }
+		if(acceptEncodings.length === 0) { return undefined }
+
 		if(supportedTypes === undefined) { return undefined }
+		if(!Array.isArray(supportedTypes)) { return undefined }
+		if(supportedTypes.length === 0) { return undefined }
 
 		for(const acceptEncoding of acceptEncodings) {
 			const { name } = acceptEncoding
 			if(supportedTypes.includes(name)) {
-				return name
+				return acceptEncoding
 			 }
 		}
 
 		//
 		if(acceptEncodings.some(item => item.name === ENCODING_ANY)) {
-			return supportedTypes.at(0)
+			const [ name ] = supportedTypes
+			if(name === undefined) { return undefined }
+			return { name }
 		}
 
 		return undefined
 	}
+
+	/**
+	 * @deprecated
+	 * @see {@link AcceptEncoding.selectItemFrom}
+	 * @param {Array<AcceptStyleItem>} acceptEncodings
+	 * @param {Array<string>} supportedTypes
+	 * @returns {string | undefined}
+	 */
+	static selectFrom(acceptEncodings, supportedTypes) {
+		const item = AcceptEncoding.selectItemFrom(acceptEncodings, supportedTypes)
+		return item?.name
+	}
 }

package/src/headers/accept-language.js

@@ -19,6 +19,8 @@ export class AcceptLanguage {
 	}
 
 	/**
+	 * @deprecated
+	 * @see {@link AcceptLanguage.selectItemFrom}
 	 * @param {string|undefined} acceptLanguageHeader
 	 * @param {Array<string>} supportedTypes
 	 */
@@ -28,24 +30,46 @@ export class AcceptLanguage {
 	}
 
 	/**
-	 * @param {Array<AcceptStyleItem>} acceptLanguages
-	 * @param {Array<string>} supportedTypes
+	 * @param {Array<AcceptStyleItem>} acceptLanguages (descending quality order)
+	 * @param {Array<string>} supportedTypes (descending preferred order)
+	 * @returns {AcceptStyleItem | undefined}
 	 */
-	static selectFrom(acceptLanguages, supportedTypes) {
+	static selectItemFrom(acceptLanguages, supportedTypes) {
+		if(acceptLanguages === undefined) { return undefined }
+		if(!Array.isArray(acceptLanguages)) { return undefined }
+		if(acceptLanguages.length === 0) { return undefined }
+
 		if(supportedTypes === undefined) { return undefined }
+		if(!Array.isArray(supportedTypes)) { return undefined }
+		if(supportedTypes.length === 0) { return undefined }
 
+		// this assume acceptLangues is quality sorted descending order
 		for(const acceptLanguage of acceptLanguages) {
 			const { name } = acceptLanguage
 			if(supportedTypes.includes(name)) {
-				return name
+				return acceptLanguage
 			}
 		}
 
 		//
 		if(acceptLanguages.some(item => item.name === LANGUAGE_ANY)) {
-			return supportedTypes.at(0)
+			const name = supportedTypes.at(0)
+			if(name === undefined) { return undefined }
+			return { name }
 		}
 
 		return undefined
 	}
+
+	/**
+	 * @deprecated
+	 * @see {@link AcceptLanguage.selectItemFrom}
+	 * @param {Array<AcceptStyleItem>} acceptLanguages
+	 * @param {Array<string>} supportedTypes
+	 * @returns {string | undefined}
+	 */
+	static selectFrom(acceptLanguages, supportedTypes) {
+		const item = AcceptLanguage.selectItemFrom(acceptLanguages, supportedTypes)
+		return item?.name
+	}
 }

package/src/headers/accept.js

@@ -1,5 +1,5 @@
 import { parseAcceptStyleHeader } from './util/accept-util.js'
-import { MIME_ANY, Mime } from './util/mime.js'
+import { MIME_ANY, MIME_SEPARATOR, Mime } from './util/mime.js'
 
 /** @import { AcceptStyleItem } from './util/accept-util.js' */
 /** @import { MimeItem } from './util/mime.js' */
@@ -11,7 +11,30 @@ export const WELL_KNOWN = new Map([
 	[ 'application/json', [ { name: 'application/json', quality: 1 } ] ]
 ])
 
+export const UNSPECIFIED_QUALITY = 1
+
 export class Accept {
+	/**
+	 * Descending order based on quality and higher specificity.
+	 *
+	 * Returns negative is the first item (a) is of higher quality then second (b).
+	 * @param {AcceptItem} a
+	 * @param {AcceptItem} b
+	 */
+	static compare(a, b) {
+		if(a.quality === b.quality) {
+			// prefer things with less ANY
+			const specificityA = (a.type === MIME_ANY ? 1 : 0) + (a.subtype === MIME_ANY ? 1 : 0)
+			const specificityB = (b.type === MIME_ANY ? 1 : 0) + (b.subtype === MIME_ANY ? 1 : 0)
+			return Math.sign(specificityA - specificityB)
+		}
+
+		// B - A descending order
+		const qualityB = b.quality ?? UNSPECIFIED_QUALITY
+		const qualityA = a.quality ?? UNSPECIFIED_QUALITY
+		return Math.sign(qualityB - qualityA)
+	}
+
 	/**
 	 * @param {string|undefined} acceptHeader
 	 * @returns {Array<AcceptItem>}
@@ -31,22 +54,12 @@ export class Accept {
 				}
 			})
 			.filter(entry => entry !== undefined)
-			.sort((entryA, entryB) => {
-				if(entryA.quality === entryB.quality) {
-					// prefer things with less ANY
-					const specificityA = (entryA.type === MIME_ANY ? 1 : 0) + (entryA.subtype === MIME_ANY ? 1 : 0)
-					const specificityB = (entryB.type === MIME_ANY ? 1 : 0) + (entryB.subtype === MIME_ANY ? 1 : 0)
-					return specificityA - specificityB
-				}
-
-				// B - A descending order
-				const qualityB = entryB.quality ?? 0
-				const qualityA = entryA.quality ?? 0
-				return qualityB - qualityA
-			})
+			.sort(Accept.compare)
 	}
 
 	/**
+	 * @deprecated
+	 * @see {@link Accept.selectItemFrom}
 	 * @param {string|undefined} acceptHeader
 	 * @param {Array<string>} supportedTypes
 	 */
@@ -58,29 +71,61 @@ export class Accept {
 	/**
 	 * @param {Array<AcceptItem>} accepts
 	 * @param {Array<string>} supportedTypes
+	 * @returns {AcceptItem | undefined}
 	 */
-	static selectFrom(accepts, supportedTypes) {
-		const bests = accepts.map(accept => {
-			const { type, subtype, quality } = accept
-			const st = supportedTypes.filter(supportedType => {
-				const supportedMime = Mime.parse(supportedType)
-				if(supportedMime === undefined) { return false }
-				return ((supportedMime.type === type || type === MIME_ANY) && (supportedMime.subtype === subtype || subtype === MIME_ANY))
-			})
+	static selectItemFrom(accepts, supportedTypes) {
+		if(accepts === undefined) { return undefined }
+		if(!Array.isArray(accepts)) { return undefined }
+		if(accepts.length === 0) { return undefined }
+
+		if(supportedTypes === undefined) { return undefined }
+		if(!Array.isArray(supportedTypes)) { return undefined }
+		if(supportedTypes.length === 0) { return undefined }
+
+		const supportedMimeTypes = supportedTypes
+			.map(Mime.parse)
+			.filter(m => m !== undefined)
+
+		// todo if supportedMimeType has ANY show warning?
 
+		if(supportedMimeTypes.length === 0) { return undefined }
+
+		const matches = accepts.map(accept => {
+			const matchSupportedMimeTypes = supportedMimeTypes.filter(mt => Mime.matches(accept, mt))
+			const best = matchSupportedMimeTypes.at(0)
+			if(best === undefined) { return undefined }
+
+			// resolve mime type and subtype
+			const type = best.type === MIME_ANY ? accept.type : best.type
+			const subtype = best.subtype === MIME_ANY ? accept.subtype : best.subtype
+
+			// preserve name and parameters of source
 			return {
-				supportedTypes: st,
-				quality
+				...accept,
+				mimetype: `${type}${MIME_SEPARATOR.SUBTYPE}${subtype}`,
+				type,
+				subtype
 			}
 		})
-		.filter(best => best.supportedTypes.length > 0)
+		.filter(m => m !== undefined)
 
-		if(bests.length === 0) { return undefined }
-		const [ first ] = bests
-		if(first === undefined) { return undefined }
-		const [ firstSt ] = first.supportedTypes
-		return firstSt
-	}
-}
+		if(matches.length === 0) { return undefined }
+
+		// sort is in-place
+		matches.sort(Accept.compare)
 
+		return matches.at(0)
+	}
 
+	/**
+	 * @deprecated
+	 * @see {@link Accept.selectItemFrom}
+	 * @param {Array<AcceptItem>} accepts
+	 * @param {Array<string>} supportedTypes
+	 * @returns {string | undefined}
+	 */
+	static selectFrom(accepts, supportedTypes) {
+		const item = Accept.selectItemFrom(accepts, supportedTypes)
+		return item?.mimetype
+	}
+}

package/src/headers/cache-control.js

@@ -1,3 +1,5 @@
+import { COMMON_LIST_HEADER_JOINER_COMMA } from "../defs.js"
+
 /** @typedef {'no-cache'|'no-store'|'no-transform'|'must-revalidate'|'immutable'|'must-understand'} Directives */
 
 /**
@@ -13,9 +15,10 @@
 export class CacheControl {
 	/**
 	 * @param {CacheControlOptions|undefined} options
-	 * @returns {string|undefined}
+	 * @param {boolean} [asArray = false]
+	 * @returns {Array<string>|string|undefined}
 	 */
-	static encode(options) {
+	static encode(options, asArray = false) {
 		if(options === undefined) { return undefined }
 
 		const {
@@ -51,6 +54,6 @@ export class CacheControl {
 		//
 		if(result.length === 0) { return undefined }
 
-		return result.join(', ')
+		return asArray ? result : result.join(COMMON_LIST_HEADER_JOINER_COMMA)
 	}
 }

package/src/headers/client-hints.js

@@ -1,4 +1,4 @@
-
+import { COMMON_LIST_HEADER_JOINER_COMMA } from "../defs.js"
 
 export const CLIENT_HINT_USER_AGENT = 'Sec-CH-UA'
 export const CLIENT_HINT_ARCHITECTURE = 'Sec-CH-UA-Arch'
@@ -69,8 +69,9 @@ export class ClientHints {
 
 	/**
 	 * @param {Array<String>} hints
+	 * @param {boolean} [asArray = false]
 	 */
-	static encode(hints) {
+	static encode(hints, asArray = false) {
 		if(hints === undefined) { return undefined }
 		if(!Array.isArray(hints)) { return undefined }
 		if(hints.length === 0) { return undefined }
@@ -80,7 +81,7 @@ export class ClientHints {
 
 		if(remaining.length === 0) { return undefined }
 
-		return remaining.join(', ')
+		return asArray ? remaining : remaining.join(COMMON_LIST_HEADER_JOINER_COMMA)
 	}
 }
 

package/src/headers/conditional.js

@@ -102,7 +102,7 @@ export class ETag {
 	static isValid(etag) {
 		if(etag === undefined) { return false }
 
-		// %x21 / %x23-7E  and %x80-FF
+		// %x21 / %x23-7E and %x80-FF
 		for(const c of etag) {
 			if(c.charCodeAt(0) < 0x21) { return false }
 			if(c.charCodeAt(0) > 0xFF) { return false }
@@ -143,7 +143,7 @@ export class ETag {
 
 		const rawEtag = raw.trim()
 		const weak = rawEtag.startsWith(CONDITION_ETAG_WEAK_PREFIX)
-		const quotedEtag = weak ? rawEtag.substring(CONDITION_ETAG_WEAK_PREFIX.length) : rawEtag
+		const quotedEtag = weak ? rawEtag.slice(CONDITION_ETAG_WEAK_PREFIX.length) : rawEtag
 
 		if(quotedEtag === CONDITION_ETAG_ANY) { return ANY_ETAG_ITEM }
 
@@ -350,18 +350,18 @@ export class Conditional {
 
 		//
 		const spaces = [
-			matchHeader.substring(4, 5),
-			matchHeader.substring(7, 8),
-			matchHeader.substring(11, 12),
-			matchHeader.substring(16, 17),
-			matchHeader.substring(25, 26)
+			matchHeader.slice(4, 5),
+			matchHeader.slice(7, 8),
+			matchHeader.slice(11, 12),
+			matchHeader.slice(16, 17),
+			matchHeader.slice(25, 26)
 		]
-		const comma = matchHeader.substring(3, 4)
+		const comma = matchHeader.slice(3, 4)
 		const timeSeparators = [
-			matchHeader.substring(19, 20),
-			matchHeader.substring(22, 23)
+			matchHeader.slice(19, 20),
+			matchHeader.slice(22, 23)
 		]
-		const gmt = matchHeader.substring(26)
+		const gmt = matchHeader.slice(26)
 
 		//
 		if(comma !== DATE_SEPARATOR) { return undefined }
@@ -374,13 +374,13 @@ export class Conditional {
 		}
 
 		//
-		const dayName = matchHeader.substring(0, 3)
-		const day = Number.parseInt(matchHeader.substring(5, 7))
-		const month = matchHeader.substring(8, 11)
-		const year = Number.parseInt(matchHeader.substring(12, 16))
-		const hour = Number.parseInt(matchHeader.substring(17, 19))
-		const minute = Number.parseInt(matchHeader.substring(20, 22))
-		const second = Number.parseInt(matchHeader.substring(23, 25))
+		const dayName = matchHeader.slice(0, 3)
+		const day = Number.parseInt(matchHeader.slice(5, 7))
+		const month = matchHeader.slice(8, 11)
+		const year = Number.parseInt(matchHeader.slice(12, 16))
+		const hour = Number.parseInt(matchHeader.slice(17, 19))
+		const minute = Number.parseInt(matchHeader.slice(20, 22))
+		const second = Number.parseInt(matchHeader.slice(23, 25))
 
 		//
 		if(!DATE_DAYS.includes(dayName)) { return undefined }

package/src/headers/content-type.js

@@ -16,7 +16,7 @@ export const MIME_TYPE_MESSAGE_HTTP = 'message/http'
 
 export const KNOWN_CONTENT_TYPES = [
 	'application', 'audio', 'image', 'message',
-	'multipart','text', 'video'
+	'multipart', 'text', 'video'
 ]
 
 export const TYPE_X_TOKEN_PREFIX = 'X-'

package/src/headers/link.js

@@ -1,3 +1,5 @@
+import { COMMON_LIST_HEADER_JOINER_COMMA } from "../defs.js"
+
 /**
  * @typedef {Object} LinkItem
  * @property {URL|string} url
@@ -9,7 +11,7 @@ export class Link {
 	/**
 	 * @param {LinkItem} link
 	 */
-	static  *#encode(link) {
+	static *#encode(link) {
 		const encodedUri = (link.url instanceof URL) ? link.url : encodeURI(link.url)
 
 		yield `<${encodedUri}>`
@@ -22,13 +24,16 @@ export class Link {
 
 	/**
 	 * @param {Array<LinkItem>|LinkItem|undefined} links
+	 * @param {boolean} [asArray = false]
 	 */
-	static encode(links) {
+	static encode(links, asArray = false) {
 		if(links === undefined) { return undefined }
 		const linkAry = Array.isArray(links) ? links : [ links ]
 		if(linkAry.length === 0) { return undefined }
-		return linkAry
+
+		const ary = linkAry
 			.map(link => [ ...Link.#encode(link) ].join('; '))
-			.join(', ')
+
+		return asArray ? ary : ary.join(COMMON_LIST_HEADER_JOINER_COMMA)
 	}
 }

package/src/headers/multipart.js

@@ -1,9 +1,8 @@
 import { ReadableStream } from 'node:stream/web'
 
-import { isQuoted, stripQuotes } from '../headers/util/quote.js'
 import { ContentDisposition } from './content-disposition.js'
 import { ContentRange } from './content-range.js'
-import { ContentType } from './content-type.js'
+// import { ContentType } from './content-type.js'
 
 /** @import { ContentRangeDirective } from './content-range.js' */
 /** @import { SendBody } from '../defs.js' */
@@ -65,11 +64,6 @@ export class Multipart {
 
 		const lines = text.split(MULTIPART_SEPARATOR)
 
-		if(lines.length === 0) {
-			// missing body?
-			return formData
-		}
-
 		const boundaryBegin = `${BOUNDARY_MARK}${boundary}`
 		const boundaryEnd = `${BOUNDARY_MARK}${boundary}${BOUNDARY_MARK}`
 
@@ -98,7 +92,7 @@ export class Multipart {
 					const name = rawName?.toLowerCase()
 					// console.log('header', name, value)
 					if(name === MULTIPART_HEADER.CONTENT_TYPE) {
-						const contentType = ContentType.parse(value)
+						//const contentType = ContentType.parse(value)
 						//console.log({ contentType })
 					}
 					else if(name === MULTIPART_HEADER.CONTENT_DISPOSITION) {
@@ -107,7 +101,10 @@ export class Multipart {
 							throw new Error('disposition not form-data')
 						}
 
-						partName = isQuoted(disposition.name) ? stripQuotes(disposition.name) : disposition.name
+						partName = disposition.name
+					}
+					else if(name === MULTIPART_HEADER.CONTENT_RANGE) {
+						// todo
 					}
 					else {
 						// unsupported part header - ignore
@@ -131,10 +128,9 @@ export class Multipart {
 				}
 				state = MULTIPART_STATE.HEADERS
 			}
-			else {
-				throw new Error('unknown state')
-			}
-
+			// else {
+			// 	throw new Error('unknown state')
+			// }
 		}
 
 		return formData
@@ -145,7 +141,7 @@ export class Multipart {
 	 * @param {Array<MultipartBytePart>} parts
 	 * @param {number|undefined} contentLength
 	 * @param {string} boundary
-	 * @returns {ReadableStream<Uint8Array>}
+	 * @returns {ReadableStream<Uint8Array<ArrayBuffer>>}
 	 */
 	static encode_Bytes(contentType, parts, contentLength, boundary) {
 		const boundaryBegin = `${BOUNDARY_MARK}${boundary}`
@@ -166,16 +162,21 @@ export class Multipart {
 					if(part.obj instanceof ReadableStream) {
 						// biome-ignore lint/performance/noAwaitInLoops: readable
 						for await (const chunk of part.obj) {
-							if(chunk instanceof ArrayBuffer || ArrayBuffer.isView(chunk)) {
+							if(chunk instanceof ArrayBuffer) {
+								controller.enqueue(new Uint8Array(chunk))
+							}
+							else if(ArrayBuffer.isView(chunk)) {
 								controller.enqueue(chunk)
 							}
 							else if(typeof chunk === 'string'){
 								controller.enqueue(encoder.encode(chunk))
 							}
-							else {
-								// console.log('chunk type', typeof chunk)
+							else if(typeof chunk === 'number') {
 								controller.enqueue(Uint8Array.from([ chunk ]))
 							}
+							else {
+								controller.error(new Error('unknown stream chunk type'))
+							}
 						}
 					}
 					else if(part.obj instanceof ArrayBuffer) {