tapimo 0.15.0 → 0.18.0

package/src/App.test.ts

@@ -1,7 +1,8 @@
 import * as http from 'node:http'
+import { sql } from 'kysely'
 import { Challenge } from 'mppx'
 import * as Docs from 'tapimo/docs'
-import { ApiKeys, App, Metrics, RateLimit, Store } from 'tapimo/server'
+import { ApiKeys, App, Db, Metrics, RateLimit, Store } from 'tapimo/server'
 import * as Tokenlist from './apps/data/routes/tokenlist.js'
 import * as Tokens from './apps/data/routes/tokens.js'
 import * as Organizations from './db/tables/organizations.js'
@@ -11,6 +12,82 @@ import * as Runtime from '../test/runtime.js'
 import * as Tempo from '../test/Tempo.js'
 
 describe('create', () => {
+  test('reuses a database factory within each concurrent request', async () => {
+    const databases: Db.Db[] = []
+    const source = () => {
+      const database = TestApp.database()
+      databases.push(database)
+      return database
+    }
+    type Row = { value: number }
+    const app = TestApp.create({ auth: false, db: { cached: source, source } }).get(
+      '/database-scope',
+      async (c) => {
+        const first = Db.get(c.get('db'))
+        const second = Db.get(c.get('db'))
+        const cached = Db.get(c.get('dbCached'))
+        const results = await Promise.all([
+          sql<Row>`SELECT pg_sleep(0.01), 1 AS value`.execute(first.kysely),
+          sql<Row>`SELECT 2 AS value`.execute(second.kysely),
+          sql<Row>`SELECT 3 AS value`.execute(cached.kysely),
+        ])
+        return c.json(results.map((result) => result.rows.map((row) => row.value)))
+      },
+    )
+    try {
+      const responses = await Promise.all([
+        app.request('/database-scope'),
+        app.request('/database-scope'),
+      ])
+      expect(await Promise.all(responses.map((response) => response.json())))
+        .toMatchInlineSnapshot(`
+          [
+            [
+              [
+                1,
+              ],
+              [
+                2,
+              ],
+              [
+                3,
+              ],
+            ],
+            [
+              [
+                1,
+              ],
+              [
+                2,
+              ],
+              [
+                3,
+              ],
+            ],
+          ]
+        `)
+      expect(databases).toHaveLength(2)
+      expect(databases[0]).not.toBe(databases[1])
+      expect(
+        responses.every((response) => response.headers.get('server-timing')?.includes('db;')),
+      ).toBe(true)
+      expect(
+        responses.every((response) =>
+          response.headers.get('server-timing')?.includes('db_cached;'),
+        ),
+      ).toBe(true)
+      expect(
+        responses.every((response) =>
+          ['db_acquire', 'db_query', 'db_cached_acquire', 'db_cached_query'].every((stage) =>
+            response.headers.get('server-timing')?.includes(`${stage};`),
+          ),
+        ),
+      ).toBe(true)
+    } finally {
+      await Promise.all(databases.map((database) => database.close()))
+    }
+  })
+
   test('rejects duplicate provider ids', () => {
     expect(() =>
       TestApp.create({
@@ -144,11 +221,11 @@ describe('create', () => {
   })
 
   test('bypasses an exhausted edge limit for cached API keys on protected routes', async () => {
-    const limit = { limit: 1, period: 'minute' } satisfies RateLimit.Limit
-    const rateLimit = RateLimit.memory()
+    let attempts = 0
     const global = {
-      async limit({ key }) {
-        return { success: (await rateLimit.consume({ key, limit })).allowed }
+      async limit() {
+        attempts++
+        return { success: attempts === 1 }
       },
     } satisfies RateLimit.Binding
     const app = TestApp.create({
@@ -184,11 +261,11 @@ describe('create', () => {
   })
 
   test('edge-limits repeated requests after a cached key becomes invalid', async () => {
-    const limit = { limit: 1, period: 'minute' } satisfies RateLimit.Limit
-    const rateLimit = RateLimit.memory()
+    let attempts = 0
     const global = {
-      async limit({ key }) {
-        return { success: (await rateLimit.consume({ key, limit })).allowed }
+      async limit() {
+        attempts++
+        return { success: attempts === 1 }
       },
     } satisfies RateLimit.Binding
     const store = Store.memory()
@@ -208,7 +285,295 @@ describe('create', () => {
     expect(throttled.headers.get('server-timing')).toContain('edge_rate_limit')
   })
 
-  test('applies the edge limit before invalid-key lookup and CORS', async () => {
+  test('isolates cold API keys from anonymous edge limits', async () => {
+    const limit = { limit: 1, period: 'minute' } satisfies RateLimit.Limit
+    const rateLimit = RateLimit.memory()
+    const ip = {
+      async limit({ key }) {
+        return { success: (await rateLimit.consume({ key, limit })).allowed }
+      },
+    } satisfies RateLimit.Binding
+    const app = TestApp.create({
+      auth: {
+        edgeRateLimit: (request, options) =>
+          RateLimit.edge(request, { ip, resolvePartition: options.resolvePartition }),
+      },
+    })
+    const headers = { 'cf-connecting-ip': '203.0.113.7' }
+
+    const allowed = await app.request('/health', { headers })
+    const anonymous = await app.request('/health', { headers })
+    const authenticated = await app.request('/v1/tokens/not-an-address', {
+      headers: { ...headers, 'tempo-api-key': TestApp.key.token },
+    })
+
+    expect(allowed.status).toBe(200)
+    expect(anonymous.status).toBe(429)
+    expect(authenticated.status).toBe(400)
+    expect(authenticated.headers.get('server-timing')).toContain('edge_rate_limit')
+  })
+
+  test('resolves cold and cached API keys without Postgres queries', async () => {
+    const queries: number[] = []
+    const db = Db.observe(TestApp.database(), { onQuery: (ms) => queries.push(ms) })
+    const app = TestApp.create({ cache: { store: Store.memory() }, db })
+
+    for (let request = 0; request < 2; request++) {
+      const response = await app.request('/v1/tokens/not-an-address', {
+        headers: { 'tempo-api-key': TestApp.key.token },
+      })
+
+      expect(response.status).toBe(400)
+      const stages = response.headers
+        .get('server-timing')!
+        .split(',')
+        .map((stage) => stage.trim().split(';')[0])
+      expect(stages.filter((stage) => ['auth_key', 'rate_limit', 'db'].includes(stage!)))
+        .toMatchInlineSnapshot(`
+          [
+            "auth_key",
+            "rate_limit",
+          ]
+        `)
+    }
+    expect(queries).toMatchInlineSnapshot(`[]`)
+  })
+
+  test.each(['cold', 'cached', 'probe'])(
+    'rejects a KV-fenced key during %s resolution',
+    async (mode) => {
+      const queries: number[] = []
+      const db = Db.observe(TestApp.database(), { onQuery: (ms) => queries.push(ms) })
+      const store = Store.memory()
+      const { record, token } = await ApiKeys.mintBounded(db, store, {
+        orgId: 'org_revocation',
+        scopes: ['data:read'],
+      })
+      const limit = { limit: 1, period: 'minute' } satisfies RateLimit.Limit
+      const rateLimit = RateLimit.memory()
+      const ip = {
+        async limit({ key }) {
+          return { success: (await rateLimit.consume({ key, limit })).allowed }
+        },
+      } satisfies RateLimit.Binding
+      const app = TestApp.create({
+        auth:
+          mode === 'probe'
+            ? {
+                edgeRateLimit: (request, options) =>
+                  RateLimit.edge(request, { ip, resolvePartition: options.resolvePartition }),
+              }
+            : {},
+        db,
+        kv: { store },
+      })
+      const headers = { 'cf-connecting-ip': '203.0.113.7', 'tempo-api-key': token }
+      if (mode === 'cached')
+        expect((await app.request('/v1/tokens/not-an-address', { headers })).status).toBe(400)
+      if (mode === 'probe')
+        expect(
+          (await app.request('/health', { headers: { 'cf-connecting-ip': '203.0.113.7' } })).status,
+        ).toBe(200)
+      await store.delete(`apikey_id:${record.id}`)
+      await ApiKeys.revokeBounded(db, store, record.id)
+      queries.length = 0
+
+      const response = await app.request('/v1/tokens/not-an-address', { headers })
+
+      expect(response.status).toBe(mode === 'probe' ? 429 : 401)
+      expect(queries).toMatchInlineSnapshot(`[]`)
+    },
+  )
+
+  test('keeps rotating invalid API keys in the anonymous edge limit', async () => {
+    const limit = { limit: 2, period: 'minute' } satisfies RateLimit.Limit
+    const rateLimit = RateLimit.memory()
+    const ip = {
+      async limit({ key }) {
+        return { success: (await rateLimit.consume({ key, limit })).allowed }
+      },
+    } satisfies RateLimit.Binding
+    const app = TestApp.create({
+      auth: {
+        edgeRateLimit: (request, options) =>
+          RateLimit.edge(request, { ip, resolvePartition: options.resolvePartition }),
+      },
+    })
+    const headers = { 'cf-connecting-ip': '203.0.113.7' }
+
+    const invalid = await app.request('/v1/tokens/not-an-address', {
+      headers: { ...headers, 'tempo-api-key': 'invalid-one' },
+    })
+    const rotated = await app.request('/v1/tokens/not-an-address', {
+      headers: { ...headers, 'tempo-api-key': 'invalid-two' },
+    })
+    const blocked = await app.request('/v1/tokens/not-an-address', {
+      headers: { ...headers, 'tempo-api-key': 'invalid-three' },
+    })
+    const authenticated = await app.request('/v1/tokens/not-an-address', {
+      headers: { ...headers, 'tempo-api-key': TestApp.key.token },
+    })
+
+    expect(invalid.status).toBe(401)
+    expect(rotated.status).toBe(401)
+    expect(blocked.status).toBe(429)
+    expect(authenticated.status).toBe(400)
+  })
+
+  test('does not cache a key whose isolated edge limit rejects', async () => {
+    let attempts = 0
+    const ip = {
+      async limit() {
+        attempts++
+        // Shared and partition buckets reject; the credential-probe admission
+        // bucket allows so each request exercises the uncached probe path.
+        return { success: attempts % 3 === 2 }
+      },
+    } satisfies RateLimit.Binding
+    const app = TestApp.create({
+      auth: {
+        edgeRateLimit: (request, options) =>
+          RateLimit.edge(request, { ip, resolvePartition: options.resolvePartition }),
+      },
+    })
+    const headers = {
+      'cf-connecting-ip': '203.0.113.7',
+      'tempo-api-key': TestApp.key.token,
+    }
+
+    const first = await app.request('/v1/tokens/not-an-address', { headers })
+    const second = await app.request('/v1/tokens/not-an-address', { headers })
+
+    expect(first.status).toBe(429)
+    expect(second.status).toBe(429)
+    expect(attempts).toBe(6)
+  })
+
+  test('does not warm the resolution cache from concurrent credential probes', async () => {
+    const queries: number[] = []
+    const db = Db.observe(TestApp.database(), { onQuery: (ms) => queries.push(ms) })
+    const store = Store.memory()
+    const { record, token: apiKey } = await ApiKeys.mint(store, { scopes: ['data:read'] })
+    const release = Promise.withResolvers<void>()
+    const partitions: (string | undefined)[] = []
+    const app = TestApp.create({
+      auth: {
+        edgeRateLimit: async (_request, options) => {
+          partitions.push(await options.resolvePartition?.())
+          if (partitions.length === 2) {
+            // Revoke after both probes but before either request enters auth resolution.
+            await ApiKeys.revoke(store, record.id)
+            release.resolve()
+          }
+          await release.promise
+        },
+      },
+      db,
+      kv: { store },
+    })
+    const headers = { 'tempo-api-key': apiKey }
+
+    const responses = await Promise.all([
+      app.request('/v1/tokens/not-an-address', { headers }),
+      app.request('/v1/tokens/not-an-address', { headers }),
+    ])
+
+    expect(partitions).toHaveLength(2)
+    expect(partitions[0]).toBeTypeOf('string')
+    expect(partitions[1]).toBe(partitions[0])
+    expect(responses.map((response) => response.status)).toMatchInlineSnapshot(`
+      [
+        401,
+        401,
+      ]
+    `)
+    expect(queries).toMatchInlineSnapshot(`[]`)
+  })
+
+  test('keeps CLI session tokens out of API-key quota resolution', async () => {
+    const partitioned: boolean[] = []
+    const app = TestApp.create({
+      auth: {
+        edgeRateLimit: async (_request, options) => {
+          partitioned.push(options.resolvePartition !== undefined)
+        },
+      },
+    })
+
+    await app.request('/v1/orgs', { headers: { 'tempo-api-key': TestApp.key.token } })
+    const cli = await app.request('/v1/orgs', {
+      headers: { authorization: `Bearer tempo:cli:${'ab'.repeat(32)}` },
+    })
+
+    expect(partitioned).toEqual([true, false])
+    expect(cli.status).toBe(401)
+  })
+
+  test('records the presented credential without an edge limiter', async () => {
+    const entries: Log.Entry[] = []
+    const app = TestApp.create({ logger: (entry) => void entries.push(entry) })
+
+    const response = await app.request('/v1/not-a-route', {
+      headers: { 'tempo-api-key': TestApp.key.token },
+    })
+
+    expect({
+      credential: entries[0]?.credential,
+      status: response.status,
+    }).toMatchInlineSnapshot(`
+      {
+        "credential": "api_key",
+        "status": 404,
+      }
+    `)
+  })
+
+  test('attributes a request canceled during auth to its presented credential', async () => {
+    const entries: Log.Entry[] = []
+    const started = Promise.withResolvers<void>()
+    const release = Promise.withResolvers<void>()
+    const app = TestApp.create({
+      auth: {
+        edgeRateLimit: async () => {
+          started.resolve()
+          await release.promise
+        },
+      },
+      logger: (entry) => void entries.push(entry),
+    })
+    const controller = new AbortController()
+
+    const response = app.request('/v1/tokens/not-an-address', {
+      headers: { 'tempo-api-key': TestApp.key.token },
+      signal: controller.signal,
+    })
+    await started.promise
+    controller.abort()
+    const [canceled] = entries
+    release.resolve()
+    await response
+
+    expect(entries).toHaveLength(1)
+    expect({
+      credential: canceled?.credential,
+      errorCode: canceled?.errorCode,
+      pendingTimings: Object.keys(canceled?.pendingTimings ?? {}),
+      principal: canceled?.principal,
+      status: canceled?.status,
+    }).toMatchInlineSnapshot(`
+      {
+        "credential": "api_key",
+        "errorCode": "client_canceled",
+        "pendingTimings": [
+          "edge_rate_limit",
+        ],
+        "principal": undefined,
+        "status": 499,
+      }
+    `)
+  })
+
+  test('applies the edge limit to invalid keys and before CORS', async () => {
     const limit = { limit: 1, period: 'minute' } satisfies RateLimit.Limit
     const rateLimit = RateLimit.memory()
     const global = {
@@ -402,6 +767,27 @@ describe('create', () => {
     ])
   })
 
+  test('tags openapi.json and answers a matching If-None-Match with 304', async () => {
+    const app = TestApp.create()
+    const first = await app.request('/openapi.json')
+    const etag = first.headers.get('etag')
+    expect(etag).toMatch(/^"[0-9a-f]{32}"$/)
+    expect(first.headers.get('cache-control')).toBe('no-cache')
+    expect((await app.request('/openapi.json')).headers.get('etag')).toBe(etag)
+
+    // CDNs weaken strong tags when they compress, so weak validators must match too.
+    const revalidated = await app.request('/openapi.json', {
+      headers: { 'if-none-match': `W/${etag}` },
+    })
+    expect(revalidated.status).toBe(304)
+    expect(revalidated.headers.get('etag')).toBe(etag)
+    expect(await revalidated.text()).toBe('')
+
+    const stale = await app.request('/openapi.json', { headers: { 'if-none-match': '"stale"' } })
+    expect(stale.status).toBe(200)
+    expect((await stale.json()).openapi).toBeDefined()
+  })
+
   test('keeps standard and custom error component names distinct', async () => {
     const spec = await (await TestApp.create().request('/openapi.json')).json()
     const billing =
@@ -468,7 +854,7 @@ describe('create', () => {
     expect((await app.request('/v1/tokens/not-an-address', { headers })).status).toBe(401)
   })
 
-  test('rejects an attributed key after its database owner is deleted', async () => {
+  test('rejects an attributed key after its owner deletion publishes the KV fence', async () => {
     const db = TestApp.database()
     const store = Store.memory()
     const organization = await Organizations.create(db, { name: 'Acme' })
@@ -480,7 +866,11 @@ describe('create', () => {
     const headers = { authorization: `Bearer ${token}` }
 
     expect((await app.request('/v1/tokens/not-an-address', { headers })).status).toBe(400)
-    expect(await Organizations.deleteOrganization(db, organization.id)).toBe(true)
+    expect(
+      await Organizations.deleteOrganization(db, organization.id, {
+        beforeCommit: () => ApiKeys.markOwnerDeleting(store, { orgId: organization.id }),
+      }),
+    ).toBe(true)
     expect((await app.request('/v1/tokens/not-an-address', { headers })).status).toBe(401)
   })
 
@@ -510,7 +900,7 @@ describe('create', () => {
     expect(rejected.status).toMatchInlineSnapshot(`401`)
   })
 
-  test('caches key resolution by default, so a revoke lags up to the TTL', async () => {
+  test('rejects a cached key after its KV revocation marker propagates', async () => {
     const store = Store.memory()
     const { record, token } = await ApiKeys.mint(store, {
       scopes: ['data:read'],
@@ -522,12 +912,9 @@ describe('create', () => {
     const authed = await app.request('/v1/tokens/not-an-address', { headers })
     expect(authed.status).toMatchInlineSnapshot(`400`)
 
-    // The positive resolve is cached per isolate (60s by default), so the
-    // revoked key keeps authenticating until the entry expires — the
-    // documented trade-off for skipping a backend read per request.
     expect(await ApiKeys.revoke(store, record.id)).toMatchInlineSnapshot(`true`)
     const revoked = await app.request('/v1/tokens/not-an-address', { headers })
-    expect(revoked.status).toMatchInlineSnapshot(`400`)
+    expect(revoked.status).toMatchInlineSnapshot(`401`)
   })
 
   test('applies endpoint auth overrides', async () => {
@@ -809,7 +1196,7 @@ describe('create', () => {
         {
           "cache": "hit",
           "chainId": 42431,
-          "route": "/*",
+          "route": "/v1/tokenlist",
         },
       ]
     `)

package/src/App.ts

@@ -1,3 +1,4 @@
+import * as asyncHooks from 'node:async_hooks'
 import type { Context } from 'hono'
 import { Hono } from 'hono'
 import { matchedRoutes } from 'hono/route'
@@ -7,13 +8,16 @@ import { HTTPException } from 'hono/http-exception'
 import { requestId, type RequestIdVariables } from 'hono/request-id'
 import { timeout as hono_timeout } from 'hono/timeout'
 import { generateSpecs } from 'hono-openapi'
+import { Hash, Hex } from 'ox'
 import type { Chain } from 'viem'
 
 import type * as Analytics from './analytics/Analytics.js'
 import * as ApiKey from './ApiKey.js'
 import * as Assets from './Assets.js'
 import * as Auth from './internal/Auth.js'
+import * as Cache from './internal/Cache.js'
 import * as Db from './db/Db.js'
+import * as ExecutionContext from './internal/ExecutionContext.js'
 import * as EdgeCache from './internal/EdgeCache.js'
 import * as core_Email from './internal/Email.js'
 import * as Log from './internal/Log.js'
@@ -41,6 +45,8 @@ import * as Management from './apps/management/App.js'
 import * as Mpp from './apps/mpp/App.js'
 import * as Relay from './apps/relay/App.js'
 
+const databaseScopes = new asyncHooks.AsyncLocalStorage<Map<Db.Source, Db.Db>>()
+
 export import data = Data.data
 export import routes = Routes.routes
 export import management = Management.management
@@ -328,6 +334,13 @@ export function create<const path extends string = '/'>(options: create.Options<
   // Normalize the `db` option: the plain form is `{ source }` with no cached
   // side; `cached` falls back to `source` so consumers never branch.
   const db = 'source' in options.db ? options.db : { source: options.db }
+  // Postgres time, including Hyperdrive connect, lands in one stage per source.
+  // Wrapped once: snapshot caches key on source identity, so a per-request
+  // wrapper would defeat them. Built-in auth reads through the same source.
+  const db_observed = {
+    cached: observeSource(db.cached ?? db.source, 'db_cached'),
+    source: observeSource(db.source, 'db'),
+  }
 
   const providers = (() => {
     const values = options.providers ?? []
@@ -356,7 +369,7 @@ export function create<const path extends string = '/'>(options: create.Options<
   const auth = Auth.install({
     auth: options.auth,
     basePath,
-    db: db.source,
+    db: db_observed.source,
     email: () => email,
     getClient,
     kv: options.kv,
@@ -364,12 +377,13 @@ export function create<const path extends string = '/'>(options: create.Options<
   })
 
   base.use('*', Timing.middleware())
+  base.use('*', (_c, next) => databaseScopes.run(new Map(), next))
   base.use('*', async (c, next) => {
     c.set('analytics', analytics)
     c.set('basePath', basePath)
     c.set('chainId', defaultChainId)
-    c.set('db', db.source)
-    c.set('dbCached', db.cached ?? db.source)
+    c.set('db', db_observed.source)
+    c.set('dbCached', db_observed.cached)
     c.set('email', email)
     c.set('getClient', (chainId) => getClient(chainId, Auth.getPrincipal(c)))
     c.set('kv', options.kv)
@@ -377,7 +391,7 @@ export function create<const path extends string = '/'>(options: create.Options<
     c.set('providers', providers)
     c.set('rpc', options.rpc)
     c.set('scopeCatalog', scopeCatalog)
-    c.set('store', Store.withRequest(store, c.req, { waitUntil: getWaitUntil(c) }))
+    c.set('store', Store.withRequest(store, c.req, { waitUntil: ExecutionContext.waitUntil(c) }))
     c.set('supportedChainIds', supportedChainIds)
     c.set('vercelOidc', options.vercelOidc)
     c.set('zones', zones)
@@ -511,6 +525,15 @@ export function create<const path extends string = '/'>(options: create.Options<
   // while `/openapi.json` and the Vocs handler start the memoized build.
   let spec: ReturnType<typeof buildSpec> | undefined
   const getSpec = () => (spec ??= buildSpec())
+  // The document is fixed per isolate, so serialize and tag it once; revalidating
+  // clients (the CLI loads it on every run) then cost a 304 instead of 1.5 MB.
+  type SpecDocument = { body: string; etag: string }
+  let specDocument: Promise<SpecDocument> | undefined
+  const getSpecDocument = () =>
+    (specDocument ??= getSpec().then((value) => {
+      const body = JSON.stringify(value)
+      return { body, etag: `"${Hash.sha256(Hex.fromString(body)).slice(2, 34)}"` }
+    }))
   const buildSpec = async () => {
     // Merge each mounted group's contributed OpenAPI metadata (tags, security
     // schemes, webhooks block). Unused tags/schemes don't render, so a subset
@@ -634,7 +657,13 @@ export function create<const path extends string = '/'>(options: create.Options<
     })
     finalized = true
 
-    app.get('/openapi.json', async (c) => c.json(await getSpec()))
+    app.get('/openapi.json', async (c) => {
+      const { body, etag } = await getSpecDocument()
+      c.header('Cache-Control', 'no-cache')
+      c.header('ETag', etag)
+      if (Cache.Etag.matches(etag, c.req.header('If-None-Match'))) return c.body(null, 304)
+      return c.body(body, 200, { 'Content-Type': 'application/json' })
+    })
 
     // The OpenRPC document is a committed build artifact (no runtime generator);
     // see scripts/openrpc/build.ts and `pnpm openrpc:build`.
@@ -669,6 +698,23 @@ export function listener(app: { fetch: NodeServer.Fetch }): Listener {
   return NodeServer.getRequestListener(app.fetch)
 }
 
+/** Wraps a source so each query's duration lands in the current request's `name` stage. */
+function observeSource(source: Db.Source, name: string): Db.Source {
+  return () => {
+    // Authentication and handlers share one pool without retaining Worker connections across requests.
+    const scope = databaseScopes.getStore()
+    const database = scope?.get(source) ?? Db.get(source)
+    scope?.set(source, database)
+    return Db.observe(database, {
+      onQuery: (ms, timing) => {
+        Timing.record(name, ms)
+        Timing.record(`${name}_acquire`, timing.acquire)
+        Timing.record(`${name}_query`, timing.query)
+      },
+    })
+  }
+}
+
 export declare namespace create {
   /**
    * Options for creating the Tempo API Hono app: shared chain, RPC, database,
@@ -1228,16 +1274,6 @@ namespace ResponseBody {
   }
 }
 
-function getWaitUntil(c: { executionCtx?: { waitUntil(promise: Promise<unknown>): void } }) {
-  // `c.executionCtx` throws in runtimes without one, so cache persistence falls back to an awaited write.
-  try {
-    const context = c.executionCtx
-    return context ? context.waitUntil.bind(context) : undefined
-  } catch {
-    return undefined
-  }
-}
-
 namespace NodeServer {
   type GetRequestListener = (typeof import('@hono/node-server'))['getRequestListener']
   export type Fetch = Parameters<GetRequestListener>[0]