@johntalton/http-util 2.0.4 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johntalton/http-util",
-  "version": "2.0.4",
+  "version": "3.0.0",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/conditional.js

@@ -1,8 +1,47 @@
+
+/**
+ * @typedef {Object} WeakEtagItem
+ * @property {true} weak
+ * @property {false} any
+ * @property {string} etag
+ */
+
+/**
+ * @typedef {Object} AnyEtagItem
+ * @property {boolean} weak
+ * @property {true} any
+ * @property {'*'} etag
+ */
+
+/**
+ * @typedef {Object} NotWeakEtagItem
+ * @property {false} weak
+ * @property {false} any
+ * @property {string} etag
+ */
+
+/** @typedef {WeakEtagItem | NotWeakEtagItem | AnyEtagItem } EtagItem */
+
+/**
+ * @typedef {Object} IMFFixDate
+ * @property {typeof DATE_DAYS[number]} dayName
+ * @property {number} day
+ * @property {typeof DATE_MONTHS[number]} month
+ * @property {number} year
+ * @property {number} hour
+ * @property {number} minute
+ * @property {number} second
+ * @property {Date} date
+ */
+
 export const CONDITION_ETAG_SEPARATOR = ','
 export const CONDITION_ETAG_ANY = '*'
 export const CONDITION_ETAG_WEAK_PREFIX = 'W/'
 export const ETAG_QUOTE = '"'
 
+/** @type {AnyEtagItem} */
+export const ANY_ETAG_ITEM = { any: true, weak: false, etag: CONDITION_ETAG_ANY }
+
 export const DATE_SPACE = ' '
 export const DATE_DAYS = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
 export const DATE_MONTHS = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
@@ -40,26 +79,25 @@ export function isQuoted(etag) {
 	return true
 }
 
-/**
- * @typedef {Object} EtagItem
- * @property {boolean} weak
- * @property {boolean} any
- * @property {string} etag
- */
+export class Conditional {
+	/**
+	 * @param {EtagItem|undefined} etagItem
+	 * @returns {string|undefined}
+	 */
+	static encodeEtag(etagItem) {
+		if(etagItem === undefined) { return undefined }
+		if(etagItem.any) {
+			if(etagItem.etag !== CONDITION_ETAG_ANY) { return undefined }
+			return CONDITION_ETAG_ANY
+		}
 
-/**
- * @typedef {Object} IMFFixDate
- * @property {typeof DATE_DAYS[number]} dayName
- * @property {number} day
- * @property {typeof DATE_MONTHS[number]} month
- * @property {number} year
- * @property {number} hour
- * @property {number} minute
- * @property {number} second
- * @property {Date} date
- */
+		if(etagItem.etag === CONDITION_ETAG_ANY) { return undefined }
+		if(!isValidEtag(etagItem.etag)) { return undefined }
+
+		const prefix = etagItem.weak ? CONDITION_ETAG_WEAK_PREFIX : ''
+		return `${prefix}${ETAG_QUOTE}${etagItem.etag}${ETAG_QUOTE}`
+	}
 
-export class Conditional {
 	/**
 	 * @param {string|undefined} matchHeader
 	 * @returns {Array<EtagItem>}
@@ -85,12 +123,7 @@ export class Conditional {
 				}
 			})
 			.map(item => {
-				if(item.etag === CONDITION_ETAG_ANY) {
-					return {
-						...item,
-						any: true
-					}
-				}
+				if(item.etag === CONDITION_ETAG_ANY) { return ANY_ETAG_ITEM }
 
 				// validated quoted
 				if(!isQuoted(item.etag)) { return undefined }
@@ -98,11 +131,14 @@ export class Conditional {
 				if(!isValidEtag(etag)) { return undefined }
 				if(etag === CONDITION_ETAG_ANY) { return undefined }
 
-				return {
+				/** @type {WeakEtagItem | NotWeakEtagItem} */
+				const result = {
 					weak: item.weak,
 					any: false,
 					etag
 				}
+
+				return result
 			})
 			.filter(item => item !== undefined)
 	}
@@ -187,6 +223,20 @@ export class Conditional {
 	}
 }
 
+// Ok
+// console.log(Conditional.encodeEtag({ any: true, weak: false, etag: '*' }))
+// console.log(Conditional.encodeEtag({ any: true, weak: true, etag: '*' }))
+// console.log(Conditional.encodeEtag({ any: false, weak: false, etag: 'Foo' }))
+// console.log(Conditional.encodeEtag({ any: false, weak: true, etag: 'WeakFoo' }))
+
+// Error
+// console.log(Conditional.encodeEtag(undefined))
+// console.log(Conditional.encodeEtag({ any: true, weak: false, etag: 'NotAsterisk' }))
+// console.log(Conditional.encodeEtag({ any: false, weak: false, etag: 'Foo\tBar' }))
+// console.log(Conditional.encodeEtag({ any: false, weak: false, etag: 'Foo"Bar' }))
+// console.log(Conditional.encodeEtag({ any: false, weak: false, etag: '*' }))
+
+
 // Ok
 // console.log(Conditional.parseEtagList('"bfc13a64729c4290ef5b2c2730249c88ca92d82d"'))
 // console.log(Conditional.parseEtagList('W/"67ab43", "54ed21", "7892dd"'))
@@ -225,6 +275,8 @@ export class Conditional {
 // 	}
 // }
 
+
+
 // const testBad = [
 // 	undefined,
 // 	null,

package/src/content-type.js

@@ -65,6 +65,7 @@ export const CHARSET = 'charset'
 export const PARAMETER_CHARSET_UTF8 = `${CHARSET}${CONTENT_TYPE_SEPARATOR.KVP}${CHARSET_UTF8}`
 export const CONTENT_TYPE_JSON = `${MIME_TYPE_JSON}${CONTENT_TYPE_SEPARATOR.PARAMETER}${PARAMETER_CHARSET_UTF8}`
 export const CONTENT_TYPE_TEXT = `${MIME_TYPE_TEXT}${CONTENT_TYPE_SEPARATOR.PARAMETER}${PARAMETER_CHARSET_UTF8}`
+export const CONTENT_TYPE_MESSAGE_HTTP = `${MIME_TYPE_MESSAGE_HTTP}${CONTENT_TYPE_SEPARATOR.PARAMETER}${PARAMETER_CHARSET_UTF8}`
 
 /** @type {ContentType} */
 export const WELL_KNOWN_JSON = {

package/src/response/accepted.js

@@ -1,39 +1,15 @@
 import http2 from 'node:http2'
-import { CONTENT_TYPE_JSON } from '../content-type.js'
-import {
-	HTTP_HEADER_TIMING_ALLOW_ORIGIN,
-	HTTP_HEADER_SERVER_TIMING,
-	ServerTiming
-} from '../server-timing.js'
+import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
 
-const {
-  HTTP_STATUS_ACCEPTED
-} = http2.constants
-
-const {
-  HTTP2_HEADER_STATUS,
-  HTTP2_HEADER_SERVER,
-  HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN
-} = http2.constants
+const { HTTP_STATUS_ACCEPTED } = http2.constants
 
 /**
  * @param {ServerHttp2Stream} stream
  * @param {Metadata} meta
  */
 export function sendAccepted(stream, meta) {
-	stream.respond({
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_ACCEPTED,
-		// [HTTP2_HEADER_CONTENT_TYPE]: CONTENT_TYPE_JSON,
-		[HTTP2_HEADER_SERVER]: meta.servername,
-		[HTTP_HEADER_TIMING_ALLOW_ORIGIN]: meta.origin,
-		[HTTP_HEADER_SERVER_TIMING]: ServerTiming.encode(meta.performance)
-	})
-
-	// stream.write(JSON.stringify( ... ))
-
-	stream.end()
-}
+	send(stream, HTTP_STATUS_ACCEPTED, {}, undefined, undefined, meta)
+}

package/src/response/conflict.js

@@ -1,39 +1,15 @@
 import http2 from 'node:http2'
-import { CONTENT_TYPE_JSON } from '../content-type.js'
-import {
-	HTTP_HEADER_TIMING_ALLOW_ORIGIN,
-	HTTP_HEADER_SERVER_TIMING,
-	ServerTiming
-} from '../server-timing.js'
+import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
 
-const {
-	HTTP_STATUS_CONFLICT
-} = http2.constants
-
-const {
-	HTTP2_HEADER_STATUS,
-	HTTP2_HEADER_SERVER,
-	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN
-} = http2.constants
+const { HTTP_STATUS_CONFLICT } = http2.constants
 
 /**
  * @param {ServerHttp2Stream} stream
  * @param {Metadata} meta
  */
 export function sendConflict(stream, meta) {
-	stream.respond({
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_CONFLICT,
-		// [HTTP2_HEADER_CONTENT_TYPE]: CONTENT_TYPE_JSON,
-		[HTTP2_HEADER_SERVER]: meta.servername,
-		[HTTP_HEADER_TIMING_ALLOW_ORIGIN]: meta.origin,
-		[HTTP_HEADER_SERVER_TIMING]: ServerTiming.encode(meta.performance)
-	})
-
-	// stream.write(JSON.stringify( ... ))
-
-	stream.end()
-}
+	send(stream, HTTP_STATUS_CONFLICT, {}, undefined, undefined, meta)
+}

package/src/response/created.js

@@ -1,42 +1,27 @@
 import http2 from 'node:http2'
-import { CONTENT_TYPE_JSON } from '../content-type.js'
-import {
-	HTTP_HEADER_TIMING_ALLOW_ORIGIN,
-	HTTP_HEADER_SERVER_TIMING,
-	ServerTiming
-} from '../server-timing.js'
+import { send } from './send-util.js'
+import { Conditional } from '../conditional.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
+/** @import { EtagItem } from '../conditional.js' */
 
 const {
-	HTTP_STATUS_CREATED
+	HTTP2_HEADER_LOCATION,
+	HTTP2_HEADER_ETAG
 } = http2.constants
 
-const {
-	HTTP2_HEADER_STATUS,
-	HTTP2_HEADER_SERVER,
-	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
-	HTTP2_HEADER_LOCATION
-} = http2.constants
+const { HTTP_STATUS_CREATED } = http2.constants
 
 /**
  * @param {ServerHttp2Stream} stream
  * @param {URL} location
+ * @param {EtagItem|undefined} etag
  * @param {Metadata} meta
  */
-export function sendCreated(stream, location, meta) {
-	stream.respond({
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_CREATED,
-		// [HTTP2_HEADER_CONTENT_TYPE]: CONTENT_TYPE_JSON,
-		[HTTP2_HEADER_SERVER]: meta.servername,
-		[HTTP2_HEADER_LOCATION]: location.href,
-		[HTTP_HEADER_TIMING_ALLOW_ORIGIN]: meta.origin,
-		[HTTP_HEADER_SERVER_TIMING]: ServerTiming.encode(meta.performance),
-	})
-
-	// stream.write(JSON.stringify( ... ))
-
-	stream.end()
+export function sendCreated(stream, location, etag, meta) {
+	send(stream, HTTP_STATUS_CREATED, {
+			[HTTP2_HEADER_LOCATION]: location.href,
+			[HTTP2_HEADER_ETAG]: Conditional.encodeEtag(etag)
+		}, undefined, undefined, meta)
 }

package/src/response/defs.js

@@ -23,7 +23,6 @@ export const PREFLIGHT_AGE_SECONDS = '500'
  * @property {Array<TimingsInfo>} performance
  * @property {string|undefined} servername
  * @property {string|undefined} origin
- * @property {string|undefined} [etag]
  */
 
 /**

package/src/response/error.js

@@ -1,47 +1,17 @@
 import http2 from 'node:http2'
-import {
-	CONTENT_TYPE_TEXT
-} from '../content-type.js'
-
-const {
-	HTTP2_HEADER_STATUS,
-	HTTP2_HEADER_CONTENT_TYPE,
-	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
-	HTTP2_HEADER_SERVER
-} = http2.constants
-
-const {
-	HTTP_STATUS_INTERNAL_SERVER_ERROR
-} = http2.constants
+import { CONTENT_TYPE_TEXT } from '../content-type.js'
+import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
 
+const { HTTP_STATUS_INTERNAL_SERVER_ERROR } = http2.constants
+
 /**
  * @param {ServerHttp2Stream} stream
  * @param {string} message
  * @param {Metadata} meta
  */
 export function sendError(stream, message, meta) {
-	console.error('500', message)
-
-	if(stream === undefined) { return }
-	if(stream.closed) { return }
-
-	if(!stream.headersSent) {
-		stream.respond({
-			[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-			[HTTP2_HEADER_STATUS]: HTTP_STATUS_INTERNAL_SERVER_ERROR,
-			[HTTP2_HEADER_CONTENT_TYPE]: CONTENT_TYPE_TEXT,
-			[HTTP2_HEADER_SERVER]: meta.servername
-		})
-	}
-
-	// protect against HEAD calls
-	if(stream.writable) {
-		if(message !== undefined) { stream.write(message) }
-	}
-
-	stream.end()
-	if(!stream.closed) { stream.close() }
-}
+	send(stream, HTTP_STATUS_INTERNAL_SERVER_ERROR, {}, CONTENT_TYPE_TEXT, message, meta)
+}

package/src/response/header-util.js

@@ -0,0 +1,42 @@
+import http2 from 'node:http2'
+import {
+	HTTP_HEADER_TIMING_ALLOW_ORIGIN,
+	HTTP_HEADER_SERVER_TIMING,
+	ServerTiming
+} from '../server-timing.js'
+
+/** @import { OutgoingHttpHeaders } from 'node:http2' */
+/** @import { Metadata } from './defs.js' */
+
+const {
+	HTTP2_HEADER_STATUS,
+	HTTP2_HEADER_SERVER,
+	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
+	HTTP2_HEADER_CONTENT_TYPE
+} = http2.constants
+
+/**
+ * @param {number} status
+ * @param {string|undefined} contentType
+ * @param {Metadata} meta
+ * @returns {OutgoingHttpHeaders}
+ */
+export function coreHeaders(status, contentType, meta) {
+	return {
+		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
+		[HTTP2_HEADER_STATUS]: status,
+		[HTTP2_HEADER_CONTENT_TYPE]: contentType,
+		[HTTP2_HEADER_SERVER]: meta.servername
+	}
+}
+
+/**
+ * @param {Metadata} meta
+ * @returns {OutgoingHttpHeaders}
+ */
+export function performanceHeaders(meta) {
+	return {
+		[HTTP_HEADER_TIMING_ALLOW_ORIGIN]: meta.origin,
+		[HTTP_HEADER_SERVER_TIMING]: ServerTiming.encode(meta.performance)
+	}
+}

package/src/response/index.js

@@ -10,11 +10,12 @@ export * from './not-acceptable.js'
 export * from './not-allowed.js'
 export * from './not-found.js'
 export * from './not-modified.js'
+export * from './precondition-failed.js'
 export * from './preflight.js'
 export * from './sse.js'
 export * from './timeout.js'
 export * from './too-many-requests.js'
 export * from './trace.js'
 export * from './unauthorized.js'
-export * from './unsupported-media.js'
 export * from './unprocessable.js'
+export * from './unsupported-media.js'

package/src/response/json.js

@@ -1,30 +1,31 @@
 import http2 from 'node:http2'
-import { brotliCompressSync, deflateSync, gzipSync, zstdCompressSync } from 'node:zlib'
-import { ServerTiming, HTTP_HEADER_SERVER_TIMING, HTTP_HEADER_TIMING_ALLOW_ORIGIN } from '../server-timing.js'
+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 { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
+/** @import { EtagItem } from '../conditional.js' */
 
 /** @typedef { (data: string, charset: BufferEncoding) => Buffer } EncoderFun */
 
 const {
-  HTTP2_HEADER_STATUS,
-  HTTP2_HEADER_CONTENT_TYPE,
-  HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
-  HTTP2_HEADER_SERVER,
   HTTP2_HEADER_CONTENT_ENCODING,
   HTTP2_HEADER_VARY,
   HTTP2_HEADER_CACHE_CONTROL,
   HTTP2_HEADER_ETAG
 } = http2.constants
 
-const {
-  HTTP_STATUS_OK
-} = http2.constants
+const { HTTP_STATUS_OK } = http2.constants
 
 /** @type {Map<string, EncoderFun>} */
 export const ENCODER_MAP = new Map([
@@ -38,9 +39,10 @@ export const ENCODER_MAP = new Map([
  * @param {ServerHttp2Stream} stream
  * @param {Object} obj
  * @param {string|undefined} encoding
+ * @param {EtagItem|undefined} etag
  * @param {Metadata} meta
  */
-export function sendJSON_Encoded(stream, obj, encoding, meta) {
+export function sendJSON_Encoded(stream, obj, encoding, etag, meta) {
 	if(stream.closed) { return }
 
 	const json = JSON.stringify(obj)
@@ -58,21 +60,11 @@ export function sendJSON_Encoded(stream, obj, encoding, meta) {
 		{ name: 'encode', duration: encodeEnd - encodeStart }
 	)
 
-	stream.respond({
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_CONTENT_TYPE]: CONTENT_TYPE_JSON,
-		[HTTP2_HEADER_CONTENT_ENCODING]: actualEncoding,
-		[HTTP2_HEADER_VARY]: 'Accept, Accept-Encoding',
-		[HTTP2_HEADER_CACHE_CONTROL]: 'private',
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_OK,
-		[HTTP2_HEADER_SERVER]: meta.servername,
-		[HTTP_HEADER_TIMING_ALLOW_ORIGIN]: meta.origin,
-		[HTTP_HEADER_SERVER_TIMING]: ServerTiming.encode(meta.performance),
-		[HTTP2_HEADER_ETAG]: `"${meta.etag}"`
-		// [HTTP2_HEADER_AGE]: age
-	})
-
-	// stream.write(encodedData)
-	stream.end(encodedData)
+	send(stream, HTTP_STATUS_OK, {
+			[HTTP2_HEADER_CONTENT_ENCODING]: actualEncoding,
+			[HTTP2_HEADER_VARY]: 'Accept, Accept-Encoding',
+			[HTTP2_HEADER_CACHE_CONTROL]: 'private',
+			[HTTP2_HEADER_ETAG]: Conditional.encodeEtag(etag)
+			// [HTTP2_HEADER_AGE]: age
+		}, CONTENT_TYPE_JSON, encodedData, meta)
 }
-

package/src/response/no-content.js

@@ -1,36 +1,24 @@
 import http2 from 'node:http2'
-import {
-	HTTP_HEADER_TIMING_ALLOW_ORIGIN,
-	HTTP_HEADER_SERVER_TIMING,
-	ServerTiming
-} from '../server-timing.js'
+import { send } from './send-util.js'
+import { Conditional } from '../conditional.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
+/** @import { EtagItem } from '../conditional.js' */
 
 const {
-	HTTP_STATUS_NO_CONTENT
-} = http2.constants
-
-const {
-	HTTP2_HEADER_STATUS,
-	HTTP2_HEADER_SERVER,
-	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
 	HTTP2_HEADER_ETAG
 } = http2.constants
 
+const { HTTP_STATUS_NO_CONTENT } = http2.constants
+
 /**
  * @param {ServerHttp2Stream} stream
+ * @param {EtagItem|undefined} etag
  * @param {Metadata} meta
  */
-export function sendNoContent(stream, meta) {
-	stream.respond({
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_NO_CONTENT,
-		[HTTP2_HEADER_SERVER]: meta.servername,
-		[HTTP_HEADER_TIMING_ALLOW_ORIGIN]: meta.origin,
-		[HTTP_HEADER_SERVER_TIMING]: ServerTiming.encode(meta.performance),
-		[HTTP2_HEADER_ETAG]: `"${meta.etag}"`
-	})
-	stream.end()
-}
+export function sendNoContent(stream, etag, meta) {
+	send(stream, HTTP_STATUS_NO_CONTENT, {
+			[HTTP2_HEADER_ETAG]: Conditional.encodeEtag(etag)
+		}, undefined, undefined, meta)
+}

package/src/response/not-acceptable.js

@@ -1,24 +1,11 @@
 import http2 from 'node:http2'
-import { MIME_TYPE_JSON } from '../content-type.js'
-import {
-	HTTP_HEADER_SERVER_TIMING,
-	HTTP_HEADER_TIMING_ALLOW_ORIGIN,
-	ServerTiming
-} from '../server-timing.js'
+import { CONTENT_TYPE_JSON } from '../content-type.js'
+import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
 
-const {
-	HTTP_STATUS_NOT_ACCEPTABLE
-} = http2.constants
-
-const {
-	HTTP2_HEADER_STATUS,
-	HTTP2_HEADER_SERVER,
-	HTTP2_HEADER_CONTENT_TYPE,
-	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN
-} = http2.constants
+const { HTTP_STATUS_NOT_ACCEPTABLE } = http2.constants
 
 /**
  * @param {ServerHttp2Stream} stream
@@ -29,18 +16,10 @@ export function sendNotAcceptable(stream, supportedTypes, meta) {
 	const supportedTypesList = Array.isArray(supportedTypes) ? supportedTypes : [ supportedTypes ]
 	const has = supportedTypesList.length !== 0
 
-	stream.respond({
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_NOT_ACCEPTABLE,
-		[HTTP2_HEADER_SERVER]: meta.servername,
-		[HTTP2_HEADER_CONTENT_TYPE]: has ? MIME_TYPE_JSON : undefined,
-		[HTTP_HEADER_TIMING_ALLOW_ORIGIN]: meta.origin,
-		[HTTP_HEADER_SERVER_TIMING]: ServerTiming.encode(meta.performance),
-	})
-
-	if(has) {
-		stream.write(JSON.stringify(supportedTypes))
-	}
-
-	stream.end()
+	send(stream,
+		HTTP_STATUS_NOT_ACCEPTABLE,
+		{},
+		has ? CONTENT_TYPE_JSON : undefined,
+		has ? JSON.stringify(supportedTypes) : undefined,
+		meta)
 }

package/src/response/not-allowed.js

@@ -1,30 +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_STATUS,
-	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
-	HTTP2_HEADER_SERVER,
-	HTTP2_HEADER_ALLOW
-} = http2.constants
-
 const {
 	HTTP_STATUS_METHOD_NOT_ALLOWED
 } = http2.constants
 
+const { HTTP2_HEADER_ALLOW } = http2.constants
+
 /**
  * @param {ServerHttp2Stream} stream
  * @param {Array<string>} methods
  * @param {Metadata} meta
  */
 export function sendNotAllowed(stream, methods, meta) {
-	stream.respond({
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_METHOD_NOT_ALLOWED,
-		[HTTP2_HEADER_ALLOW]: methods.join(','),
-		[HTTP2_HEADER_SERVER]: meta.servername
-	})
-	stream.end()
-}
+	send(stream, HTTP_STATUS_METHOD_NOT_ALLOWED, {
+			[HTTP2_HEADER_ALLOW]: methods.join(',')
+		}, undefined, undefined, meta)
+}

package/src/response/not-found.js

@@ -1,21 +1,11 @@
 import http2 from 'node:http2'
-import {
-	CONTENT_TYPE_TEXT
-} from '../content-type.js'
+import { CONTENT_TYPE_TEXT } from '../content-type.js'
+import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
 
-const {
-	HTTP2_HEADER_STATUS,
-	HTTP2_HEADER_CONTENT_TYPE,
-	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
-	HTTP2_HEADER_SERVER
-} = http2.constants
-
-const {
-	HTTP_STATUS_NOT_FOUND
-} = http2.constants
+const { HTTP_STATUS_NOT_FOUND } = http2.constants
 
 /**
  * @param {ServerHttp2Stream} stream
@@ -23,15 +13,5 @@ const {
  * @param {Metadata} meta
  */
 export function sendNotFound(stream, message, meta) {
-	console.log('404', message)
-
-	stream.respond({
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_NOT_FOUND,
-		[HTTP2_HEADER_CONTENT_TYPE]: CONTENT_TYPE_TEXT,
-		[HTTP2_HEADER_SERVER]: meta.servername
-	})
-
-	if(message !== undefined) { stream.write(message) }
-	stream.end()
+	send(stream, HTTP_STATUS_NOT_FOUND, {}, CONTENT_TYPE_TEXT, message, meta)
 }

package/src/response/not-modified.js

@@ -1,43 +1,31 @@
 import http2 from 'node:http2'
-import {
-	HTTP_HEADER_TIMING_ALLOW_ORIGIN,
-	HTTP_HEADER_SERVER_TIMING,
-	ServerTiming
-} from '../server-timing.js'
+import { send } from './send-util.js'
+import { Conditional } from '../conditional.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
+/** @import { EtagItem } from '../conditional.js' */
 
 const {
-	HTTP_STATUS_NOT_MODIFIED
-} = http2.constants
-
-const {
-	HTTP2_HEADER_STATUS,
-	HTTP2_HEADER_SERVER,
-	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
 	HTTP2_HEADER_AGE,
 	HTTP2_HEADER_ETAG,
 	HTTP2_HEADER_VARY,
 	HTTP2_HEADER_CACHE_CONTROL
 } = http2.constants
 
+const { HTTP_STATUS_NOT_MODIFIED } = http2.constants
+
 /**
  * @param {ServerHttp2Stream} stream
- * @param {number} age
+ * @param {EtagItem|undefined} etag
+ * @param {number|undefined} age
  * @param {Metadata} meta
  */
-export function sendNotModified(stream, age, meta) {
-	stream.respond({
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_NOT_MODIFIED,
-		[HTTP2_HEADER_VARY]: 'Accept, Accept-Encoding',
-		[HTTP2_HEADER_CACHE_CONTROL]: 'private',
-		[HTTP2_HEADER_SERVER]: meta.servername,
-		[HTTP_HEADER_TIMING_ALLOW_ORIGIN]: meta.origin,
-		[HTTP_HEADER_SERVER_TIMING]: ServerTiming.encode(meta.performance),
-		[HTTP2_HEADER_ETAG]: `"${meta.etag}"`,
-		[HTTP2_HEADER_AGE]: age
-	})
-	stream.end()
+export function sendNotModified(stream, etag, age, meta) {
+	send(stream, HTTP_STATUS_NOT_MODIFIED, {
+			[HTTP2_HEADER_VARY]: 'Accept, Accept-Encoding',
+			[HTTP2_HEADER_CACHE_CONTROL]: 'private',
+			[HTTP2_HEADER_ETAG]: Conditional.encodeEtag(etag),
+			[HTTP2_HEADER_AGE]: age !== undefined ? `${age}` : undefined
+		}, undefined, undefined, meta)
 }

package/src/response/precondition-failed.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_PRECONDITION_FAILED } = http2.constants
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {Metadata} meta
+ */
+export function sendPreconditionFailed(stream, meta) {
+	send(stream, HTTP_STATUS_PRECONDITION_FAILED, {}, undefined, undefined, meta)
+}

package/src/response/preflight.js

@@ -3,22 +3,18 @@ import {
 	HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE,
 	PREFLIGHT_AGE_SECONDS
 } from './defs.js'
+import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
 
 const {
-	HTTP2_HEADER_STATUS,
 	HTTP2_HEADER_CONTENT_TYPE,
-	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
 	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS,
-	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS,
-	HTTP2_HEADER_SERVER
+	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS
 } = http2.constants
 
-const {
-	HTTP_STATUS_OK
-} = http2.constants
+const { HTTP_STATUS_OK } = http2.constants
 
 /**
  * @param {ServerHttp2Stream} stream
@@ -26,13 +22,9 @@ const {
  * @param {Metadata} meta
  */
 export function sendPreflight(stream, methods, meta) {
-	stream.respond({
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_OK,
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS]: methods.join(','),
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS]: ['Authorization', HTTP2_HEADER_CONTENT_TYPE].join(','),
-		[HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE]: PREFLIGHT_AGE_SECONDS,
-		[HTTP2_HEADER_SERVER]: meta.servername
-	})
-	stream.end()
-}
+	send(stream, HTTP_STATUS_OK, {
+			[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS]: methods.join(','),
+			[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS]: ['Authorization', HTTP2_HEADER_CONTENT_TYPE].join(','),
+			[HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE]: PREFLIGHT_AGE_SECONDS
+		}, undefined, undefined, meta)
+}

package/src/response/response.js

@@ -8,32 +8,34 @@ import { sendNotAcceptable } from './not-acceptable.js'
 import { sendNotAllowed } from './not-allowed.js'
 import { sendNotFound } from './not-found.js'
 import { sendNotModified } from './not-modified.js'
+import { sendPreconditionFailed } from './precondition-failed.js'
 import { sendPreflight } from './preflight.js'
 import { sendSSE } from './sse.js'
 import { sendTimeout } from './timeout.js'
 import { sendTooManyRequests } from './too-many-requests.js'
 import { sendTrace } from './trace.js'
 import { sendUnauthorized } from './unauthorized.js'
-import { sendUnsupportedMediaType } from './unsupported-media.js'
 import { sendUnprocessable } from './unprocessable.js'
+import { sendUnsupportedMediaType } from './unsupported-media.js'
 
 export const Response = {
 	accepted: sendAccepted,
 	conflict: sendConflict,
 	created: sendCreated,
 	error: sendError,
-	noContent: sendNoContent,
 	json: sendJSON_Encoded,
+	noContent: sendNoContent,
 	notAcceptable: sendNotAcceptable,
 	notAllowed: sendNotAllowed,
 	notFound: sendNotFound,
 	notModified: sendNotModified,
+	preconditionFailed: sendPreconditionFailed,
 	preflight: sendPreflight,
 	sse: sendSSE,
 	timeout: sendTimeout,
 	tooManyRequests: sendTooManyRequests,
 	trace: sendTrace,
 	unauthorized: sendUnauthorized,
-	unsupportedMediaType: sendUnsupportedMediaType,
-	unprocessable: sendUnprocessable
+	unprocessable: sendUnprocessable,
+	unsupportedMediaType: sendUnsupportedMediaType
 }

package/src/response/send-util.js

@@ -0,0 +1,39 @@
+import { coreHeaders, performanceHeaders } from './header-util.js'
+
+/** @import { ServerHttp2Stream } from 'node:http2' */
+/** @import { IncomingHttpHeaders } from 'node:http2' */
+/** @import { Metadata } from './defs.js' */
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {number} status
+ * @param {IncomingHttpHeaders} headers
+ * @param {string|undefined} contentType
+ * @param {ArrayBufferLike|ArrayBufferView|string|undefined} body
+ * @param {Metadata} meta
+ */
+export function send(stream, status, headers, contentType, body, meta) {
+	// if(status >= 400) { console.warn(status, body) }
+	if(status === 401) { console.warn(status, body) }
+	if(status === 404) { console.warn(status, body) }
+	if(status === 500) { console.warn(status, body) }
+
+	if(stream === undefined) { return }
+	if(stream.closed) { return }
+
+	if(!stream.headersSent) {
+		stream.respond({
+			...coreHeaders(status, contentType, meta),
+			...performanceHeaders(meta),
+			...headers
+		})
+	}
+
+	if(stream.writable && body !== undefined) {
+		stream.end(body)
+		return
+	}
+
+	stream.end()
+	// if(!stream.closed) { stream.close() }
+}

package/src/response/sse.js

@@ -5,51 +5,34 @@ import {
 	SSE_BOM,
 	ENDING,
 } from '@johntalton/sse-util'
+import { coreHeaders, performanceHeaders } from './header-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata, SSEOptions } from './defs.js' */
 
-const {
-	HTTP2_HEADER_STATUS,
-	HTTP2_HEADER_CONTENT_TYPE,
-	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
-	HTTP2_HEADER_SERVER
-} = http2.constants
-
-const {
-	HTTP_STATUS_OK,
-	HTTP_STATUS_NO_CONTENT
-} = http2.constants
+const { HTTP_STATUS_OK } = http2.constants
 
 /**
  * @param {ServerHttp2Stream} stream
  * @param {SSEOptions & Metadata} meta
  */
 export function sendSSE(stream, meta) {
-	// stream.setTimeout(0)
-	// stream.session?.setTimeout(0)
-	// stream.session?.socket.setTimeout(0)
-	// stream.session.socket.setNoDelay(true)
-	// stream.session.socket.setKeepAlive(true)
-
-	// stream.on('close', () => console.log('SSE stream closed'))
-	// stream.on('aborted', () => console.log('SSE stream aborted'))
-
 	const activeStream = meta.active ?? true
 	const sendBOM = meta.bom ?? true
 
+	const status = activeStream ? HTTP_STATUS_OK : SSE_INACTIVE_STATUS_CODE
+
 	stream.respond({
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_CONTENT_TYPE]: SSE_MIME,
-		[HTTP2_HEADER_STATUS]: activeStream ? HTTP_STATUS_OK : HTTP_STATUS_NO_CONTENT, // SSE_INACTIVE_STATUS_CODE
+		...coreHeaders(status, SSE_MIME, meta),
+		...performanceHeaders(meta)
+
 		// [HTTP2_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS]: 'true'
-		[HTTP2_HEADER_SERVER]: meta.servername
-	 })
+	})
 
-	 if(!activeStream) {
+	if(!activeStream) {
 		stream.end()
 		return
-	 }
+	}
 
 	if(sendBOM) {
 		stream.write(SSE_BOM + ENDING.CRLF)

package/src/response/timeout.js

@@ -1,10 +1,5 @@
 import http2 from 'node:http2'
-import { CONTENT_TYPE_JSON } from '../content-type.js'
-import {
-	HTTP_HEADER_TIMING_ALLOW_ORIGIN,
-	HTTP_HEADER_SERVER_TIMING,
-	ServerTiming
-} from '../server-timing.js'
+import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
@@ -13,29 +8,14 @@ const {
 	HTTP_STATUS_REQUEST_TIMEOUT
 } = http2.constants
 
-const {
-	HTTP2_HEADER_STATUS,
-	HTTP2_HEADER_SERVER,
-	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
-	HTTP2_HEADER_CONNECTION
-} = http2.constants
+const { HTTP2_HEADER_CONNECTION } = http2.constants
 
 /**
  * @param {ServerHttp2Stream} stream
  * @param {Metadata} meta
  */
 export function sendTimeout(stream, meta) {
-	stream.respond({
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_REQUEST_TIMEOUT,
-		// [HTTP2_HEADER_CONTENT_TYPE]: CONTENT_TYPE_JSON,
-		[HTTP2_HEADER_SERVER]: meta.servername,
-		[HTTP_HEADER_TIMING_ALLOW_ORIGIN]: meta.origin,
-		[HTTP_HEADER_SERVER_TIMING]: ServerTiming.encode(meta.performance),
-		[HTTP2_HEADER_CONNECTION]: 'close'
-	})
-
-	// stream.write(JSON.stringify( ... ))
-
-	stream.end()
-}
+	send(stream, HTTP_STATUS_REQUEST_TIMEOUT, {
+			[HTTP2_HEADER_CONNECTION]: 'close'
+		}, undefined, undefined, meta)
+}

package/src/response/too-many-requests.js

@@ -6,42 +6,31 @@ import {
 	RateLimit,
 	RateLimitPolicy
 } from '../rate-limit.js'
-
+import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
+/** @import { RateLimitInfo, RateLimitPolicyInfo } from '../rate-limit.js' */
 
 const {
-	HTTP2_HEADER_STATUS,
-	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
-	HTTP2_HEADER_SERVER,
-	HTTP2_HEADER_RETRY_AFTER,
-	HTTP2_HEADER_CONTENT_TYPE
+	HTTP2_HEADER_RETRY_AFTER
 } = http2.constants
 
-const {
-	HTTP_STATUS_TOO_MANY_REQUESTS
-} = http2.constants
+const { HTTP_STATUS_TOO_MANY_REQUESTS } = http2.constants
 
 /**
  * @param {ServerHttp2Stream} stream
- * @param {*} limitInfo
- * @param {Array<any>} policies
+ * @param {RateLimitInfo} limitInfo
+ * @param {Array<RateLimitPolicyInfo>} policies
  * @param {Metadata} meta
  */
 export function sendTooManyRequests(stream, limitInfo, policies, meta) {
-	stream.respond({
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_TOO_MANY_REQUESTS,
-		[HTTP2_HEADER_CONTENT_TYPE]: CONTENT_TYPE_TEXT,
-		[HTTP2_HEADER_SERVER]: meta.servername,
-		[HTTP2_HEADER_RETRY_AFTER]: limitInfo.retryAfterS,
-		[HTTP_HEADER_RATE_LIMIT]: RateLimit.from(limitInfo),
-		[HTTP_HEADER_RATE_LIMIT_POLICY]: RateLimitPolicy.from(...policies)
-	})
-
-	stream.write(`Retry After ${limitInfo.retryAfterS} Seconds`)
-
-	stream.end()
+	send(stream, HTTP_STATUS_TOO_MANY_REQUESTS, {
+			[HTTP2_HEADER_RETRY_AFTER]: `${limitInfo.resetSeconds}`,
+			[HTTP_HEADER_RATE_LIMIT]: RateLimit.from(limitInfo),
+			[HTTP_HEADER_RATE_LIMIT_POLICY]: RateLimitPolicy.from(...policies)
+		},
+		CONTENT_TYPE_TEXT,
+		`Retry After ${limitInfo.resetSeconds} Seconds`,
+		meta)
 }
-

package/src/response/trace.js

@@ -1,26 +1,12 @@
 import http2 from 'node:http2'
-import {
-	MIME_TYPE_MESSAGE_HTTP
-} from '../content-type.js'
-import {
-	HTTP_HEADER_SERVER_TIMING,
-	HTTP_HEADER_TIMING_ALLOW_ORIGIN,
-	ServerTiming
-} from '../server-timing.js'
+import { CONTENT_TYPE_MESSAGE_HTTP } from '../content-type.js'
+import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { IncomingHttpHeaders } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
 
-const {
-	HTTP2_HEADER_STATUS,
-	HTTP2_HEADER_CONTENT_TYPE,
-	HTTP2_HEADER_SERVER
-} = http2.constants
-
-const {
-	HTTP_STATUS_OK
-} = http2.constants
+const { HTTP_STATUS_OK } = http2.constants
 
 /**
  * @param {ServerHttp2Stream} stream
@@ -38,15 +24,6 @@ export function sendTrace(stream, method, url, headers, meta) {
 	])
 
 	const version = HTTP_VERSION.get(stream.session?.alpnProtocol ?? 'h2')
-
-	stream.respond({
-		[HTTP2_HEADER_CONTENT_TYPE]: MIME_TYPE_MESSAGE_HTTP,
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_OK,
-		[HTTP2_HEADER_SERVER]: meta.servername,
-		[HTTP_HEADER_TIMING_ALLOW_ORIGIN]: meta.origin,
-		[HTTP_HEADER_SERVER_TIMING]: ServerTiming.encode(meta.performance),
-	})
-
 	const reconstructed = [
 		`${method} ${url.pathname}${url.search} ${version}`,
 		Object.entries(headers)
@@ -58,6 +35,5 @@ export function sendTrace(stream, method, url, headers, meta) {
 		]
 		.join('\n')
 
-	stream.end(reconstructed)
+	send(stream, HTTP_STATUS_OK, {}, CONTENT_TYPE_MESSAGE_HTTP, reconstructed, meta)
 }
-

package/src/response/unauthorized.js

@@ -1,30 +1,17 @@
 import http2 from 'node:http2'
+import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
 
-const {
-	HTTP2_HEADER_STATUS,
-	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
-	HTTP2_HEADER_SERVER
-} = http2.constants
-
-const {
-	HTTP_STATUS_UNAUTHORIZED
-} = http2.constants
+const { HTTP_STATUS_UNAUTHORIZED } = http2.constants
 
 /**
  * @param {ServerHttp2Stream} stream
  * @param {Metadata} meta
  */
 export function sendUnauthorized(stream, meta) {
-	console.log('Unauthorized')
-
-	stream.respond({
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_UNAUTHORIZED,
-		[HTTP2_HEADER_SERVER]: meta.servername
-		//  WWW-Authenticate
-	})
-	stream.end()
+	send(stream, HTTP_STATUS_UNAUTHORIZED, {
+			//  WWW-Authenticate
+		}, undefined, undefined, meta)
 }

package/src/response/unprocessable.js

@@ -1,39 +1,15 @@
 import http2 from 'node:http2'
-import { CONTENT_TYPE_JSON } from '../content-type.js'
-import {
-	HTTP_HEADER_TIMING_ALLOW_ORIGIN,
-	HTTP_HEADER_SERVER_TIMING,
-	ServerTiming
-} from '../server-timing.js'
+import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
 
-const {
-  HTTP_STATUS_UNPROCESSABLE_ENTITY
-} = http2.constants
-
-const {
-  HTTP2_HEADER_STATUS,
-  HTTP2_HEADER_SERVER,
-  HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN
-} = http2.constants
+const { HTTP_STATUS_UNPROCESSABLE_ENTITY } = http2.constants
 
 /**
  * @param {ServerHttp2Stream} stream
  * @param {Metadata} meta
  */
 export function sendUnprocessable(stream, meta) {
-	stream.respond({
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_UNPROCESSABLE_ENTITY,
-		// [HTTP2_HEADER_CONTENT_TYPE]: CONTENT_TYPE_JSON,
-		[HTTP2_HEADER_SERVER]: meta.servername,
-		[HTTP_HEADER_TIMING_ALLOW_ORIGIN]: meta.origin,
-		[HTTP_HEADER_SERVER_TIMING]: ServerTiming.encode(meta.performance)
-	})
-
-	// stream.write(JSON.stringify( ... ))
-
-	stream.end()
-}
+	send(stream, HTTP_STATUS_UNPROCESSABLE_ENTITY, {}, undefined, undefined, meta)
+}

package/src/response/unsupported-media.js

@@ -1,23 +1,11 @@
 import http2 from 'node:http2'
 import { HTTP_HEADER_ACCEPT_POST } from './defs.js'
-import {
-	HTTP_HEADER_TIMING_ALLOW_ORIGIN,
-	HTTP_HEADER_SERVER_TIMING,
-	ServerTiming
-} from '../server-timing.js'
+import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */
 /** @import { Metadata } from './defs.js' */
 
-const {
-	HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE
-} = http2.constants
-
-const {
-	HTTP2_HEADER_STATUS,
-	HTTP2_HEADER_SERVER,
-	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN
-} = http2.constants
+const { HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE } = http2.constants
 
 /**
  * @param {ServerHttp2Stream} stream
@@ -27,14 +15,7 @@ const {
 export function sendUnsupportedMediaType(stream, acceptableMediaType, meta) {
 	const acceptable = Array.isArray(acceptableMediaType) ? acceptableMediaType : [ acceptableMediaType ]
 
-	stream.respond({
-		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
-		[HTTP2_HEADER_STATUS]: HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE,
-		[HTTP_HEADER_ACCEPT_POST]: acceptable.join(','),
-		[HTTP2_HEADER_SERVER]: meta.servername,
-		[HTTP_HEADER_TIMING_ALLOW_ORIGIN]: meta.origin,
-		[HTTP_HEADER_SERVER_TIMING]: ServerTiming.encode(meta.performance),
-	})
-
-	stream.end()
-}
+	send(stream, HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE, {
+			[HTTP_HEADER_ACCEPT_POST]: acceptable.join(',')
+		}, undefined, undefined, meta)
+}