@johntalton/http-util 4.1.1 → 5.0.0

package/src/range.js

@@ -0,0 +1,159 @@
+import { RANGE_UNITS_BYTES } from "./response/defs.js"
+
+export const RANGE_EQUAL = '='
+export const RANGE_SEPARATOR = '-'
+export const RANGE_LIST_SEPARATOR = ','
+
+/** @type {''} */
+export const RANGE_EMPTY = ''
+
+/**
+ * @typedef {Object} RangeValueFixed
+ * @property {number} start
+ * @property {number} end
+ */
+
+/**
+ * @typedef {Object} RangeValueOpenEnded
+ * @property {number} start
+ * @property {''} end
+ */
+
+/**
+ * @typedef {Object} RangeValueFromEnd
+ * @property {''} start
+ * @property {number} end
+ */
+
+/** @typedef {RangeValueFixed | RangeValueOpenEnded | RangeValueFromEnd} RangeValue */
+
+/** @typedef {RangeValueFixed} NormalizedRangeValue */
+
+/**
+ * @template RV
+ * @typedef {Object} RangeDirective
+ * @property {'bytes'|'none'|undefined} units
+ * @property {Array<RV>} ranges
+ */
+
+/**
+ * @typedef {Object} RangeDirectiveInfo
+ * @property {boolean} exceeds
+ * @property {boolean} overlap
+ */
+
+
+export class Range {
+	/**
+	 * @param {string|undefined} rangeHeader
+	 * @returns {RangeDirective<RangeValue>|undefined}
+	 */
+	static parse(rangeHeader) {
+		if(rangeHeader === undefined) { return undefined }
+		if(!rangeHeader.startsWith(RANGE_UNITS_BYTES)) { return undefined }
+		if(!(rangeHeader.substring(RANGE_UNITS_BYTES.length, RANGE_UNITS_BYTES.length + 1) === RANGE_EQUAL)) { return undefined }
+		const rangeStr = rangeHeader.substring(RANGE_UNITS_BYTES.length + RANGE_EQUAL.length).trim()
+		if(rangeStr === '') { return undefined }
+
+		const ranges = rangeStr.split(RANGE_LIST_SEPARATOR)
+			.map(range => range.trim())
+			.map(range => {
+				const [ startStr, endStr ] = range.split(RANGE_SEPARATOR)
+				if(startStr === undefined) { return undefined }
+				if(endStr === undefined) { return undefined }
+				if(startStr === RANGE_EMPTY && endStr === RANGE_EMPTY) { return undefined }
+
+				const start = Number.parseInt(startStr, 10)
+				const end = Number.parseInt(endStr, 10)
+
+				if(startStr === RANGE_EMPTY) {
+					if(!Number.isInteger(end)) { return undefined }
+					if(end === 0) { return undefined }
+					return { start: RANGE_EMPTY, end }
+				}
+
+				if(endStr === RANGE_EMPTY) {
+					if(!Number.isInteger(start)) { return undefined }
+					return { start, end: RANGE_EMPTY }
+				}
+
+				if(!Number.isInteger(start) || !Number.isInteger(end)) { return undefined }
+				return { start, end }
+			})
+			.filter(range => range !== undefined)
+
+		if(ranges.length === 0) { return undefined }
+
+		return {
+			units: RANGE_UNITS_BYTES,
+			ranges
+		}
+	}
+
+	/**
+	 * @param {RangeDirective<RangeValue>|undefined} directive
+	 * @param {number} contentLength
+	 * @returns {RangeDirectiveInfo & RangeDirective<NormalizedRangeValue>|undefined}
+	 */
+	static normalize(directive, contentLength) {
+		if(directive === undefined) { return undefined }
+
+		/** @type {Array<NormalizedRangeValue>} */
+		const normalizedRanges = directive.ranges.map(({ start, end }) => {
+			if(end === RANGE_EMPTY) { return { start, end: contentLength - 1 } }
+			if(start === RANGE_EMPTY) { return { start: contentLength - end, end: contentLength - 1 } }
+			return { start, end }
+		})
+
+		const exceeds = normalizedRanges.reduce((acc, value) => {
+			return acc || (value.start >= contentLength) || (value.end >= contentLength)
+		}, false)
+
+		const overlap = normalizedRanges
+			.toSorted((a, b) => a.start - b.start)
+			.reduce((acc, item) => {
+				return {
+					overlap: acc.overlap || acc.end > item.start,
+					end: item.end
+				}
+			}, { overlap: false, end: 0 })
+			.overlap
+
+		return {
+			units: directive.units,
+			overlap,
+			exceeds,
+			ranges: normalizedRanges
+		}
+	}
+}
+
+// console.log(Range.parse(''))
+// console.log(Range.parse('='))
+// console.log(Range.parse('foo'))
+// console.log(Range.parse('bytes'))
+// console.log(Range.parse('bytes='))
+// console.log(Range.parse('bytes=-'))
+// console.log(Range.parse('bytes=foo'))
+// console.log(Range.parse('bytes=0-foo'))
+// console.log(Range.parse('bytes=0-0xff'))
+// console.log()
+// console.log(Range.parse('bytes=1024-'))
+// console.log(Range.parse('bytes=-1024'))
+// console.log(Range.parse('bytes=0-1024'))
+// console.log()
+// console.log(Range.parse('bytes=0-0,-1'))
+// console.log(Range.parse('bytes=0-1024, -1024'))
+// console.log(Range.parse('bytes= 0-999, 4500-5499, -1000'))
+// console.log(Range.parse('bytes=500-600,601-999'))
+
+// console.log('------')
+// console.log(Range.normalize(Range.parse('bytes=1024-'), 5000))
+// console.log(Range.normalize(Range.parse('bytes=-1024'), 5000))
+// console.log(Range.normalize(Range.parse('bytes=0-1024'), 5000))
+// console.log(Range.normalize(Range.parse('bytes=0-0,-1'), 10000)) // 0 and 9999
+// console.log(Range.normalize(Range.parse('bytes=0-1024, -1024'), 5000))
+// console.log(Range.normalize(Range.parse('bytes= 0-999, 4500-5499, -1000'), 5000))
+// console.log(Range.normalize(Range.parse('bytes=500-600,601-999'), 5000))
+
+// console.log(Range.normalize(Range.parse('bytes=-500'), 10000)) // 9500-9999

package/src/response/bytes.js

@@ -0,0 +1,26 @@
+import http2 from 'node:http2'
+import { send_bytes } from './send-util.js'
+
+/** @import { ServerHttp2Stream } from 'node:http2' */
+/** @import { Metadata } from './defs.js' */
+/** @import { EtagItem } from '../conditional.js' */
+/** @import { CacheControlOptions } from '../cache-control.js' */
+/** @import { SendBody } from './send-util.js' */
+
+const { HTTP_STATUS_OK } = http2.constants
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {SendBody|undefined} obj
+ * @param {string|undefined} contentType
+ * @param {number|undefined} contentLength
+ * @param {string|undefined} encoding
+ * @param {EtagItem|undefined} etag
+ * @param {number|undefined} age
+ * @param {CacheControlOptions} cacheControl
+ * @param {'bytes'|'none'|undefined} acceptRanges
+ * @param {Metadata} meta
+ */
+export function sendBytes(stream, contentType, obj, contentLength, encoding, etag, age, cacheControl, acceptRanges, meta) {
+	send_bytes(stream, HTTP_STATUS_OK, contentType, obj, undefined, contentLength, encoding, etag, age, cacheControl, acceptRanges, undefined, meta)
+}

package/src/response/content-too-large.js

@@ -0,0 +1,15 @@
+import http2 from 'node:http2'
+import { send } from './send-util.js'
+
+/** @import { ServerHttp2Stream } from 'node:http2' */
+/** @import { Metadata } from './defs.js' */
+
+const { HTTP_STATUS_PAYLOAD_TOO_LARGE } = http2.constants
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {Metadata} meta
+ */
+export function sendContentTooLarge(stream, meta) {
+  send(stream, HTTP_STATUS_PAYLOAD_TOO_LARGE, {}, [], undefined, undefined, meta)
+}

package/src/response/defs.js

@@ -9,21 +9,33 @@ export const HTTP_HEADER_SEC_FETCH_SITE = 'sec-fetch-site'
 export const HTTP_HEADER_SEC_FETCH_MODE = 'sec-fetch-mode'
 export const HTTP_HEADER_SEC_FETCH_DEST = 'sec-fetch-dest'
 export const HTTP_HEADER_ACCEPT_POST = 'accept-post'
+export const HTTP_HEADER_ACCEPT_PATCH = 'accept-patch'
+
+export const HTTP_METHOD_QUERY = 'QUERY'
+export const HTTP_HEADER_ACCEPT_QUERY = 'accept-query'
 
 export const DEFAULT_METHODS = [ 'HEAD', 'GET', 'POST', 'PATCH', 'DELETE' ]
 
 export const HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE = 'access-control-max-age'
 export const PREFLIGHT_AGE_SECONDS = '500'
 
+/** @type {'bytes'} */
+export const RANGE_UNITS_BYTES = 'bytes'
+/** @type {'none'} */
+export const RANGE_UNITS_NONE = 'none'
 
 /** @import { TimingsInfo } from '../server-timing.js' */
 
+/**
+ * @typedef {`X-${string}`} CustomHeaderKey
+ */
+
 /**
  * @typedef {Object} Metadata
  * @property {Array<TimingsInfo>} performance
  * @property {string|undefined} servername
  * @property {string|undefined} origin
- * @property {Array<[ string, string ]>} customHeaders
+ * @property {Array<[ CustomHeaderKey, string ]>} customHeaders
  */
 
 /**

package/src/response/forbidden.js

@@ -0,0 +1,17 @@
+import http2 from 'node:http2'
+import { send } from './send-util.js'
+
+/** @import { ServerHttp2Stream } from 'node:http2' */
+/** @import { Metadata } from './defs.js' */
+
+const { HTTP_STATUS_FORBIDDEN} = http2.constants
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {Metadata} meta
+ */
+export function sendForbidden(stream, meta) {
+	throw new Error('unsupported')
+	send(stream, HTTP_STATUS_FORBIDDEN, {
+	}, [], undefined, undefined, meta)
+}

package/src/response/gone.js

@@ -0,0 +1,15 @@
+import http2 from 'node:http2'
+import { send } from './send-util.js'
+
+/** @import { ServerHttp2Stream } from 'node:http2' */
+/** @import { Metadata } from './defs.js' */
+
+const { HTTP_STATUS_GONE } = http2.constants
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {Metadata} meta
+ */
+export function sendGone(stream, meta) {
+  send(stream, HTTP_STATUS_GONE, {}, [], undefined, undefined, meta)
+}

package/src/response/im-a-teapot.js

@@ -0,0 +1,15 @@
+import http2 from 'node:http2'
+import { send } from './send-util.js'
+
+/** @import { ServerHttp2Stream } from 'node:http2' */
+/** @import { Metadata } from './defs.js' */
+
+const { HTTP_STATUS_TEAPOT } = http2.constants
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {Metadata} meta
+ */
+export function sendImATeapot(stream, meta) {
+  send(stream, HTTP_STATUS_TEAPOT, {}, [], undefined, undefined, meta)
+}

package/src/response/index.js

@@ -1,19 +1,33 @@
 export * from './defs.js'
+export * from './send-util.js'
 
 export * from './accepted.js'
+export * from './bytes.js'
 export * from './conflict.js'
+export * from './content-too-large.js'
 export * from './created.js'
 export * from './error.js'
+export * from './forbidden.js'
+export * from './gone.js'
+export * from './im-a-teapot.js'
+export * from './insufficient-storage.js'
 export * from './json.js'
+export * from './moved-permanently.js'
+export * from './multiple-choices.js'
 export * from './no-content.js'
 export * from './not-acceptable.js'
 export * from './not-allowed.js'
 export * from './not-found.js'
 export * from './not-implemented.js'
 export * from './not-modified.js'
+export * from './partial-content.js'
+export * from './permanent-redirect.js'
 export * from './precondition-failed.js'
 export * from './preflight.js'
+export * from './range-not-satisfiable.js'
+export * from './see-other.js'
 export * from './sse.js'
+export * from './temporary-redirect.js'
 export * from './timeout.js'
 export * from './too-many-requests.js'
 export * from './trace.js'

package/src/response/insufficient-storage.js

@@ -0,0 +1,15 @@
+import http2 from 'node:http2'
+import { send } from './send-util.js'
+
+/** @import { ServerHttp2Stream } from 'node:http2' */
+/** @import { Metadata } from './defs.js' */
+
+const { HTTP_STATUS_INSUFFICIENT_STORAGE } = http2.constants
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {Metadata} meta
+ */
+export function sendInsufficientStorage(stream, meta) {
+  send(stream, HTTP_STATUS_INSUFFICIENT_STORAGE, {}, [], undefined, undefined, meta)
+}

package/src/response/json.js

@@ -1,43 +1,15 @@
 import http2 from 'node:http2'
-import {
-	brotliCompressSync,
-	deflateSync,
-	gzipSync,
-	zstdCompressSync
-} from 'node:zlib'
-import {
-	CHARSET_UTF8,
-	CONTENT_TYPE_JSON
-} from '../content-type.js'
-import { send } from './send-util.js'
-import { Conditional } from '../conditional.js'
-import { CacheControl } from '../cache-control.js'
+
+import { send_encoded } from './send-util.js'
+import { CONTENT_TYPE_JSON } from '../content-type.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
 /** @import { EtagItem } from '../conditional.js' */
 /** @import { CacheControlOptions } from '../cache-control.js' */
 
-/** @typedef { (data: string, charset: BufferEncoding) => Buffer } EncoderFun */
-
-const {
-  HTTP2_HEADER_CONTENT_ENCODING,
-  HTTP2_HEADER_VARY,
-  HTTP2_HEADER_CACHE_CONTROL,
-  HTTP2_HEADER_ETAG,
-	HTTP2_HEADER_AGE
-} = http2.constants
-
 const { HTTP_STATUS_OK } = http2.constants
 
-/** @type {Map<string, EncoderFun>} */
-export const ENCODER_MAP = new Map([
-	[ 'br', (data, charset) => brotliCompressSync(Buffer.from(data, charset)) ],
-	[ 'gzip', (data, charset) => gzipSync(Buffer.from(data, charset)) ],
-	[ 'deflate', (data, charset) => deflateSync(Buffer.from(data, charset)) ],
-	[ 'zstd', (data, charset) => zstdCompressSync(Buffer.from(data, charset)) ]
-])
-
 /**
  * @param {ServerHttp2Stream} stream
  * @param {Object} obj
@@ -45,31 +17,12 @@ export const ENCODER_MAP = new Map([
  * @param {EtagItem|undefined} etag
  * @param {number|undefined} age
  * @param {CacheControlOptions} cacheControl
+ * @param {Array<string>|undefined} supportedQueryTypes
  * @param {Metadata} meta
  */
-export function sendJSON_Encoded(stream, obj, encoding, etag, age, cacheControl, meta) {
+export function sendJSON_Encoded(stream, obj, encoding, etag, age, cacheControl, supportedQueryTypes, meta) {
 	if(stream.closed) { return }
 
 	const json = JSON.stringify(obj)
-
-	const useIdentity = encoding === 'identity'
-	const encoder = encoding !== undefined ? ENCODER_MAP.get(encoding) : undefined
-	const hasEncoder = encoder !== undefined
-	const actualEncoding = hasEncoder ? encoding : undefined
-
-	const encodeStart = performance.now()
-	const encodedData = hasEncoder && !useIdentity ? encoder(json, CHARSET_UTF8) : json
-	const encodeEnd = performance.now()
-
-	meta.performance.push(
-		{ name: 'encode', duration: encodeEnd - encodeStart }
-	)
-
-	send(stream, HTTP_STATUS_OK, {
-			[HTTP2_HEADER_CONTENT_ENCODING]: actualEncoding,
-			[HTTP2_HEADER_VARY]: 'Accept, Accept-Encoding',
-			[HTTP2_HEADER_CACHE_CONTROL]: CacheControl.encode(cacheControl),
-			[HTTP2_HEADER_ETAG]: Conditional.encodeEtag(etag),
-			[HTTP2_HEADER_AGE]: age !== undefined ? `${age}` : undefined
-		}, [ HTTP2_HEADER_AGE ], CONTENT_TYPE_JSON, encodedData, meta)
+	send_encoded(stream, HTTP_STATUS_OK, CONTENT_TYPE_JSON, json, encoding, etag, age, cacheControl, undefined, supportedQueryTypes, meta)
 }

package/src/response/moved-permanently.js

@@ -0,0 +1,22 @@
+import http2 from 'node:http2'
+import { send } from './send-util.js'
+
+/** @import { ServerHttp2Stream } from 'node:http2' */
+/** @import { Metadata } from './defs.js' */
+
+const {
+  HTTP2_HEADER_LOCATION
+} = http2.constants
+
+const { HTTP_STATUS_MOVED_PERMANENTLY } = http2.constants
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {URL} location
+ * @param {Metadata} meta
+ */
+export function sendMovedPermanently(stream, location, meta) {
+  send(stream, HTTP_STATUS_MOVED_PERMANENTLY, {
+    [HTTP2_HEADER_LOCATION]: location.href
+  }, [ HTTP2_HEADER_LOCATION ], undefined, undefined, meta)
+}

package/src/response/multiple-choices.js

@@ -0,0 +1,20 @@
+import http2 from 'node:http2'
+import { send } from './send-util.js'
+
+/** @import { ServerHttp2Stream } from 'node:http2' */
+/** @import { Metadata } from './defs.js' */
+
+const { HTTP_STATUS_MULTIPLE_CHOICES } = http2.constants
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {Metadata} meta
+ */
+export function sendMultipleChoices(stream, meta) {
+	throw new Error('unsupported')
+	send(stream, HTTP_STATUS_MULTIPLE_CHOICES, {
+		// Alternates:
+		// TCN: list
+		// Vary: negotiate
+	}, [], undefined, undefined, meta)
+}

package/src/response/partial-content.js

@@ -0,0 +1,71 @@
+import http2 from 'node:http2'
+
+import { send_bytes } from './send-util.js'
+import { RANGE_UNITS_BYTES } from "./defs.js"
+import { Multipart } from '../multipart.js'
+import { MIME_TYPE_MULTIPART_RANGE } from '../content-type.js'
+
+/** @import { ServerHttp2Stream } from 'node:http2' */
+/** @import { Metadata } from './defs.js' */
+/** @import { EtagItem } from '../conditional.js' */
+/** @import { CacheControlOptions } from '../cache-control.js' */
+/** @import { ContentRangeDirective } from '../content-range.js' */
+/** @import { SendBody } from './send-util.js' */
+
+const { HTTP_STATUS_PARTIAL_CONTENT } = http2.constants
+
+/**
+ * @template T
+ * @typedef {[ T, ...T[] ]} NonEmptyArray
+ */
+
+/**
+ * @typedef {Object} PartialBytes
+ * @property {SendBody} obj
+ * @property {ContentRangeDirective} range
+ */
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {string} contentType
+ * @param {NonEmptyArray<PartialBytes>|PartialBytes} objs
+ * @param {number|undefined} contentLength
+ * @param {string|undefined} encoding
+ * @param {EtagItem|undefined} etag
+ * @param {number|undefined} age
+ * @param {CacheControlOptions} cacheControl
+ * @param {Metadata} meta
+ */
+export function sendPartialContent(stream, contentType, objs, contentLength, encoding, etag, age, cacheControl, meta) {
+	const acceptRanges = RANGE_UNITS_BYTES
+	const supportedQueryTypes = undefined
+
+	if(Array.isArray(objs) && objs.length > 1) {
+		// send using multipart bytes
+		const boundary = 'PARTIAL_CONTENT_BOUNDARY' // todo make unique for content
+		const obj = Multipart.encode_Bytes(contentType, objs, contentLength, boundary)
+
+		const multipartContentType = `${MIME_TYPE_MULTIPART_RANGE}; boundary=${boundary}`
+
+		send_bytes(
+			stream,
+			HTTP_STATUS_PARTIAL_CONTENT,
+			multipartContentType,
+			obj,
+			undefined,
+			undefined,
+			encoding,
+			etag,
+			age,
+			cacheControl,
+			acceptRanges,
+			supportedQueryTypes,
+			meta)
+
+		return
+	}
+
+	// single range, send as regular object
+	const obj = Array.isArray(objs) ? objs[0] : objs
+	send_bytes(stream, HTTP_STATUS_PARTIAL_CONTENT, contentType, obj.obj, obj.range, undefined, encoding, etag, age, cacheControl, acceptRanges, supportedQueryTypes, meta)
+}

package/src/response/permanent-redirect.js

@@ -0,0 +1,23 @@
+import http2 from 'node:http2'
+import { send } from './send-util.js'
+
+/** @import { ServerHttp2Stream } from 'node:http2' */
+/** @import { Metadata } from './defs.js' */
+
+const {
+	HTTP2_HEADER_LOCATION
+} = http2.constants
+
+const { HTTP_STATUS_PERMANENT_REDIRECT } = http2.constants
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {URL} location
+ * @param {Metadata} meta
+ */
+export function sendPermanentRedirect(stream, location, meta) {
+	throw new Error('unsupported')
+	send(stream, HTTP_STATUS_PERMANENT_REDIRECT, {
+		[HTTP2_HEADER_LOCATION]: location.href
+	}, [ HTTP2_HEADER_LOCATION ], undefined, undefined, meta)
+}

package/src/response/preflight.js

@@ -1,6 +1,8 @@
 import http2 from 'node:http2'
 import {
 	HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE,
+	HTTP_HEADER_ACCEPT_QUERY,
+	HTTP_METHOD_QUERY,
 	PREFLIGHT_AGE_SECONDS
 } from './defs.js'
 import { send } from './send-util.js'
@@ -14,7 +16,10 @@ const {
 	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS,
 	HTTP2_HEADER_IF_MATCH,
 	HTTP2_HEADER_IF_NONE_MATCH,
-	HTTP2_HEADER_AUTHORIZATION
+	HTTP2_HEADER_AUTHORIZATION,
+	HTTP2_HEADER_ACCEPT_RANGES,
+	HTTP2_HEADER_RANGE,
+	HTTP2_HEADER_IF_RANGE
 } = http2.constants
 
 const { HTTP_STATUS_OK } = http2.constants
@@ -22,18 +27,28 @@ const { HTTP_STATUS_OK } = http2.constants
 /**
  * @param {ServerHttp2Stream} stream
  * @param {Array<string>} methods
+ * @param {Array<string>|undefined} supportedQueryTypes
+ * @param {'byte'|'none'|undefined} acceptRanges
  * @param {Metadata} meta
  */
-export function sendPreflight(stream, methods, meta) {
+export function sendPreflight(stream, methods, supportedQueryTypes, acceptRanges, meta) {
+	const supportsQuery = methods.includes(HTTP_METHOD_QUERY) && supportedQueryTypes !== undefined && supportedQueryTypes.length > 0
+	const exposedHeadersAcceptQuery = supportsQuery ? [ HTTP_HEADER_ACCEPT_QUERY ] : []
+	const exposedHeaders = acceptRanges !== undefined ? [ HTTP2_HEADER_ACCEPT_RANGES, ...exposedHeadersAcceptQuery ] : exposedHeadersAcceptQuery
+
 	send(stream, HTTP_STATUS_OK, {
 			[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS]: methods.join(','),
 			[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS]: [
 				HTTP2_HEADER_IF_MATCH,
 				HTTP2_HEADER_IF_NONE_MATCH,
 				HTTP2_HEADER_AUTHORIZATION,
-				HTTP2_HEADER_CONTENT_TYPE
+				HTTP2_HEADER_CONTENT_TYPE,
+				HTTP2_HEADER_RANGE,
+				HTTP2_HEADER_IF_RANGE
 			].join(','),
-			[HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE]: PREFLIGHT_AGE_SECONDS
+			[HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE]: PREFLIGHT_AGE_SECONDS,
+			[HTTP2_HEADER_ACCEPT_RANGES]: acceptRanges,
+			[HTTP_HEADER_ACCEPT_QUERY]: supportedQueryTypes?.join(',')
 			// Access-Control-Allow-Credentials
-		}, [], undefined, undefined, meta)
+		}, exposedHeaders, undefined, undefined, meta)
 }

package/src/response/range-not-satisfiable.js

@@ -0,0 +1,27 @@
+import http2 from 'node:http2'
+import { send } from './send-util.js'
+import { CONTENT_RANGE_UNKNOWN, ContentRange } from '../content-range.js'
+
+/** @import { ServerHttp2Stream } from 'node:http2' */
+/** @import { Metadata } from './defs.js' */
+/** @import { ContentRangeDirective} from '../content-range.js' */
+
+const {
+	HTTP2_HEADER_CONTENT_RANGE
+} = http2.constants
+
+const { HTTP_STATUS_RANGE_NOT_SATISFIABLE } = http2.constants
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {ContentRangeDirective} rangeDirective
+ * @param {Metadata} meta
+ */
+export function sendRangeNotSatisfiable(stream, rangeDirective, meta) {
+	/** @type {ContentRangeDirective} */
+	const invalidRange = { size: rangeDirective.size, range: CONTENT_RANGE_UNKNOWN }
+
+	send(stream, HTTP_STATUS_RANGE_NOT_SATISFIABLE, {
+		[HTTP2_HEADER_CONTENT_RANGE]: ContentRange.encode(invalidRange)
+	}, [ HTTP2_HEADER_CONTENT_RANGE ], undefined, undefined, meta)
+}