feat: support edge middleware (#114)

* feat: build time edge runtime

* chore: update middleware test fixture

* fix: remove pattern array for now

* chore: update tests with middleware scenarios

* chore: fix fixture build errors

* feat: support edge middleware

* chore: update comment

* chore: remove `.only`

* fix: stop caching resolved paths

* chore: fix test

* chore: add e2e test

* fix: use correct runtime directory

* chore: add E2E test

* Apply suggestions from code review

Co-authored-by: Lukas Holzer <lukas.holzer@typeflow.cc>

* chore: remove dead code

* chore: document `E2E_PERSIST`

---------

Co-authored-by: Rob Stanford <me@robstanford.com>
Co-authored-by: Lukas Holzer <lukas.holzer@typeflow.cc>

Author: 3 people

.gitignore

@@ -1,6 +1,7 @@
 node_modules/
 dist/
 .next
+edge-runtime/vendor
 
 # Local Netlify folder
 .netlify

README.md

@@ -46,6 +46,9 @@ following:
    up. In case of a failure, the deploy won't be cleaned up to leave it for troubleshooting
    purposes.
 
+> [!TIP] If you'd like to always keep the deployment and the local fixture around for
+> troubleshooting, run `E2E_PERSIST=1 npm run e2e`.
+
 #### cleanup old deploys
 
 To cleanup old and dangling deploys from failed builds you can run the following script:

deno.json

@@ -3,5 +3,9 @@
     "files": {
       "include": ["edge-runtime/middleware.ts"]
     }
-  }
+  },
+  "imports": {
+    "@netlify/edge-functions": "https://edge.netlify.com/v1/index.ts"
+  },
+  "importMap": "./edge-runtime/vendor/import_map.json"
 }

edge-runtime/README.md

@@ -0,0 +1,29 @@
+# Edge runtime
+
+This directory contains the logic required to create Netlify Edge Functions to support a Next.js
+site.
+
+It stands out from the rest of the project because it contains files that run in Deno, not Node.js.
+Therefore any files within `edge-runtime/` should not be imported from anywhere outside this
+directory.
+
+There are a few sub-directories you should know about.
+
+## `lib/`
+
+Files that are imported by the generated edge functions.
+
+## `shim/`
+
+Files that are inlined in the generated edge functions. This means that _you must not import these
+files_ from anywhere in the application, because they contain just fragments of a valid program.
+
+## `vendor/`
+
+Third-party dependencies used in the generated edge functions and pulled in ahead of time to avoid a
+build time dependency on any package registry.
+
+This directory is automatically managed by the build script and can be re-generated by running
+`npm run build`.
+
+You should not commit this directory to version control.

edge-runtime/lib/headers.ts

@@ -0,0 +1,26 @@
+// Next 13 supports request header mutations and has the side effect of prepending header values with 'x-middleware-request'
+// as part of invoking NextResponse.next() in the middleware. We need to remove that before sending the response the user
+// as the code that removes it in Next isn't run based on how we handle the middleware
+//
+// Related Next.js code:
+// * https://github.com/vercel/next.js/blob/68d06fe015b28d8f81da52ca107a5f4bd72ab37c/packages/next/server/next-server.ts#L1918-L1928
+// * https://github.com/vercel/next.js/blob/43c9d8940dc42337dd2f7d66aa90e6abf952278e/packages/next/server/web/spec-extension/response.ts#L10-L27
+export function updateModifiedHeaders(requestHeaders: Headers, responseHeaders: Headers) {
+  const overriddenHeaders = responseHeaders.get('x-middleware-override-headers')
+
+  if (!overriddenHeaders) {
+    return
+  }
+
+  const headersToUpdate = overriddenHeaders.split(',').map((header) => header.trim())
+
+  for (const header of headersToUpdate) {
+    const oldHeaderKey = 'x-middleware-request-' + header
+    const headerValue = responseHeaders.get(oldHeaderKey) || ''
+
+    requestHeaders.set(header, headerValue)
+    responseHeaders.delete(oldHeaderKey)
+  }
+
+  responseHeaders.delete('x-middleware-override-headers')
+}

edge-runtime/lib/middleware.ts

@@ -0,0 +1,60 @@
+import type { Context } from '@netlify/edge-functions'
+
+import { ElementHandlers } from '../vendor/deno.land/x/html_rewriter@v0.1.0-pre.17/index.ts'
+
+type NextDataTransform = <T>(data: T) => T
+
+interface ResponseCookies {
+  // This is non-standard that Next.js adds.
+  // https://github.com/vercel/next.js/blob/de08f8b3d31ef45131dad97a7d0e95fa01001167/packages/next/src/compiled/@edge-runtime/cookies/index.js#L158
+  readonly _headers: Headers
+}
+
+interface MiddlewareResponse extends Response {
+  originResponse: Response
+  dataTransforms: NextDataTransform[]
+  elementHandlers: Array<[selector: string, handlers: ElementHandlers]>
+  get cookies(): ResponseCookies
+}
+
+interface MiddlewareRequest {
+  request: Request
+  context: Context
+  originalRequest: Request
+  next(): Promise<MiddlewareResponse>
+  rewrite(destination: string | URL, init?: ResponseInit): Response
+}
+
+export function isMiddlewareRequest(
+  response: Response | MiddlewareRequest,
+): response is MiddlewareRequest {
+  return 'originalRequest' in response
+}
+
+export function isMiddlewareResponse(
+  response: Response | MiddlewareResponse,
+): response is MiddlewareResponse {
+  return 'dataTransforms' in response
+}
+
+export const addMiddlewareHeaders = async (
+  originResponse: Promise<Response> | Response,
+  middlewareResponse: Response,
+) => {
+  // If there are extra headers, we need to add them to the response.
+  if ([...middlewareResponse.headers.keys()].length === 0) {
+    return originResponse
+  }
+
+  // We need to await the response to get the origin headers, then we can add the ones from middleware.
+  const res = await originResponse
+  const response = new Response(res.body, res)
+  middlewareResponse.headers.forEach((value, key) => {
+    if (key === 'set-cookie') {
+      response.headers.append(key, value)
+    } else {
+      response.headers.set(key, value)
+    }
+  })
+  return response
+}

edge-runtime/lib/next-request.ts

@@ -0,0 +1,59 @@
+import type { Context } from '@netlify/edge-functions'
+
+interface I18NConfig {
+  defaultLocale: string
+  localeDetection?: false
+  locales: string[]
+}
+
+export interface RequestData {
+  geo?: {
+    city?: string
+    country?: string
+    region?: string
+    latitude?: string
+    longitude?: string
+    timezone?: string
+  }
+  headers: Record<string, string>
+  ip?: string
+  method: string
+  nextConfig?: {
+    basePath?: string
+    i18n?: I18NConfig | null
+    trailingSlash?: boolean
+  }
+  page?: {
+    name?: string
+    params?: { [key: string]: string }
+  }
+  url: string
+  body?: ReadableStream<Uint8Array>
+}
+
+export const buildNextRequest = (
+  request: Request,
+  context: Context,
+  nextConfig?: RequestData['nextConfig'],
+): RequestData => {
+  const { url, method, body, headers } = request
+  const { country, subdivision, city, latitude, longitude, timezone } = context.geo
+  const geo: RequestData['geo'] = {
+    country: country?.code,
+    region: subdivision?.code,
+    city,
+    latitude: latitude?.toString(),
+    longitude: longitude?.toString(),
+    timezone,
+  }
+
+  return {
+    headers: Object.fromEntries(headers.entries()),
+    geo,
+    url,
+    method,
+    ip: context.ip,
+    body: body ?? undefined,
+    nextConfig,
+  }
+}

edge-runtime/lib/response.ts

@@ -0,0 +1,145 @@
+import type { Context } from '@netlify/edge-functions'
+import { HTMLRewriter } from '../vendor/deno.land/x/html_rewriter@v0.1.0-pre.17/index.ts'
+
+import { updateModifiedHeaders } from './headers.ts'
+import { normalizeDataUrl, relativizeURL } from './util.ts'
+import { addMiddlewareHeaders, isMiddlewareRequest, isMiddlewareResponse } from './middleware.ts'
+
+export interface FetchEventResult {
+  response: Response
+  waitUntil: Promise<any>
+}
+
+export const buildResponse = async ({
+  result,
+  request,
+  context,
+}: {
+  result: FetchEventResult
+  request: Request
+  context: Context
+}) => {
+  updateModifiedHeaders(request.headers, result.response.headers)
+
+  // They've returned the MiddlewareRequest directly, so we'll call `next()` for them.
+  if (isMiddlewareRequest(result.response)) {
+    result.response = await result.response.next()
+  }
+
+  if (isMiddlewareResponse(result.response)) {
+    const { response } = result
+    if (request.method === 'HEAD' || request.method === 'OPTIONS') {
+      return response.originResponse
+    }
+
+    // NextResponse doesn't set cookies onto the originResponse, so we need to copy them over
+    // In some cases, it's possible there are no headers set. See https://github.com/netlify/pod-ecosystem-frameworks/issues/475
+    if (response.cookies._headers?.has('set-cookie')) {
+      response.originResponse.headers.set(
+        'set-cookie',
+        response.cookies._headers.get('set-cookie')!,
+      )
+    }
+
+    // If it's JSON we don't need to use the rewriter, we can just parse it
+    if (response.originResponse.headers.get('content-type')?.includes('application/json')) {
+      const props = await response.originResponse.json()
+      const transformed = response.dataTransforms.reduce((prev, transform) => {
+        return transform(prev)
+      }, props)
+      const body = JSON.stringify(transformed)
+      const headers = new Headers(response.headers)
+      headers.set('content-length', String(body.length))
+
+      return Response.json(transformed, { ...response, headers })
+    }
+
+    // This var will hold the contents of the script tag
+    let buffer = ''
+    // Create an HTMLRewriter that matches the Next data script tag
+    const rewriter = new HTMLRewriter()
+
+    if (response.dataTransforms.length > 0) {
+      rewriter.on('script[id="__NEXT_DATA__"]', {
+        text(textChunk) {
+          // Grab all the chunks in the Next data script tag
+          buffer += textChunk.text
+          if (textChunk.lastInTextNode) {
+            try {
+              // When we have all the data, try to parse it as JSON
+              const data = JSON.parse(buffer.trim())
+              // Apply all of the transforms to the props
+              const props = response.dataTransforms.reduce(
+                (prev, transform) => transform(prev),
+                data.props,
+              )
+              // Replace the data with the transformed props
+              // With `html: true` the input is treated as raw HTML
+              // @see https://developers.cloudflare.com/workers/runtime-apis/html-rewriter/#global-types
+              textChunk.replace(JSON.stringify({ ...data, props }), { html: true })
+            } catch (err) {
+              console.log('Could not parse', err)
+            }
+          } else {
+            // Remove the chunk after we've appended it to the buffer
+            textChunk.remove()
+          }
+        },
+      })
+    }
+
+    if (response.elementHandlers.length > 0) {
+      response.elementHandlers.forEach(([selector, handlers]) => rewriter.on(selector, handlers))
+    }
+    return rewriter.transform(response.originResponse)
+  }
+  const res = new Response(result.response.body, result.response)
+  request.headers.set('x-nf-next-middleware', 'skip')
+
+  const rewrite = res.headers.get('x-middleware-rewrite')
+
+  // Data requests (i.e. requests for /_next/data ) need special handling
+  const isDataReq = request.headers.get('x-nextjs-data')
+
+  if (rewrite) {
+    const rewriteUrl = new URL(rewrite, request.url)
+    const baseUrl = new URL(request.url)
+    const relativeUrl = relativizeURL(rewrite, request.url)
+
+    // Data requests might be rewritten to an external URL
+    // This header tells the client router the redirect target, and if it's external then it will do a full navigation
+    if (isDataReq) {
+      res.headers.set('x-nextjs-rewrite', relativeUrl)
+    }
+    if (rewriteUrl.origin !== baseUrl.origin) {
+      // Netlify Edge Functions don't support proxying to external domains, but Next middleware does
+      const proxied = fetch(new Request(rewriteUrl.toString(), request))
+      return addMiddlewareHeaders(proxied, res)
+    }
+    res.headers.set('x-middleware-rewrite', relativeUrl)
+
+    request.headers.set('x-original-path', new URL(request.url, `http://n`).pathname)
+    request.headers.set('x-middleware-rewrite', rewrite)
+
+    return addMiddlewareHeaders(context.rewrite(rewrite), res)
+  }
+
+  const redirect = res.headers.get('Location')
+
+  // Data requests shouldn't automatically redirect in the browser (they might be HTML pages): they're handled by the router
+  if (redirect && isDataReq) {
+    res.headers.delete('location')
+    res.headers.set('x-nextjs-redirect', relativizeURL(redirect, request.url))
+  }
+
+  const nextRedirect = res.headers.get('x-nextjs-redirect')
+
+  if (nextRedirect && isDataReq) {
+    res.headers.set('x-nextjs-redirect', normalizeDataUrl(nextRedirect))
+  }
+
+  if (res.headers.get('x-middleware-next') === '1') {
+    return addMiddlewareHeaders(context.next(), res)
+  }
+  return res
+}

edge-runtime/lib/util.ts

@@ -0,0 +1,26 @@
+// If the redirect is a data URL, we need to normalize it.
+// https://github.com/vercel/next.js/blob/25e0988e7c9033cb1503cbe0c62ba5de2e97849c/packages/next/src/shared/lib/router/utils/get-next-pathname-info.ts#L69-L76
+export function normalizeDataUrl(redirect: string) {
+  if (redirect.startsWith('/_next/data/') && redirect.includes('.json')) {
+    const paths = redirect
+      .replace(/^\/_next\/data\//, '')
+      .replace(/\.json/, '')
+      .split('/')
+
+    redirect = paths[1] !== 'index' ? `/${paths.slice(1).join('/')}` : '/'
+  }
+
+  return redirect
+}
+
+/**
+ * This is how Next handles rewritten URLs.
+ */
+export function relativizeURL(url: string | string, base: string | URL) {
+  const baseURL = typeof base === 'string' ? new URL(base) : base
+  const relative = new URL(url, base)
+  const origin = `${baseURL.protocol}//${baseURL.host}`
+  return `${relative.protocol}//${relative.host}` === origin
+    ? relative.toString().replace(origin, '')
+    : relative.toString()
+}

edge-runtime/middleware.ts

@@ -1,22 +1,40 @@
-import type { Config, Context } from '@netlify/edge-functions'
+import type { Context } from '@netlify/edge-functions'
 
-// import nextConfig from '../edge-shared/nextConfig.json' assert { type: 'json' }
+import { buildNextRequest, RequestData } from './lib/next-request.ts'
+import { buildResponse } from './lib/response.ts'
+import { FetchEventResult } from './lib/response.ts'
 
-export async function handleMiddleware(req: Request, context: Context, nextHandler: () => any) {
+type NextHandler = (params: { request: RequestData }) => Promise<FetchEventResult>
+
+/**
+ * Runs a Next.js middleware as a Netlify Edge Function. It translates a web
+ * platform Request into a NextRequest instance on the way in, and translates
+ * a NextResponse into a web platform Response on the way out.
+ *
+ * @param request Incoming request
+ * @param context Netlify-specific context object
+ * @param nextHandler Next.js middleware handler
+ */
+export async function handleMiddleware(
+  request: Request,
+  context: Context,
+  nextHandler: NextHandler,
+) {
   // Don't run in dev
-  if (Deno.env.get('NETLIFY_DEV')) {
+  if (Netlify.env.has('NETLIFY_DEV')) {
     return
   }
 
-  const url = new URL(req.url)
-  console.log('from handleMiddleware', url)
-  // const req = new IncomingMessage(internalEvent);
-  // const res = new ServerlessResponse({
-  //   method: req.method ?? "GET",
-  //   headers: {},
-  // });
-  //
-  // const request = buildNextRequest(req, context, nextConfig)
+  const nextRequest = buildNextRequest(request, context)
+
+  try {
+    const result = await nextHandler({ request: nextRequest })
+    const response = await buildResponse({ result, request: request, context })
 
-  return Response.json({ success: true })
+    return response
+  } catch (error) {
+    console.error(error)
+
+    return new Response(error.message, { status: 500 })
+  }
 }

edge-runtime/shim/index.js

@@ -0,0 +1,8 @@
+// NOTE: This is a fragment of a JavaScript program that will be inlined with
+// a Webpack bundle. You should not import this file from anywhere in the
+// application.
+import { AsyncLocalStorage } from 'node:async_hooks'
+
+globalThis.AsyncLocalStorage = AsyncLocalStorage
+
+var _ENTRIES = {}

edge-runtime/vendor.ts

@@ -0,0 +1,18 @@
+// NOTE: This file contains a list of the third-party Deno dependencies we use.
+// It acts as a seed that populates the `vendor/` directory and should not be
+// imported directly.
+
+import 'https://deno.land/std@0.175.0/encoding/base64.ts'
+import 'https://deno.land/std@0.175.0/http/cookie.ts'
+import 'https://deno.land/std@0.175.0/node/buffer.ts'
+import 'https://deno.land/std@0.175.0/node/events.ts'
+import 'https://deno.land/std@0.175.0/node/async_hooks.ts'
+import 'https://deno.land/std@0.175.0/node/assert.ts'
+import 'https://deno.land/std@0.175.0/node/util.ts'
+import 'https://deno.land/std@0.175.0/path/mod.ts'
+
+import 'https://deno.land/x/path_to_regexp@v6.2.1/index.ts'
+import 'https://deno.land/x/html_rewriter@v0.1.0-pre.17/index.ts'
+
+import 'https://esm.sh/v91/next@12.2.5/deno/dist/server/web/spec-extension/request.js'
+import 'https://esm.sh/v91/next@12.2.5/deno/dist/server/web/spec-extension/response.js'

src/build/functions/edge.ts

@@ -1,7 +1,8 @@
 import type { NetlifyPluginOptions } from '@netlify/build'
 import type { EdgeFunctionDefinition as NextDefinition } from 'next/dist/build/webpack/plugins/middleware-plugin.js'
 import { cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
-import { dirname, join, relative, resolve } from 'node:path'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
 import { getMiddlewareManifest } from '../config.js'
 import {
   EDGE_FUNCTIONS_DIR,
@@ -12,79 +13,60 @@ import {
 } from '../constants.js'
 
 interface NetlifyManifest {
-  version: 1
+  version: number
   functions: NetlifyDefinition[]
 }
 
-type NetlifyDefinition =
-  | {
-      function: string
-      name?: string
-      path: string
-      cache?: 'manual'
-      generator: string
-    }
-  | {
-      function: string
-      name?: string
-      pattern: string
-      cache?: 'manual'
-      generator: string
-    }
-
-const getHandlerName = ({ name }: NextDefinition) =>
-  EDGE_HANDLER_NAME.replace('{{name}}', name.replace(/\W/g, '-'))
-
-const buildHandlerDefinitions = (
-  { name: definitionName, matchers, page }: NextDefinition,
-  handlerName: string,
-): NetlifyDefinition[] => {
-  return definitionName === 'middleware'
-    ? [
-        {
-          function: handlerName,
-          name: 'Next.js Middleware Handler',
-          path: '/*',
-          generator: `${PLUGIN_NAME}@${PLUGIN_VERSION}`,
-        } as any,
-      ]
-    : matchers.map((matcher) => ({
-        function: handlerName,
-        name: `Next.js Edge Handler: ${page}`,
-        pattern: matcher.regexp,
-        cache: 'manual',
-        generator: `${PLUGIN_NAME}@${PLUGIN_VERSION}`,
-      }))
+interface NetlifyDefinition {
+  function: string
+  name: string
+  pattern: string
+  cache?: 'manual'
+  generator: string
 }
 
-const copyHandlerDependencies = async (
-  { name: definitionName, files }: NextDefinition,
-  handlerName: string,
-) => {
+const writeEdgeManifest = async (manifest: NetlifyManifest) => {
+  await mkdir(resolve(EDGE_FUNCTIONS_DIR), { recursive: true })
+  await writeFile(resolve(EDGE_FUNCTIONS_DIR, 'manifest.json'), JSON.stringify(manifest, null, 2))
+}
+
+const writeHandlerFile = async ({ name }: NextDefinition) => {
+  const handlerName = getHandlerName({ name })
+
+  await cp(
+    join(PLUGIN_DIR, 'edge-runtime'),
+    resolve(EDGE_FUNCTIONS_DIR, handlerName, 'edge-runtime'),
+    { recursive: true },
+  )
+  await writeFile(
+    resolve(EDGE_FUNCTIONS_DIR, handlerName, `${handlerName}.js`),
+    `
+    import {handleMiddleware} from './edge-runtime/middleware.ts';
+    import handler from './server/${name}.js';
+    export default (req, context) => handleMiddleware(req, context, handler);
+    `,
+  )
+}
+
+const copyHandlerDependencies = async ({ name, files }: NextDefinition) => {
+  const edgeRuntimePath = join(PLUGIN_DIR, 'edge-runtime')
+  const srcDir = resolve('.next/standalone/.next')
+  const shimPath = resolve(edgeRuntimePath, 'shim/index.js')
+  const shim = await readFile(shimPath, 'utf8')
+  const imports = `import './edge-runtime-webpack.js';`
+  const exports = `export default _ENTRIES["middleware_${name}"].default;`
+
   await Promise.all(
     files.map(async (file) => {
-      const srcDir = join(process.cwd(), '.next/standalone/.next')
-      const destDir = join(process.cwd(), EDGE_FUNCTIONS_DIR, handlerName)
+      const destDir = resolve(EDGE_FUNCTIONS_DIR, getHandlerName({ name }))
 
-      if (file === `server/${definitionName}.js`) {
+      if (file === `server/${name}.js`) {
         const entrypoint = await readFile(join(srcDir, file), 'utf8')
-        // const exports = ``
-        const exports = `
-        export default _ENTRIES["middleware_${definitionName}"].default;
-        // export default () => {
-
-        // console.log('here', _ENTRIES)
-        // }
-        `
-        await mkdir(dirname(join(destDir, file)), { recursive: true })
-        await writeFile(
-          join(destDir, file),
-          `
-          import './edge-runtime-webpack.js';
+        const parts = [shim, imports, entrypoint, exports]
 
+        await mkdir(dirname(join(destDir, file)), { recursive: true })
+        await writeFile(join(destDir, file), parts.join('\n;'))
 
-          var _ENTRIES = {};\n`.concat(entrypoint, '\n', exports),
-        )
         return
       }
 
@@ -93,29 +75,21 @@ const copyHandlerDependencies = async (
   )
 }
 
-const writeHandlerFile = async ({ name: definitionName }: NextDefinition, handlerName: string) => {
-  const handlerFile = resolve(EDGE_FUNCTIONS_DIR, handlerName, `${handlerName}.js`)
-  const rel = relative(handlerFile, join(PLUGIN_DIR, 'dist/run/handlers/middleware.js'))
-  await cp(
-    join(PLUGIN_DIR, 'edge-runtime'),
-    resolve(EDGE_FUNCTIONS_DIR, handlerName, 'edge-runtime'),
-    {
-      recursive: true,
-    },
-  )
-  await writeFile(
-    resolve(EDGE_FUNCTIONS_DIR, handlerName, `${handlerName}.js`),
-    `import {handleMiddleware} from './edge-runtime/middleware.ts';
-    import handler from './server/${definitionName}.js';
-    export default (req, context) => handleMiddleware(req, context, handler);
-    export const config = {path: "/*"}`,
-  )
+const createEdgeHandler = async (definition: NextDefinition): Promise<void> => {
+  await copyHandlerDependencies(definition)
+  await writeHandlerFile(definition)
 }
 
-const writeEdgeManifest = async (manifest: NetlifyManifest) => {
-  await mkdir(resolve(EDGE_FUNCTIONS_DIR), { recursive: true })
-  await writeFile(resolve(EDGE_FUNCTIONS_DIR, 'manifest.json'), JSON.stringify(manifest, null, 2))
-}
+const getHandlerName = ({ name }: Pick<NextDefinition, 'name'>): string =>
+  `${EDGE_HANDLER_NAME}-${name.replace(/\W/g, '-')}`
+
+const buildHandlerDefinition = ({ name, matchers, page }: NextDefinition): NetlifyDefinition => ({
+  function: getHandlerName({ name }),
+  name: name === 'middleware' ? 'Next.js Middleware Handler' : `Next.js Edge Handler: ${page}`,
+  pattern: matchers[0].regexp,
+  cache: name === 'middleware' ? undefined : 'manual',
+  generator: `${PLUGIN_NAME}@${PLUGIN_VERSION}`,
+})
 
 export const createEdgeHandlers = async ({
   constants,
@@ -127,21 +101,12 @@ export const createEdgeHandlers = async ({
     ...Object.values(nextManifest.middleware),
     // ...Object.values(nextManifest.functions)
   ]
-  const netlifyManifest: NetlifyManifest = {
+  await Promise.all(nextDefinitions.map(createEdgeHandler))
+
+  const netlifyDefinitions = nextDefinitions.map(buildHandlerDefinition)
+  const netlifyManifest = {
     version: 1,
-    functions: await nextDefinitions.reduce(
-      async (netlifyDefinitions: Promise<NetlifyDefinition[]>, nextDefinition: NextDefinition) => {
-        const handlerName = getHandlerName(nextDefinition)
-        await copyHandlerDependencies(nextDefinition, handlerName)
-        await writeHandlerFile(nextDefinition, handlerName)
-        return [
-          ...(await netlifyDefinitions),
-          ...buildHandlerDefinitions(nextDefinition, handlerName),
-        ]
-      },
-      Promise.resolve([]),
-    ),
+    functions: netlifyDefinitions,
   }
-
   await writeEdgeManifest(netlifyManifest)
 }

tests/e2e/edge-middleware.test.ts

@@ -0,0 +1,21 @@
+import { expect, test } from '@playwright/test'
+import { createE2EFixture } from '../utils/create-e2e-fixture.js'
+
+let ctx: Awaited<ReturnType<typeof createE2EFixture>>
+
+test.beforeAll(async () => {
+  ctx = await createE2EFixture('middleware')
+})
+
+test.afterAll(async ({}, testInfo) => {
+  await ctx?.cleanup?.(!!testInfo.errors.length)
+})
+
+test('Runs edge middleware', async ({ page }) => {
+  await page.goto(`${ctx.url}/test/redirect`)
+
+  await expect(page).toHaveTitle('Simple Next App')
+
+  const h1 = page.locator('h1')
+  await expect(h1).toHaveText('Other')
+})

tests/fixtures/middleware/app/other/page.js

@@ -1,4 +1,4 @@
-export default function Home() {
+export default function Page() {
   return (
     <main>
       <h1>Other</h1>

tests/fixtures/middleware/app/test/next/page.js

@@ -0,0 +1,12 @@
+import { headers } from 'next/headers'
+
+export default function Page() {
+  const headersList = headers()
+  const message = headersList.get('x-hello-from-middleware-req')
+
+  return (
+    <main>
+      <h1>Message from middleware: {message}</h1>
+    </main>
+  )
+}

tests/fixtures/middleware/app/test/redirect/page.js

@@ -0,0 +1,7 @@
+export default function Redirect() {
+  return (
+    <main>
+      <h1>If middleware works, we shoudn't get here</h1>
+    </main>
+  )
+}

tests/fixtures/middleware/app/test/rewrite/page.js

@@ -0,0 +1,7 @@
+export default function Rewrite() {
+  return (
+    <main>
+      <h1>If middleware works, we shoudn't get here</h1>
+    </main>
+  )
+}

tests/fixtures/middleware/middleware.ts

@@ -1,10 +1,43 @@
-import { NextResponse } from 'next/server'
 import type { NextRequest } from 'next/server'
+import { NextResponse } from 'next/server'
 
 export function middleware(request: NextRequest) {
-  return NextResponse.redirect(new URL('/other', request.url))
+  let response: NextResponse
+
+  const requestHeaders = new Headers(request.headers)
+  requestHeaders.set('x-hello-from-middleware-req', 'hello')
+
+  if (request.nextUrl.pathname.startsWith('/test/next')) {
+    response = NextResponse.next({
+      request: {
+        headers: requestHeaders,
+      },
+    })
+  } else if (request.nextUrl.pathname.startsWith('/test/redirect')) {
+    response = NextResponse.redirect(new URL('/other', request.url))
+  } else if (request.nextUrl.pathname.startsWith('/test/rewrite-internal')) {
+    response = NextResponse.rewrite(new URL('/rewrite-target', request.url), {
+      request: {
+        headers: requestHeaders,
+      },
+    })
+  } else if (request.nextUrl.pathname.startsWith('/test/rewrite-external')) {
+    const requestURL = new URL(request.url)
+    const externalURL = requestURL.searchParams.get('external-url') as string
+
+    response = NextResponse.rewrite(externalURL, {
+      request: {
+        headers: requestHeaders,
+      },
+    })
+  } else {
+    response = NextResponse.json({ error: 'Error' }, { status: 500 })
+  }
+
+  response.headers.set('x-hello-from-middleware-res', 'hello')
+  return response
 }
 
 export const config = {
-  matcher: '/test',
+  matcher: '/test/:path*',
 }

tests/integration/edge-handler.test.ts

@@ -7,6 +7,7 @@ import {
   type FixtureTestContext,
 } from '../utils/fixture.js'
 import { generateRandomObjectID, startMockBlobStore } from '../utils/helpers.js'
+import { LocalServer } from '../utils/local-server.js'
 
 beforeEach<FixtureTestContext>(async (ctx) => {
   // set for each test a new deployID and siteID
@@ -17,11 +18,79 @@ beforeEach<FixtureTestContext>(async (ctx) => {
   await startMockBlobStore(ctx)
 })
 
-test<FixtureTestContext>('simple test if everything works', async (ctx) => {
+test<FixtureTestContext>('should add request/response headers', async (ctx) => {
   await createFixture('middleware', ctx)
   await runPlugin(ctx)
 
-  const response1 = await invokeEdgeFunction(ctx)
+  const origin = await LocalServer.run(async (req, res) => {
+    expect(req.url).toBe('/test/next')
+    expect(req.headers['x-hello-from-middleware-req']).toBe('hello')
+
+    res.write('Hello from origin!')
+    res.end()
+  })
+
+  ctx.cleanup?.push(() => origin.stop())
+
+  const response1 = await invokeEdgeFunction(ctx, {
+    functions: ['___netlify-edge-handler-middleware'],
+    origin,
+    url: '/test/next',
+  })
+
+  expect(await response1.text()).toBe('Hello from origin!')
+  expect(response1.status).toBe(200)
+  expect(response1.headers.get('x-hello-from-middleware-res'), 'added a response header').toEqual(
+    'hello',
+  )
+  expect(origin.calls).toBe(1)
+})
+
+test<FixtureTestContext>('should return a redirect response', async (ctx) => {
+  await createFixture('middleware', ctx)
+  await runPlugin(ctx)
+
+  const origin = new LocalServer()
+  const response1 = await invokeEdgeFunction(ctx, {
+    functions: ['___netlify-edge-handler-middleware'],
+    origin,
+    redirect: 'manual',
+    url: '/test/redirect',
+  })
+
+  ctx.cleanup?.push(() => origin.stop())
+
+  expect(response1.headers.get('location'), 'added a location header').toBeTypeOf('string')
+  expect(
+    new URL(response1.headers.get('location') as string).pathname,
+    'redirected to the correct path',
+  ).toEqual('/other')
+  expect(origin.calls).toBe(0)
+})
+
+test<FixtureTestContext>('should rewrite to an external URL', async (ctx) => {
+  await createFixture('middleware', ctx)
+  await runPlugin(ctx)
+
+  const external = await LocalServer.run(async (req, res) => {
+    expect(req.url).toBe('/some-path')
+
+    res.write('Hello from external host!')
+    res.end()
+  })
+  ctx.cleanup?.push(() => external.stop())
+
+  const origin = new LocalServer()
+  ctx.cleanup?.push(() => origin.stop())
+
+  const response1 = await invokeEdgeFunction(ctx, {
+    functions: ['___netlify-edge-handler-middleware'],
+    origin,
+    url: `/test/rewrite-external?external-url=http://localhost:${external.port}/some-path`,
+  })
+
+  expect(await response1.text()).toBe('Hello from external host!')
   expect(response1.status).toBe(200)
-  expect(await response1.json()).toEqual({ success: true })
+  expect(external.calls).toBe(1)
+  expect(origin.calls).toBe(0)
 })

tests/prepare.mjs

@@ -14,37 +14,40 @@ const fixturesDir = fileURLToPath(new URL(`./fixtures`, import.meta.url))
 
 const limit = pLimit(Math.max(2, cpus().length))
 await Promise.all(
-  readdirSync(fixturesDir).map((fixture) =>
-    limit(async () => {
-      console.log(`[${fixture}] Preparing fixture`)
-      await rm(join(fixturesDir, fixture, '.next'), { recursive: true, force: true })
-      const cwd = join(fixturesDir, fixture)
+  readdirSync(fixturesDir)
+    // Ignoring things like `.DS_Store`.
+    .filter((fixture) => !fixture.startsWith('.'))
+    .map((fixture) =>
+      limit(async () => {
+        console.log(`[${fixture}] Preparing fixture`)
+        await rm(join(fixturesDir, fixture, '.next'), { recursive: true, force: true })
+        const cwd = join(fixturesDir, fixture)
 
-      // npm is the default
-      let cmd = `npm install --no-audit --progress=false --prefer-offline`
+        // npm is the default
+        let cmd = `npm install --no-audit --progress=false --prefer-offline`
 
-      if (existsSync(join(cwd, 'pnpm-lock.yaml'))) {
-        cmd = `pnpm install --reporter=silent`
-      }
+        if (existsSync(join(cwd, 'pnpm-lock.yaml'))) {
+          cmd = `pnpm install --reporter=silent`
+        }
 
-      const addPrefix = new Transform({
-        transform(chunk, encoding, callback) {
-          this.push(chunk.toString().replace(/\n/gm, `\n[${fixture}] `))
-          callback()
-        },
-      })
+        const addPrefix = new Transform({
+          transform(chunk, encoding, callback) {
+            this.push(chunk.toString().replace(/\n/gm, `\n[${fixture}] `))
+            callback()
+          },
+        })
 
-      const output = execaCommand(cmd, {
-        cwd,
-        stdio: 'pipe',
-        env: { ...process.env, FORCE_COLOR: '1' },
-      })
-      if (process.env.DEBUG) {
-        output.stdout?.pipe(addPrefix).pipe(process.stdout)
-      }
-      output.stderr?.pipe(addPrefix).pipe(process.stderr)
+        const output = execaCommand(cmd, {
+          cwd,
+          stdio: 'pipe',
+          env: { ...process.env, FORCE_COLOR: '1' },
+        })
+        if (process.env.DEBUG) {
+          output.stdout?.pipe(addPrefix).pipe(process.stdout)
+        }
+        output.stderr?.pipe(addPrefix).pipe(process.stderr)
 
-      return output
-    }),
-  ),
+        return output
+      }),
+    ),
 )

tests/test-setup.ts

@@ -1,10 +1,9 @@
-import { afterEach, vi } from 'vitest'
+import { afterEach } from 'vitest'
 import { FixtureTestContext } from './utils/fixture'
-import { fsCpHelper, rmHelper } from './utils/fs-helper.js'
 
 // cleanup after each test as a fallback if someone forgot to call it
 afterEach<FixtureTestContext>(async ({ cleanup }) => {
-  if (typeof cleanup === 'function') {
-    await cleanup()
-  }
+  const jobs = (cleanup ?? []).map((job) => job())
+
+  await Promise.all(jobs)
 })

tests/utils/create-e2e-fixture.ts

@@ -4,6 +4,7 @@ import { exec } from 'node:child_process'
 import { copyFile, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { dirname, join } from 'node:path'
+import { env } from 'node:process'
 import { fileURLToPath } from 'node:url'
 import { cpus } from 'os'
 import pLimit from 'p-limit'
@@ -33,33 +34,41 @@ export const createE2EFixture = async (
   let deployID: string
   let logs: string
   const _cleanup = (failure: boolean = false) => {
+    if (env.E2E_PERSIST) {
+      console.log(
+        `💾 Fixture and deployed site have been persisted. To clean up automatically, run tests without the 'E2E_PERSIST' environment variable.`,
+      )
+
+      return
+    }
+
     if (!failure) {
       return cleanup(cwd, deployID)
     }
-    console.log('\n\n\n🪵  Deploy Logs:')
+    console.log('\n\n\n🪵  Deploy logs:')
     console.log(logs)
     // on failures we don't delete the deploy
   }
   try {
     const [packageName] = await Promise.all([buildAndPackRuntime(cwd), copyFixture(fixture, cwd)])
     await installRuntime(packageName, cwd, config.packageManger || 'npm')
     const result = await deploySite(cwd)
-    console.log(`🌍 Deployed Site is live under: ${result.url}`)
+    console.log(`🌍 Deployed site is live: ${result.url}`)
     deployID = result.deployID
     logs = result.logs
     return { cwd, cleanup: _cleanup, deployID: result.deployID, url: result.url }
   } catch (error) {
-    await _cleanup()
+    await _cleanup(true)
     throw error
   }
 }
 
 /** Copies a fixture folder to a destination */
 async function copyFixture(fixtureName: string, dest: string): Promise<void> {
-  console.log(`🔨  Build Runtime...`)
+  console.log(`🔨 Building runtime...`)
   await execaCommand('npm run build')
 
-  console.log(`📂  Copy Fixture to temp directory...`)
+  console.log(`📂 Copying fixture to '${dest}'...`)
   const src = fileURLToPath(new URL(`../fixtures/${fixtureName}`, import.meta.url))
   const files = await fg.glob('**/*', {
     ignore: ['node_modules'],
@@ -80,7 +89,8 @@ async function copyFixture(fixtureName: string, dest: string): Promise<void> {
 
 /** Creates a tarball of the packed npm package at the provided destination */
 async function buildAndPackRuntime(dest: string): Promise<string> {
-  console.log(`📦  Creating tarball with 'npm pack'...`)
+  console.log(`📦 Creating tarball with 'npm pack'...`)
+
   const { stdout } = await execaCommand(
     // for the e2e tests we don't need to clean up the package.json. That just creates issues with concurrency
     `npm pack --json --ignore-scripts --pack-destination ${dest}`,
@@ -106,7 +116,8 @@ async function installRuntime(
   cwd: string,
   packageManger: PackageManager,
 ): Promise<void> {
-  console.log(`⚙️   Installing runtime ${packageName}...`)
+  console.log(`🐣 Installing runtime from '${packageName}'...`)
+
   let command: string = `npm install --ignore-scripts --no-audit --progress=false ${packageName}`
 
   switch (packageManger) {
@@ -129,7 +140,8 @@ async function installRuntime(
 }
 
 async function deploySite(cwd: string): Promise<DeployResult> {
-  console.log(`🚀  Building and Deploying Site...`)
+  console.log(`🚀 Building and deploying site...`)
+
   const outputFile = 'deploy-output.txt'
   const cmd = `ntl deploy --build --site ${SITE_ID}`
 
@@ -144,18 +156,21 @@ async function deploySite(cwd: string): Promise<DeployResult> {
   return { url, deployID, logs: output }
 }
 
-export async function deleteDeploy(deploy_id?: string): Promise<void> {
-  if (deploy_id) {
-    console.log(`♻️  Delete Deploy ${deploy_id}...`)
-    const cmd = `ntl api deleteDeploy --data='{"deploy_id":"${deploy_id}"}'`
-    // execa mangles around with the json so let's use exec here
-    return new Promise<void>((resolve, reject) =>
-      exec(cmd, (err) => (err ? reject(err) : resolve())),
-    )
+export async function deleteDeploy(deployID?: string): Promise<void> {
+  if (!deployID) {
+    return
   }
+
+  const cmd = `ntl api deleteDeploy --data='{"deploy_id":"${deployID}"}'`
+  // execa mangles around with the json so let's use exec here
+  return new Promise<void>((resolve, reject) => exec(cmd, (err) => (err ? reject(err) : resolve())))
 }
 
 async function cleanup(dest: string, deployId?: string): Promise<void> {
-  console.log(`🗑️  Starting Cleanup...`)
+  console.log(`🧹 Cleaning up fixture and deployed site...`)
+  console.log(
+    `  - To persist them for further inspection, run the tests with the 'E2E_PERSIST' environment variable`,
+  )
+
   await Promise.allSettled([deleteDeploy(deployId), rm(dest, { recursive: true, force: true })])
 }

tests/utils/fixture.ts

@@ -1,33 +1,29 @@
 import { BlobsServer, type getStore } from '@netlify/blobs'
-import { TestContext, assert, expect, vi } from 'vitest'
+import { TestContext, assert, vi } from 'vitest'
 
-import {
-  runCoreSteps,
-  type NetlifyPluginConstants,
-  type NetlifyPluginOptions,
-} from '@netlify/build'
+import { type NetlifyPluginConstants, type NetlifyPluginOptions } from '@netlify/build'
 import { bundle, serve } from '@netlify/edge-bundler'
 import type { LambdaResponse } from '@netlify/serverless-functions-api/dist/lambda/response.js'
 import { zipFunctions } from '@netlify/zip-it-and-ship-it'
 import { execaCommand } from 'execa'
+import { glob } from 'fast-glob'
 import getPort from 'get-port'
 import { execute } from 'lambda-local'
 import { existsSync } from 'node:fs'
-import { cp, mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises'
+import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { basename, dirname, join, parse, relative, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { v4 } from 'uuid'
 import {
   BLOB_DIR,
   EDGE_FUNCTIONS_DIR,
   EDGE_HANDLER_NAME,
   SERVER_FUNCTIONS_DIR,
   SERVER_HANDLER_NAME,
 } from '../../src/build/constants.js'
+import { LocalServer } from './local-server.js'
 import { streamToString } from './stream-to-string.js'
-import { inspect } from 'node:util'
-import { v4 } from 'uuid'
-import { glob } from 'fast-glob'
 
 export interface FixtureTestContext extends TestContext {
   cwd: string
@@ -38,7 +34,7 @@ export interface FixtureTestContext extends TestContext {
   blobStore: ReturnType<typeof getStore>
   functionDist: string
   edgeFunctionPort: number
-  cleanup?: () => Promise<void>
+  cleanup?: (() => Promise<void>)[]
 }
 
 export const BLOB_TOKEN = 'secret-token'
@@ -63,13 +59,15 @@ function installDependencies(cwd: string) {
 export const createFixture = async (fixture: string, ctx: FixtureTestContext) => {
   ctx.cwd = await mkdtemp(join(tmpdir(), 'netlify-next-runtime-'))
   vi.spyOn(process, 'cwd').mockReturnValue(ctx.cwd)
-  ctx.cleanup = async () => {
-    try {
-      await rm(ctx.cwd, { recursive: true, force: true })
-    } catch {
-      // noop
-    }
-  }
+  ctx.cleanup = [
+    async () => {
+      try {
+        await rm(ctx.cwd, { recursive: true, force: true })
+      } catch {
+        // noop
+      }
+    },
+  ]
 
   try {
     const src = fileURLToPath(new URL(`../fixtures/${fixture}`, import.meta.url))
@@ -94,13 +92,15 @@ export const createFixture = async (fixture: string, ctx: FixtureTestContext) =>
 export const createFsFixture = async (fixture: Record<string, string>, ctx: FixtureTestContext) => {
   ctx.cwd = await mkdtemp(join(tmpdir(), 'netlify-next-runtime-'))
   vi.spyOn(process, 'cwd').mockReturnValue(ctx.cwd)
-  ctx.cleanup = async () => {
-    try {
-      await rm(ctx.cwd, { recursive: true, force: true })
-    } catch {
-      // noop
-    }
-  }
+  ctx.cleanup = [
+    async () => {
+      try {
+        await rm(ctx.cwd, { recursive: true, force: true })
+      } catch {
+        // noop
+      }
+    },
+  ]
 
   try {
     await Promise.all(
@@ -225,7 +225,6 @@ export async function runPlugin(
         path: join(dist, 'source/root', relative(ctx.cwd, fn.path)),
       })),
     )
-    expect(success).toBe(true)
   }
 
   await Promise.all([bundleEdgeFunctions(), bundleFunctions(), uploadBlobs(ctx)])
@@ -327,25 +326,46 @@ export async function invokeFunction(
 export async function invokeEdgeFunction(
   ctx: FixtureTestContext,
   options: {
+    /**
+     * The local server to use as the mock origin
+     */
+    origin?: LocalServer
+
+    /**
+     * The relative path for the request
+     * @default '/'
+     */
+    url?: string
+
+    /**
+     * Whether to follow redirects
+     */
+    redirect?: RequestInit['redirect']
+
     /** Array of functions to invoke */
     functions?: string[]
   } = {},
 ): Promise<Response> {
+  const passthroughHost = options.origin ? `localhost:${options.origin.port}` : ''
   const functionsToInvoke = options.functions || [EDGE_HANDLER_NAME]
-  return await fetch(`http://0.0.0.0:${ctx.edgeFunctionPort}/`, {
+
+  return await fetch(`http://0.0.0.0:${ctx.edgeFunctionPort}${options.url ?? '/'}`, {
+    redirect: options.redirect,
+
     // Checkout the stargate headers: https://github.com/netlify/stargate/blob/dc8adfb6e91fa0a2fb00c0cba06e4e2f9e5d4e4d/proxy/deno/edge.go#L1142-L1170
     headers: {
       'x-nf-edge-functions': functionsToInvoke.join(','),
       'x-nf-deploy-id': ctx.deployID,
-      'X-NF-Site-Info': Buffer.from(
+      'x-nf-site-info': Buffer.from(
         JSON.stringify({ id: ctx.siteID, name: 'Test Site', url: 'https://example.com' }),
       ).toString('base64'),
       'x-nf-blobs-info': Buffer.from(
         JSON.stringify({ url: `http://${ctx.blobStoreHost}`, token: BLOB_TOKEN }),
       ).toString('base64'),
-      'x-NF-passthrough': 'passthrough',
-      // 'x-NF-passthrough-host': 'passthrough', // TODO: add lambda local url
-      'X-NF-Request-ID': v4(),
+      'x-nf-passthrough': 'passthrough',
+      'x-nf-passthrough-host': passthroughHost,
+      'x-nf-passthrough-proto': 'http:',
+      'x-nf-request-id': v4(),
     },
   })
 }

tests/utils/local-server.ts

@@ -0,0 +1,77 @@
+import http from 'node:http'
+import { AddressInfo } from 'node:net'
+
+export type LocalServerHandler = (
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+) => Promise<void>
+
+/**
+ * A basic HTTP server to use in tests. It accepts a handler that responds to
+ * all requests and keeps track of how many times it's called.
+ */
+export class LocalServer {
+  calls: number
+  port: number
+  running: boolean
+  server: http.Server
+
+  constructor(handler?: LocalServerHandler, port?: number) {
+    this.calls = 0
+    this.port = port ?? 0
+    this.running = false
+    this.server = http.createServer(async (req: http.IncomingMessage, res: http.ServerResponse) => {
+      this.calls++
+
+      if (handler !== undefined) {
+        await handler(req, res)
+      }
+    })
+  }
+
+  static async run(handler?: LocalServerHandler, port?: number) {
+    const server = new LocalServer(handler, port)
+
+    await server.start()
+
+    return server
+  }
+
+  async start() {
+    return new Promise<AddressInfo>((resolve, reject) => {
+      this.server.listen(this.port, () => {
+        this.running = true
+
+        const address = this.server.address()
+
+        if (!address || typeof address === 'string') {
+          return reject(new Error('Server cannot be started on a pipe or Unix socket'))
+        }
+
+        this.port = address.port
+
+        resolve(address)
+      })
+    })
+  }
+
+  async stop() {
+    if (!this.running) {
+      return
+    }
+
+    return new Promise<void>((resolve, reject) => {
+      this.server.close((error?: NodeJS.ErrnoException) => {
+        if (error) {
+          return reject(error)
+        }
+
+        resolve()
+      })
+    })
+  }
+
+  get url() {
+    return `http://0.0.0.0:${this.port}`
+  }
+}

tools/build.js

@@ -1,4 +1,6 @@
+import { resolve } from 'node:path'
 import { build, context } from 'esbuild'
+import { execaCommand } from 'execa'
 import glob from 'fast-glob'
 import { rm } from 'node:fs/promises'
 
@@ -58,10 +60,30 @@ async function bundle(entryPoints, format, watch) {
   })
 }
 
+async function vendorDeno() {
+  const vendorSource = resolve('edge-runtime/vendor.ts')
+  const vendorDest = resolve('edge-runtime/vendor')
+
+  try {
+    await execaCommand('deno --version')
+  } catch {
+    throw new Error('Could not check the version of Deno. Is it installed on your system?')
+  }
+
+  console.log(`🧹 Deleting '${vendorDest}'...`)
+
+  await rm(vendorDest, { force: true, recursive: true })
+
+  console.log(`📦 Vendoring Deno modules into '${vendorDest}'...`)
+
+  await execaCommand(`deno vendor ${vendorSource} --output=${vendorDest}`)
+}
+
 const args = new Set(process.argv.slice(2))
 const watch = args.has('--watch') || args.has('-w')
 
 await Promise.all([
+  vendorDeno(),
   bundle(entryPointsESM, 'esm', watch),
   ...entryPointsCJS.map((entry) => bundle([entry], 'cjs', watch)),
 ])