jishushell 0.6.5 → 0.7.3

package/node_modules/fastify/lib/schemas.js

@@ -10,6 +10,7 @@ const {
   FST_ERR_SCH_DUPLICATE,
   FST_ERR_SCH_CONTENT_MISSING_SCHEMA
 } = require('./errors')
+const ContentType = require('./content-type')
 
 const SCHEMAS_SOURCE = ['params', 'body', 'querystring', 'query', 'headers']
 
@@ -147,52 +148,58 @@ function getSchemaSerializer (context, statusCode, contentType) {
     return false
   }
   if (responseSchemaDef[statusCode]) {
-    if (responseSchemaDef[statusCode].constructor === Object && contentType) {
-      const mediaName = contentType.split(';', 1)[0]
-      if (responseSchemaDef[statusCode][mediaName]) {
-        return responseSchemaDef[statusCode][mediaName]
-      }
+    if (responseSchemaDef[statusCode].constructor === Object) {
+      const ct = new ContentType(contentType)
+      if (ct.isValid) {
+        if (responseSchemaDef[statusCode][ct.mediaType]) {
+          return responseSchemaDef[statusCode][ct.mediaType]
+        }
 
-      // fallback to match all media-type
-      if (responseSchemaDef[statusCode]['*/*']) {
-        return responseSchemaDef[statusCode]['*/*']
-      }
+        // fallback to match all media-type
+        if (responseSchemaDef[statusCode]['*/*']) {
+          return responseSchemaDef[statusCode]['*/*']
+        }
 
-      return false
+        return false
+      }
     }
     return responseSchemaDef[statusCode]
   }
   const fallbackStatusCode = (statusCode + '')[0] + 'xx'
   if (responseSchemaDef[fallbackStatusCode]) {
-    if (responseSchemaDef[fallbackStatusCode].constructor === Object && contentType) {
-      const mediaName = contentType.split(';', 1)[0]
-      if (responseSchemaDef[fallbackStatusCode][mediaName]) {
-        return responseSchemaDef[fallbackStatusCode][mediaName]
-      }
+    if (responseSchemaDef[fallbackStatusCode].constructor === Object) {
+      const ct = new ContentType(contentType)
+      if (ct.isValid) {
+        if (responseSchemaDef[fallbackStatusCode][ct.mediaType]) {
+          return responseSchemaDef[fallbackStatusCode][ct.mediaType]
+        }
 
-      // fallback to match all media-type
-      if (responseSchemaDef[fallbackStatusCode]['*/*']) {
-        return responseSchemaDef[fallbackStatusCode]['*/*']
-      }
+        // fallback to match all media-type
+        if (responseSchemaDef[fallbackStatusCode]['*/*']) {
+          return responseSchemaDef[fallbackStatusCode]['*/*']
+        }
 
-      return false
+        return false
+      }
     }
 
     return responseSchemaDef[fallbackStatusCode]
   }
   if (responseSchemaDef.default) {
-    if (responseSchemaDef.default.constructor === Object && contentType) {
-      const mediaName = contentType.split(';', 1)[0]
-      if (responseSchemaDef.default[mediaName]) {
-        return responseSchemaDef.default[mediaName]
-      }
+    if (responseSchemaDef.default.constructor === Object) {
+      const ct = new ContentType(contentType)
+      if (ct.isValid) {
+        if (responseSchemaDef.default[ct.mediaType]) {
+          return responseSchemaDef.default[ct.mediaType]
+        }
 
-      // fallback to match all media-type
-      if (responseSchemaDef.default['*/*']) {
-        return responseSchemaDef.default['*/*']
-      }
+        // fallback to match all media-type
+        if (responseSchemaDef.default['*/*']) {
+          return responseSchemaDef.default['*/*']
+        }
 
-      return false
+        return false
+      }
     }
 
     return responseSchemaDef.default

package/node_modules/fastify/lib/symbols.js

@@ -32,6 +32,7 @@ const keys = {
   kRequestPayloadStream: Symbol('fastify.RequestPayloadStream'),
   kRequestAcceptVersion: Symbol('fastify.RequestAcceptVersion'),
   kRequestCacheValidateFns: Symbol('fastify.request.cache.validateFns'),
+  kRequestContentType: Symbol('fastify.request.contentType'),
   kRequestOriginalUrl: Symbol('fastify.request.originalUrl'),
   kRequestSignal: Symbol('fastify.request.signal'),
   kHandlerTimeout: Symbol('fastify.handlerTimeout'),
@@ -65,7 +66,8 @@ const keys = {
   kChildLoggerFactory: Symbol('fastify.childLoggerFactory'),
   kHasBeenDecorated: Symbol('fastify.hasBeenDecorated'),
   kKeepAliveConnections: Symbol('fastify.keepAliveConnections'),
-  kRouteByFastify: Symbol('fastify.routeByFastify')
+  kRouteByFastify: Symbol('fastify.routeByFastify'),
+  kDiagnosticsStore: Symbol('fastify.diagnosticsStore')
 }
 
 module.exports = keys

package/node_modules/fastify/lib/validation.js

@@ -162,9 +162,7 @@ function validate (context, request, execution) {
     if (typeof context[bodySchema] === 'function') {
       validatorFunction = context[bodySchema]
     } else if (context[bodySchema]) {
-      // TODO: add request.contentType and reuse it here
-      const contentType = getEssenceMediaType(request.headers['content-type'])
-      const contentSchema = context[bodySchema][contentType]
+      const contentSchema = context[bodySchema][request.mediaType]
       if (contentSchema) {
         validatorFunction = contentSchema
       }
@@ -262,16 +260,6 @@ function wrapValidationError (result, dataVar, schemaErrorFormatter) {
   return error
 }
 
-/**
- * simple function to retrieve the essence media type
- * @param {string} header
- * @returns {string} Mimetype string.
- */
-function getEssenceMediaType (header) {
-  if (!header) return ''
-  return header.trimStart().split(/[ ;]/, 1)[0].trim().toLowerCase()
-}
-
 module.exports = {
   symbols: { bodySchema, querystringSchema, responseSchema, paramsSchema, headersSchema },
   compileSchemasForValidation,

package/node_modules/fastify/lib/warnings.js

@@ -8,9 +8,9 @@ const { createWarning } = require('process-warning')
  *   - FSTSEC001
  *   - FSTDEP022
  *
- * Deprecation Codes FSTDEP001 - FSTDEP021 were used by v4 and MUST NOT not be reused.
+ * Deprecation Codes FSTDEP001 - FSTDEP021 were used by v4 and MUST NOT be reused.
  *                             - FSTDEP022 is used by v5 and MUST NOT be reused.
- * Warning Codes FSTWRN001 - FSTWRN002 were used by v4 and MUST NOT not be reused.
+ * Warning Codes FSTWRN001 - FSTWRN002 were used by v4 and MUST NOT be reused.
  */
 
 const FSTWRN001 = createWarning({
@@ -30,7 +30,7 @@ const FSTWRN003 = createWarning({
 const FSTWRN004 = createWarning({
   name: 'FastifyWarning',
   code: 'FSTWRN004',
-  message: 'It seems that you are overriding an errorHandler in the same scope, which can lead to subtle bugs.',
+  message: 'It seems that you are overriding an errorHandler in the same scope, which can lead to subtle bugs. To disable this behavior, set \'allowErrorHandlerOverride\' to false. For more information, visit: https://fastify.dev/docs/latest/Reference/Server/#allowerrorhandleroverride',
   unlimited: true
 })
 

package/node_modules/fastify/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "5.8.5",
+  "version": "5.9.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -19,11 +19,11 @@
     "lint:markdown": "markdownlint-cli2",
     "lint:eslint": "eslint",
     "prepublishOnly": "cross-env PREPUBLISH=true borp --reporter=@jsumners/line-reporter && npm run test:validator:integrity && npm run build:sync-version",
-    "test": "npm run lint && npm run unit && npm run test:typescript",
-    "test:ci": "npm run unit && npm run test:typescript",
-    "test:report": "npm run lint && npm run unit:report && npm run test:typescript",
+    "test": "npm run lint && npm run unit && npm run test:types",
+    "test:ci": "npm run unit && npm run test:types",
+    "test:report": "npm run lint && npm run unit:report && npm run test:types",
     "test:validator:integrity": "npm run build:validation && git diff --quiet --ignore-all-space --ignore-blank-lines --ignore-cr-at-eol lib/error-serializer.js && git diff --quiet --ignore-all-space --ignore-blank-lines --ignore-cr-at-eol lib/config-validator.js",
-    "test:typescript": "tsc test/types/import.ts --target es2022 --moduleResolution node16 --module node16 --noEmit && tsd",
+    "test:types": "tstyche",
     "test:watch": "npm run unit -- --watch --coverage-report=none --reporter=terse",
     "unit": "borp",
     "unit:report": "c8 --reporter html borp --reporter=@jsumners/line-reporter",
@@ -45,7 +45,7 @@
   "contributors": [
     {
       "name": "Tomas Della Vedova",
-      "url": "http://delved.org",
+      "url": "https://delvedor.dev",
       "author": true
     },
     {
@@ -59,7 +59,7 @@
     },
     {
       "name": "Dustin Deus",
-      "url": "http://starptech.de",
+      "url": "https://starptech.com",
       "email": "deusdustin@gmail.com"
     },
     {
@@ -74,7 +74,7 @@
     },
     {
       "name": "Trivikram Kamat",
-      "url": "http://trivikr.github.io",
+      "url": "https://trivikr.github.io",
       "email": "trivikr.dev@gmail.com"
     },
     {
@@ -179,11 +179,12 @@
     "autocannon": "^8.0.0",
     "borp": "^1.0.0",
     "branch-comparer": "^1.1.0",
-    "concurrently": "^9.1.2",
+    "concurrently": "^10.0.0",
     "cross-env": "^10.0.0",
     "eslint": "^9.0.0",
     "fast-json-body": "^1.1.0",
-    "fastify-plugin": "^5.0.0",
+    "fastify-plugin": "^6.0.0",
+    "fastify-tsconfig": "^3.0.0",
     "fluent-json-schema": "^6.0.0",
     "h2url": "^0.2.0",
     "http-errors": "^2.0.0",
@@ -195,7 +196,7 @@
     "node-forge": "^1.3.1",
     "proxyquire": "^2.1.3",
     "split2": "^4.2.0",
-    "tsd": "^0.33.0",
+    "tstyche": "^7.0.0",
     "typebox": "^1.0.81",
     "typescript": "~6.0.2",
     "undici": "^7.11.0",
@@ -210,7 +211,7 @@
     "abstract-logging": "^2.0.1",
     "avvio": "^9.0.0",
     "fast-json-stringify": "^6.0.0",
-    "find-my-way": "^9.0.0",
+    "find-my-way": "^9.6.0",
     "light-my-request": "^6.0.0",
     "pino": "^9.14.0 || ^10.1.0",
     "process-warning": "^5.0.0",
@@ -218,8 +219,5 @@
     "secure-json-parse": "^4.0.0",
     "semver": "^7.6.0",
     "toad-cache": "^3.7.0"
-  },
-  "tsd": {
-    "directory": "test/types"
   }
 }

package/node_modules/fastify/scripts/validate-ecosystem-links.js

@@ -14,6 +14,7 @@
 
 const fs = require('node:fs')
 const path = require('node:path')
+const { fetch } = require('undici')
 
 const ECOSYSTEM_FILE = path.join(__dirname, '../docs/Guides/Ecosystem.md')
 const GITHUB_OWNER_REGEX = /^[a-z\d](?:[a-z\d-]{0,38})$/i

package/node_modules/fastify/test/bundler/esbuild/package.json

@@ -5,6 +5,6 @@
     "test": "npm run bundle && node bundler-test.js"
   },
   "devDependencies": {
-    "esbuild": "^0.25.0"
+    "esbuild": "^0.28.1"
   }
 }

package/node_modules/fastify/test/close-pipelining.test.js

@@ -41,8 +41,7 @@ test('Should return 503 while closing - pipelining', async t => {
 })
 
 test('Should close the socket abruptly - pipelining - return503OnClosing: false', async t => {
-  // Since Node v20, we will always invoke server.closeIdleConnections()
-  // therefore our socket will be closed
+  // Node.js will always invoke server.closeIdleConnections() therefore our socket will be closed
   const fastify = Fastify({
     return503OnClosing: false,
     forceCloseConnections: false

package/node_modules/fastify/test/custom-http-server.test.js

@@ -63,6 +63,44 @@ async function setup () {
     )
   })
 
+  test('Should not make an extra closeIdleConnections call for native servers', async t => {
+    const fastify = Fastify({
+      forceCloseConnections: 'idle'
+    })
+
+    await fastify.listen({ port: 0 })
+
+    let called = 0
+    fastify.server.closeIdleConnections = function () {
+      called++
+    }
+
+    await fastify.close()
+
+    t.assert.strictEqual(called, 1)
+  })
+
+  test('Should preserve the extra closeIdleConnections call for custom servers', async t => {
+    let called = 0
+    const fastify = Fastify({
+      forceCloseConnections: 'idle',
+      serverFactory (handler) {
+        const server = http.createServer(handler)
+        const originalCloseIdleConnections = server.closeIdleConnections.bind(server)
+        server.closeIdleConnections = function () {
+          called++
+          return originalCloseIdleConnections()
+        }
+        return server
+      }
+    })
+
+    await fastify.listen({ port: 0 })
+    await fastify.close()
+
+    t.assert.strictEqual(called, 2)
+  })
+
   test('Should accept user defined serverFactory and ignore secondary server creation', async t => {
     const server = http.createServer(() => { })
     t.after(() => new Promise(resolve => server.close(resolve)))

package/node_modules/fastify/test/decorator-instance-properties.test.js

@@ -0,0 +1,63 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+
+test('hasRequestDecorator returns true for built-in constructor-assigned request properties', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  t.assert.equal(fastify.hasRequestDecorator('id'), true)
+  t.assert.equal(fastify.hasRequestDecorator('params'), true)
+  t.assert.equal(fastify.hasRequestDecorator('raw'), true)
+  t.assert.equal(fastify.hasRequestDecorator('query'), true)
+  t.assert.equal(fastify.hasRequestDecorator('log'), true)
+  t.assert.equal(fastify.hasRequestDecorator('body'), true)
+})
+
+test('hasReplyDecorator returns true for built-in constructor-assigned reply properties', t => {
+  t.plan(3)
+  const fastify = Fastify()
+  t.assert.equal(fastify.hasReplyDecorator('raw'), true)
+  t.assert.equal(fastify.hasReplyDecorator('request'), true)
+  t.assert.equal(fastify.hasReplyDecorator('log'), true)
+})
+
+test('decorateRequest throws FST_ERR_DEC_ALREADY_PRESENT for built-in request properties', t => {
+  t.plan(4)
+  const fastify = Fastify()
+  for (const name of ['id', 'params', 'raw', 'body']) {
+    t.assert.throws(
+      () => fastify.decorateRequest(name, null),
+      (err) => err.code === 'FST_ERR_DEC_ALREADY_PRESENT'
+    )
+  }
+})
+
+test('decorateReply throws FST_ERR_DEC_ALREADY_PRESENT for built-in reply properties', t => {
+  t.plan(2)
+  const fastify = Fastify()
+  for (const name of ['raw', 'request']) {
+    t.assert.throws(
+      () => fastify.decorateReply(name, null),
+      (err) => err.code === 'FST_ERR_DEC_ALREADY_PRESENT'
+    )
+  }
+})
+
+test('hasRequestDecorator returns false for unknown properties', t => {
+  t.plan(1)
+  const fastify = Fastify()
+  t.assert.equal(fastify.hasRequestDecorator('nonExistent'), false)
+})
+
+test('decorateRequest still works for non-built-in names', (t, done) => {
+  t.plan(2)
+  const fastify = Fastify()
+  fastify.decorateRequest('myExtra', null)
+  t.assert.equal(fastify.hasRequestDecorator('myExtra'), true)
+  fastify.get('/', async (req) => req.myExtra)
+  fastify.ready((err) => {
+    t.assert.ifError(err)
+    done()
+  })
+})

package/node_modules/fastify/test/diagnostics-channel/async-error-handler.test.js

@@ -0,0 +1,74 @@
+'use strict'
+
+const { test } = require('node:test')
+const diagnostics = require('node:diagnostics_channel')
+const Fastify = require('../..')
+const Request = require('../../lib/request')
+const Reply = require('../../lib/reply')
+
+test('diagnostics channel tracks async operations in async error handlers', async t => {
+  t.plan(17)
+  let callOrder = 0
+  let firstEncounteredMessage
+  let asyncStartFired = false
+  let asyncEndFired = false
+
+  const fastify = Fastify()
+
+  function subscribe (name, handler) {
+    const wrapped = (msg) => {
+      if (msg.request.server === fastify) handler(msg)
+    }
+    diagnostics.subscribe(name, wrapped)
+    t.after(() => diagnostics.unsubscribe(name, wrapped))
+  }
+
+  subscribe('tracing:fastify.request.handler:start', (msg) => {
+    t.assert.strictEqual(callOrder++, 0)
+    firstEncounteredMessage = msg
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+  })
+
+  subscribe('tracing:fastify.request.handler:error', (msg) => {
+    t.assert.strictEqual(callOrder++, 1)
+    t.assert.ok(msg.error instanceof Error)
+    t.assert.strictEqual(msg.error.message, 'handler error')
+  })
+
+  subscribe('tracing:fastify.request.handler:end', (msg) => {
+    t.assert.strictEqual(callOrder++, 2)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+    t.assert.strictEqual(msg.async, true)
+  })
+
+  subscribe('tracing:fastify.request.handler:asyncStart', (msg) => {
+    t.assert.strictEqual(callOrder++, 3)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+    asyncStartFired = true
+  })
+
+  subscribe('tracing:fastify.request.handler:asyncEnd', (msg) => {
+    t.assert.strictEqual(callOrder++, 4)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+    asyncEndFired = true
+  })
+
+  fastify.setErrorHandler(async (error, request, reply) => {
+    await new Promise(resolve => setImmediate(resolve))
+    reply.status(503).send({ error: error.message })
+  })
+
+  fastify.get('/', () => {
+    throw new Error('handler error')
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  const response = await fetch(fastifyServer)
+  t.assert.ok(!response.ok)
+  t.assert.strictEqual(response.status, 503)
+  t.assert.ok(asyncStartFired, 'asyncStart should fire for async error handler')
+  t.assert.ok(asyncEndFired, 'asyncEnd should fire for async error handler')
+})

package/node_modules/fastify/test/hooks.test.js

@@ -12,6 +12,7 @@ const proxyquire = require('proxyquire')
 const { connect } = require('node:net')
 const { sleep } = require('./helper')
 const { waitForCb } = require('./toolkit.js')
+const { fetch } = require('undici')
 
 process.removeAllListeners('warning')
 
@@ -3277,6 +3278,28 @@ test('onTimeout should be triggered and socket _meta is set', async t => {
   }
 })
 
+test('socket._meta is cleared after response to prevent keep-alive leaks', async t => {
+  t.plan(3)
+  const fastify = Fastify({ connectionTimeout: 500 })
+  t.after(() => { fastify.close() })
+
+  fastify.addHook('onTimeout', function (req, res, done) { done() })
+
+  fastify.addHook('onResponse', function (req, reply, done) {
+    t.assert.strictEqual(req.raw.socket._meta, null, 'socket._meta must be null after response')
+    done()
+  })
+
+  fastify.get('/', async (req, reply) => {
+    return { hello: 'world' }
+  })
+
+  const address = await fastify.listen({ port: 0 })
+  const result = await fetch(address)
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+})
+
 test('registering invalid hooks should throw an error', async t => {
   t.plan(3)
 

package/node_modules/fastify/test/http-methods/get.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { test } = require('node:test')
-const { Client } = require('undici')
+const { Client, fetch } = require('undici')
 const fastify = require('../../fastify')()
 
 const schema = {

package/node_modules/fastify/test/http2/plain.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { test } = require('node:test')
+const http2 = require('node:http2')
 const Fastify = require('../..')
 const h2url = require('h2url')
 const msg = { hello: 'world' }
@@ -66,3 +67,137 @@ test('http2 plain test', async t => {
     t.assert.strictEqual(JSON.parse(res.body).port, parseInt(host.split(':')[1]))
   })
 })
+
+test('http2 large non-stream replies are sent completely', async t => {
+  const modes = ['buffer', 'string']
+
+  for (const mode of modes) {
+    await t.test(mode, async t => {
+      const fastify = Fastify({ http2: true })
+      const payload = mode === 'buffer'
+        ? Buffer.alloc((64 * 1024) + 1, 'a')
+        : 'a'.repeat((64 * 1024) + 1)
+      const contentLength = Buffer.byteLength(payload)
+
+      fastify.get('/large', async (req, reply) => {
+        reply.header('content-type', 'application/octet-stream')
+        reply.header('content-length', contentLength)
+
+        return payload
+      })
+
+      await fastify.listen({ port: 0, host: '127.0.0.1' })
+
+      const client = http2.connect(`http://127.0.0.1:${fastify.server.address().port}`)
+      t.after(() => {
+        client.close()
+        return fastify.close()
+      })
+
+      await new Promise((resolve, reject) => {
+        const large = client.request({
+          [http2.constants.HTTP2_HEADER_METHOD]: http2.constants.HTTP2_METHOD_GET,
+          [http2.constants.HTTP2_HEADER_PATH]: '/large'
+        })
+        const chunks = []
+
+        large.on('error', reject)
+        large.on('data', chunk => {
+          chunks.push(chunk)
+        })
+        large.on('end', () => {
+          t.assert.strictEqual(Buffer.concat(chunks).length, contentLength)
+          resolve()
+        })
+        large.end()
+      })
+    })
+  }
+})
+
+test('http2 large buffer replies can be cancelled without rejecting the next stream', async t => {
+  const fastify = Fastify({ http2: true })
+  const payload = Buffer.alloc(32 * 1024 * 1024, 'a')
+  let smallHit = false
+
+  fastify.get('/large', async (req, reply) => {
+    reply.header('content-type', 'application/octet-stream')
+    reply.header('content-length', payload.length)
+
+    return payload
+  })
+
+  fastify.get('/small', async () => {
+    smallHit = true
+    return 'ok'
+  })
+
+  await fastify.listen({ port: 0, host: '127.0.0.1' })
+
+  const client = http2.connect(`http://127.0.0.1:${fastify.server.address().port}`)
+  t.after(() => {
+    client.close()
+    return fastify.close()
+  })
+
+  await new Promise((resolve, reject) => {
+    let cancelTimer
+    let requestTimer
+    let timeout
+
+    function cleanup () {
+      clearTimeout(cancelTimer)
+      clearTimeout(requestTimer)
+      clearTimeout(timeout)
+    }
+
+    const large = client.request({
+      [http2.constants.HTTP2_HEADER_METHOD]: http2.constants.HTTP2_METHOD_GET,
+      [http2.constants.HTTP2_HEADER_PATH]: '/large'
+    })
+    let largeResponded = false
+
+    large.on('error', err => {
+      if (!largeResponded) {
+        cleanup()
+        reject(err)
+      }
+    })
+    large.on('response', () => {
+      largeResponded = true
+      large.pause()
+      cancelTimer = setTimeout(() => {
+        large.close(http2.constants.NGHTTP2_CANCEL)
+      }, 100)
+      requestTimer = setTimeout(() => {
+        const small = client.request({
+          [http2.constants.HTTP2_HEADER_METHOD]: http2.constants.HTTP2_METHOD_GET,
+          [http2.constants.HTTP2_HEADER_PATH]: '/small'
+        })
+        let body = ''
+
+        timeout = setTimeout(() => {
+          cleanup()
+          reject(new Error('timed out waiting for /small response'))
+        }, 3000)
+
+        small.setEncoding('utf8')
+        small.on('error', err => {
+          cleanup()
+          reject(err)
+        })
+        small.on('data', chunk => {
+          body += chunk
+        })
+        small.on('end', () => {
+          cleanup()
+          t.assert.strictEqual(body, 'ok')
+          t.assert.strictEqual(smallHit, true)
+          resolve()
+        })
+        small.end()
+      }, 200)
+    })
+    large.end()
+  })
+})

package/node_modules/fastify/test/http2/secure-with-fallback.test.js

@@ -6,7 +6,7 @@ const h2url = require('h2url')
 const msg = { hello: 'world' }
 
 const { buildCertificate } = require('../build-certificate')
-const { Agent } = require('undici')
+const { Agent, fetch } = require('undici')
 test.before(buildCertificate)
 
 test('secure with fallback', async (t) => {