@mcansh/react-router-fastify 5.0.0

package/dist/vite.mjs

@@ -0,0 +1,181 @@
+import { t as importSsrModule } from "./vite-runtime-Cuj_Fjkd.mjs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+//#region src/vite.ts
+const adapterPackageNames = ["@mcansh/react-router-fastify", "@mcansh/remix-fastify"];
+/**
+* Vite plugin that lets `react-router dev` serve through a Fastify app.
+*
+* Vite continues to handle its internal client/HMR/module middleware first.
+* Fastify receives the remaining requests, including the React Router catch-all
+* installed by `fastifyReactRouter`.
+*
+* @param options Development server entry options.
+* @returns Vite plugin.
+*/
+function fastifyReactRouterDev(options = {}) {
+	let { entry = "./server.ts", exportName = "createServer", externalizeServerEntryImports = true } = options;
+	let command = "serve";
+	let root = process.cwd();
+	let serverEntryImportSpecifiers = /* @__PURE__ */ new Set();
+	let serverEntryImportFiles = /* @__PURE__ */ new Set();
+	return {
+		name: "fastify-react-router-dev",
+		enforce: "pre",
+		config(_config, environment) {
+			if (environment.command !== "serve") return;
+			return { ssr: { noExternal: adapterPackageNames } };
+		},
+		configResolved(config) {
+			command = config.command;
+			root = config.root;
+			let externals = collectServerEntryExternals(path.resolve(root, entry), externalizeServerEntryImports);
+			serverEntryImportSpecifiers = externals.specifiers;
+			serverEntryImportFiles = externals.files;
+		},
+		async resolveId(source, importer, resolveOptions) {
+			if (command !== "build" || !resolveOptions.ssr) return null;
+			if (shouldExternalizeSpecifier(source) === false) return null;
+			if (serverEntryImportSpecifiers.has(source)) return {
+				id: source,
+				external: true
+			};
+			if (importer == null) return null;
+			let resolved = await this.resolve(source, importer, {
+				...resolveOptions,
+				skipSelf: true
+			});
+			if (resolved == null) return null;
+			let filePath = toFilePath(resolved.id);
+			if (filePath == null || serverEntryImportFiles.has(filePath) === false) return null;
+			return {
+				id: source.startsWith("#") ? source : filePath,
+				external: true
+			};
+		},
+		configureServer(vite) {
+			let resolvedEntry = path.resolve(vite.config.root, entry);
+			let appPromise;
+			async function closeApp() {
+				let current = appPromise;
+				appPromise = void 0;
+				if (current == null) return;
+				try {
+					await (await current).close();
+				} catch {}
+			}
+			async function loadApp() {
+				if (appPromise == null) appPromise = (async () => {
+					let module = await importSsrModule(vite, resolvedEntry);
+					let factory = module[exportName] ?? module.default;
+					if (typeof factory !== "function") throw new Error(`[fastify-react-router-dev] Expected ${entry} to export "${exportName}" or a default Fastify app factory.`);
+					let app = await factory(vite);
+					await app.ready();
+					return app;
+				})();
+				return appPromise;
+			}
+			vite.watcher.on("change", () => {
+				closeApp();
+			});
+			vite.watcher.on("unlink", () => {
+				closeApp();
+			});
+			vite.httpServer?.once("close", () => {
+				closeApp();
+			});
+			return () => {
+				vite.middlewares.use(async (request, response, next) => {
+					try {
+						(await loadApp()).routing(request, response);
+					} catch (error) {
+						if (error instanceof Error) vite.ssrFixStacktrace(error);
+						next(error);
+					}
+				});
+			};
+		}
+	};
+}
+function collectServerEntryExternals(entryPath, externalizeServerEntryImports) {
+	let specifiers = /* @__PURE__ */ new Set();
+	let files = /* @__PURE__ */ new Set();
+	if (externalizeServerEntryImports === false) return {
+		specifiers,
+		files
+	};
+	let imports = Array.isArray(externalizeServerEntryImports) ? externalizeServerEntryImports : readImportSpecifiers(entryPath);
+	for (let specifier of imports) {
+		if (shouldExternalizeSpecifier(specifier) === false) continue;
+		specifiers.add(specifier);
+		if (isLocalSpecifier(specifier)) {
+			let file = resolveLocalImport(entryPath, specifier);
+			if (file) files.add(file);
+		}
+	}
+	return {
+		specifiers,
+		files
+	};
+}
+function readImportSpecifiers(filePath) {
+	if (fs.existsSync(filePath) === false) return [];
+	let source = fs.readFileSync(filePath, "utf8");
+	let specifiers = /* @__PURE__ */ new Set();
+	for (let match of source.matchAll(/\b(?:import|export)\s+(?:[^'"]*?\s+from\s*)?["']([^"']+)["']|import\s*\(\s*["']([^"']+)["']\s*\)/g)) specifiers.add(match[1] ?? match[2]);
+	return [...specifiers];
+}
+function shouldExternalizeSpecifier(specifier) {
+	return specifier.startsWith("#") || isLocalSpecifier(specifier);
+}
+function isLocalSpecifier(specifier) {
+	return specifier.startsWith(".") || specifier.startsWith("/");
+}
+function resolveLocalImport(importer, specifier) {
+	return resolveExistingFile(path.resolve(path.dirname(importer), specifier));
+}
+function resolveExistingFile(filePath) {
+	if (isFile(filePath)) return normalizePath(filePath);
+	for (let extension of [
+		".ts",
+		".tsx",
+		".mts",
+		".mjs",
+		".js",
+		".jsx"
+	]) {
+		let candidate = `${filePath}${extension}`;
+		if (isFile(candidate)) return normalizePath(candidate);
+	}
+	for (let extension of [
+		".ts",
+		".tsx",
+		".mts",
+		".mjs",
+		".js",
+		".jsx"
+	]) {
+		let candidate = path.join(filePath, `index${extension}`);
+		if (isFile(candidate)) return normalizePath(candidate);
+	}
+}
+function isFile(filePath) {
+	try {
+		return fs.statSync(filePath).isFile();
+	} catch {
+		return false;
+	}
+}
+function toFilePath(id) {
+	let withoutQuery = id.replace(/[?#].*$/, "");
+	if (withoutQuery.startsWith("file://")) return normalizePath(fileURLToPath(withoutQuery));
+	if (path.isAbsolute(withoutQuery)) return normalizePath(withoutQuery);
+}
+function normalizePath(filePath) {
+	return filePath.split(path.sep).join("/");
+}
+//#endregion
+export { fastifyReactRouterDev };
+
+//# sourceMappingURL=vite.mjs.map

package/dist/vite.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.mjs","names":[],"sources":["../src/vite.ts"],"sourcesContent":["import fs from \"node:fs\"\nimport path from \"node:path\"\nimport { fileURLToPath } from \"node:url\"\n\nimport type { FastifyInstance } from \"fastify\"\nimport type { Plugin, ViteDevServer } from \"vite\"\n\nimport { importSsrModule } from \"./vite-runtime.ts\"\n\nconst adapterPackageNames = [\n  \"@mcansh/react-router-fastify\",\n  \"@mcansh/remix-fastify\",\n]\n\nexport type FastifyAppFactory = (\n  vite: ViteDevServer,\n) => FastifyInstance | Promise<FastifyInstance>\n\nexport interface FastifyReactRouterDevOptions {\n  /** Server module loaded by Vite during `react-router dev`. */\n  entry?: string\n  /** Named export that creates the Fastify app. Falls back to `default`. */\n  exportName?: string\n  /**\n   * Keeps local modules imported by the Fastify server entry external in the\n   * React Router SSR build. This preserves singleton module identity for shared\n   * values such as React Router context tokens.\n   *\n   * Pass an array to externalize explicit import specifiers instead.\n   */\n  externalizeServerEntryImports?: boolean | string[]\n}\n\n/**\n * Vite plugin that lets `react-router dev` serve through a Fastify app.\n *\n * Vite continues to handle its internal client/HMR/module middleware first.\n * Fastify receives the remaining requests, including the React Router catch-all\n * installed by `fastifyReactRouter`.\n *\n * @param options Development server entry options.\n * @returns Vite plugin.\n */\nexport function fastifyReactRouterDev(\n  options: FastifyReactRouterDevOptions = {},\n): Plugin {\n  let {\n    entry = \"./server.ts\",\n    exportName = \"createServer\",\n    externalizeServerEntryImports = true,\n  } = options\n  let command: \"build\" | \"serve\" = \"serve\"\n  let root = process.cwd()\n  let serverEntryImportSpecifiers = new Set<string>()\n  let serverEntryImportFiles = new Set<string>()\n\n  return {\n    name: \"fastify-react-router-dev\",\n    enforce: \"pre\",\n    config(_config, environment) {\n      if (environment.command !== \"serve\") return\n\n      return {\n        ssr: {\n          noExternal: adapterPackageNames,\n        },\n      }\n    },\n    configResolved(config) {\n      command = config.command\n      root = config.root\n\n      let resolvedEntry = path.resolve(root, entry)\n      let externals = collectServerEntryExternals(\n        resolvedEntry,\n        externalizeServerEntryImports,\n      )\n      serverEntryImportSpecifiers = externals.specifiers\n      serverEntryImportFiles = externals.files\n    },\n    async resolveId(source, importer, resolveOptions) {\n      if (command !== \"build\" || !resolveOptions.ssr) return null\n      if (shouldExternalizeSpecifier(source) === false) return null\n\n      if (serverEntryImportSpecifiers.has(source)) {\n        return { id: source, external: true }\n      }\n\n      if (importer == null) return null\n\n      let resolved = await this.resolve(source, importer, {\n        ...resolveOptions,\n        skipSelf: true,\n      })\n      if (resolved == null) return null\n\n      let filePath = toFilePath(resolved.id)\n      if (filePath == null || serverEntryImportFiles.has(filePath) === false)\n        return null\n\n      return {\n        id: source.startsWith(\"#\") ? source : filePath,\n        external: true,\n      }\n    },\n    configureServer(vite) {\n      let resolvedEntry = path.resolve(vite.config.root, entry)\n      let appPromise: Promise<FastifyInstance> | undefined\n\n      async function closeApp(): Promise<void> {\n        let current = appPromise\n        appPromise = undefined\n        if (current == null) return\n\n        try {\n          let app = await current\n          await app.close()\n        } catch {\n          // The app may have failed while loading; there is nothing to close.\n        }\n      }\n\n      async function loadApp(): Promise<FastifyInstance> {\n        if (appPromise == null) {\n          appPromise = (async () => {\n            let module = await importSsrModule(vite, resolvedEntry)\n            let factory = module[exportName] ?? module.default\n\n            if (typeof factory !== \"function\") {\n              throw new Error(\n                `[fastify-react-router-dev] Expected ${entry} to export \"${exportName}\" or a default Fastify app factory.`,\n              )\n            }\n\n            let app = await (factory as FastifyAppFactory)(vite)\n            await app.ready()\n            return app\n          })()\n        }\n\n        return appPromise\n      }\n\n      vite.watcher.on(\"change\", () => {\n        void closeApp()\n      })\n      vite.watcher.on(\"unlink\", () => {\n        void closeApp()\n      })\n      vite.httpServer?.once(\"close\", () => {\n        void closeApp()\n      })\n\n      return () => {\n        vite.middlewares.use(async (request, response, next) => {\n          try {\n            let app = await loadApp()\n            app.routing(request, response)\n          } catch (error) {\n            if (error instanceof Error) vite.ssrFixStacktrace(error)\n            next(error)\n          }\n        })\n      }\n    },\n  }\n}\n\nfunction collectServerEntryExternals(\n  entryPath: string,\n  externalizeServerEntryImports: boolean | string[],\n): {\n  specifiers: Set<string>\n  files: Set<string>\n} {\n  let specifiers = new Set<string>()\n  let files = new Set<string>()\n\n  if (externalizeServerEntryImports === false) {\n    return { specifiers, files }\n  }\n\n  let imports = Array.isArray(externalizeServerEntryImports)\n    ? externalizeServerEntryImports\n    : readImportSpecifiers(entryPath)\n\n  for (let specifier of imports) {\n    if (shouldExternalizeSpecifier(specifier) === false) continue\n\n    specifiers.add(specifier)\n\n    if (isLocalSpecifier(specifier)) {\n      let file = resolveLocalImport(entryPath, specifier)\n      if (file) files.add(file)\n    }\n  }\n\n  return { specifiers, files }\n}\n\nfunction readImportSpecifiers(filePath: string): string[] {\n  if (fs.existsSync(filePath) === false) return []\n\n  let source = fs.readFileSync(filePath, \"utf8\")\n  let specifiers = new Set<string>()\n  let importPattern =\n    /\\b(?:import|export)\\s+(?:[^'\"]*?\\s+from\\s*)?[\"']([^\"']+)[\"']|import\\s*\\(\\s*[\"']([^\"']+)[\"']\\s*\\)/g\n\n  for (let match of source.matchAll(importPattern)) {\n    specifiers.add(match[1] ?? match[2])\n  }\n\n  return [...specifiers]\n}\n\nfunction shouldExternalizeSpecifier(specifier: string): boolean {\n  return specifier.startsWith(\"#\") || isLocalSpecifier(specifier)\n}\n\nfunction isLocalSpecifier(specifier: string): boolean {\n  return specifier.startsWith(\".\") || specifier.startsWith(\"/\")\n}\n\nfunction resolveLocalImport(\n  importer: string,\n  specifier: string,\n): string | undefined {\n  let resolved = path.resolve(path.dirname(importer), specifier)\n  return resolveExistingFile(resolved)\n}\n\nfunction resolveExistingFile(filePath: string): string | undefined {\n  if (isFile(filePath)) return normalizePath(filePath)\n\n  for (let extension of [\".ts\", \".tsx\", \".mts\", \".mjs\", \".js\", \".jsx\"]) {\n    let candidate = `${filePath}${extension}`\n    if (isFile(candidate)) return normalizePath(candidate)\n  }\n\n  for (let extension of [\".ts\", \".tsx\", \".mts\", \".mjs\", \".js\", \".jsx\"]) {\n    let candidate = path.join(filePath, `index${extension}`)\n    if (isFile(candidate)) return normalizePath(candidate)\n  }\n\n  return undefined\n}\n\nfunction isFile(filePath: string): boolean {\n  try {\n    return fs.statSync(filePath).isFile()\n  } catch {\n    return false\n  }\n}\n\nfunction toFilePath(id: string): string | undefined {\n  let withoutQuery = id.replace(/[?#].*$/, \"\")\n\n  if (withoutQuery.startsWith(\"file://\")) {\n    return normalizePath(fileURLToPath(withoutQuery))\n  }\n\n  if (path.isAbsolute(withoutQuery)) {\n    return normalizePath(withoutQuery)\n  }\n\n  return undefined\n}\n\nfunction normalizePath(filePath: string): string {\n  return filePath.split(path.sep).join(\"/\")\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@mcansh/react-router-fastify",
+  "version": "5.0.0",
+  "description": "Fastify adapter and Vite development plugin for React Router v8 framework mode",
+  "keywords": [
+    "adapter",
+    "fastify",
+    "react-router",
+    "vite"
+  ],
+  "bugs": {
+    "url": "https://github.com/mcansh/remix-fastify/issues"
+  },
+  "license": "MIT",
+  "author": "Logan McAnsh <logan@mcan.sh> (https://mcan.sh)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mcansh/remix-fastify.git",
+    "directory": "packages/react-router-fastify"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/mcansh"
+    }
+  ],
+  "files": [
+    "CHANGELOG.md",
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./vite": "./dist/vite.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@fastify/static": "^9.1.3"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/core": "^0.18.3",
+    "@react-router/dev": "8.0.1",
+    "@react-router/node": "8.0.1",
+    "@types/node": "^26.0.0",
+    "@vitest/coverage-v8": "4.1.9",
+    "fastify": "^5.8.5",
+    "publint": "^0.3.21",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "react-router": "8.0.1",
+    "tsdown": "^0.22.3",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.16",
+    "vitest": "^4.0.15"
+  },
+  "peerDependencies": {
+    "@react-router/node": "^8.0.0",
+    "fastify": "^5.0.0",
+    "react-router": "^8.0.0",
+    "vite": "^7.0.0 || ^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22.22.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "git clean -fdX",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "validate": "pnpm run typecheck && pnpm run test && pnpm run build"
+  }
+}

package/src/fastify.ts

@@ -0,0 +1,131 @@
+import path from "node:path"
+import { pathToFileURL } from "node:url"
+
+import fastifyStatic from "@fastify/static"
+import type { FastifyStaticOptions } from "@fastify/static"
+import type { FastifyInstance, RouteShorthandOptions } from "fastify"
+import type { ServerBuild } from "react-router"
+import type { ViteDevServer } from "vite"
+
+import { createRequestHandler, type GetLoadContextFunction } from "./handler.ts"
+import { importSsrModule } from "./vite-runtime.ts"
+
+export interface FastifyReactRouterOptions {
+  devServer?: ViteDevServer
+  basePath?: string
+  serverBuildPath?: string
+  clientBuildDirectory?: string
+  mode?: string
+  getLoadContext?: GetLoadContextFunction
+  build?: ServerBuild | (() => ServerBuild | Promise<ServerBuild>)
+  staticOptions?: FastifyStaticOptions
+  assetCacheControl?: string
+  fileCacheControl?: string
+  routeOptions?: RouteShorthandOptions
+}
+
+/**
+ * Fastify plugin that serves React Router framework builds.
+ *
+ * @param fastify Fastify instance.
+ * @param options Adapter options.
+ */
+export async function fastifyReactRouter(
+  fastify: FastifyInstance,
+  options: FastifyReactRouterOptions,
+): Promise<void> {
+  let {
+    devServer,
+    basePath = "/",
+    serverBuildPath = "build/server/index.js",
+    clientBuildDirectory = "build/client",
+    mode = process.env.NODE_ENV,
+    getLoadContext,
+    build,
+    staticOptions,
+    assetCacheControl = "public, max-age=31536000, immutable",
+    fileCacheControl = "public, max-age=3600",
+    routeOptions,
+  } = options
+
+  let serverBuild =
+    devServer == null
+      ? build ?? createBuildLoader(devServer, path.resolve(serverBuildPath))
+      : createBuildLoader(devServer, path.resolve(serverBuildPath))
+
+  if (devServer == null) {
+    await registerStaticFiles(fastify, {
+      basePath,
+      clientBuildDirectory: path.resolve(clientBuildDirectory),
+      assetCacheControl,
+      fileCacheControl,
+      staticOptions,
+    })
+  }
+
+  let handler = createRequestHandler({
+    build: serverBuild,
+    getLoadContext,
+    mode,
+  })
+
+  fastify.removeAllContentTypeParsers()
+  fastify.addContentTypeParser("*", (_request, payload, done) => {
+    done(null, payload)
+  })
+
+  if (routeOptions) {
+    fastify.all("*", routeOptions, handler)
+  } else {
+    fastify.all("*", handler)
+  }
+}
+
+function createBuildLoader(
+  devServer: ViteDevServer | undefined,
+  serverBuildPath: string,
+): ServerBuild | (() => ServerBuild | Promise<ServerBuild>) {
+  if (devServer != null) {
+    return () =>
+      importSsrModule<ServerBuild>(
+        devServer,
+        "virtual:react-router/server-build",
+      )
+  }
+
+  return async () =>
+    import(
+      /* @vite-ignore */ pathToFileURL(serverBuildPath).href
+    ) as Promise<ServerBuild>
+}
+
+async function registerStaticFiles(
+  fastify: FastifyInstance,
+  options: {
+    basePath: string
+    clientBuildDirectory: string
+    assetCacheControl: string
+    fileCacheControl: string
+    staticOptions?: FastifyStaticOptions
+  },
+): Promise<void> {
+  let assetsDirectory = path.join(options.clientBuildDirectory, "assets")
+
+  await fastify.register(fastifyStatic, {
+    root: options.clientBuildDirectory,
+    prefix: options.basePath,
+    wildcard: false,
+    cacheControl: false,
+    dotfiles: "ignore",
+    etag: true,
+    lastModified: true,
+    setHeaders(res, filePath) {
+      let isAsset = filePath.startsWith(assetsDirectory)
+      res.setHeader(
+        "cache-control",
+        isAsset ? options.assetCacheControl : options.fileCacheControl,
+      )
+    },
+    ...options.staticOptions,
+  })
+}

package/src/handler.ts

@@ -0,0 +1,52 @@
+import type { FastifyReply, FastifyRequest } from "fastify"
+import type { RouterContextProvider, ServerBuild } from "react-router"
+import { createRequestHandler as createReactRouterHandler } from "react-router"
+
+import { createRequest } from "./request.ts"
+import { sendResponse } from "./response.ts"
+
+export type HttpRequest = FastifyRequest["raw"]
+export type HttpResponse = FastifyReply["raw"]
+
+export type ReactRouterLoadContext = RouterContextProvider
+
+export type GetLoadContextFunction = (
+  request: FastifyRequest,
+  reply: FastifyReply,
+) =>
+  | ReactRouterLoadContext
+  | undefined
+  | Promise<ReactRouterLoadContext | undefined>
+
+export type RequestHandler = (
+  request: FastifyRequest,
+  reply: FastifyReply,
+) => Promise<void>
+
+export interface CreateRequestHandlerOptions {
+  build: ServerBuild | (() => ServerBuild | Promise<ServerBuild>)
+  getLoadContext?: GetLoadContextFunction
+  mode?: string
+}
+
+/**
+ * Creates a Fastify route handler backed by React Router's server runtime.
+ *
+ * @param options React Router build, mode, and optional load context hook.
+ * @returns Fastify route handler.
+ */
+export function createRequestHandler(
+  options: CreateRequestHandlerOptions,
+): RequestHandler {
+  let reactRouterHandler = createReactRouterHandler(
+    options.build,
+    options.mode ?? process.env.NODE_ENV,
+  )
+
+  return async (request, reply) => {
+    let webRequest = createRequest(request, reply)
+    let context = await options.getLoadContext?.(request, reply)
+    let webResponse = await reactRouterHandler(webRequest, context)
+    await sendResponse(reply, webResponse)
+  }
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export { fastifyReactRouter } from "./fastify.ts"
+export type { FastifyReactRouterOptions } from "./fastify.ts"
+export { createRequestHandler } from "./handler.ts"
+export { createHeaders, createRequest, createUrl } from "./request.ts"
+export { sendResponse } from "./response.ts"
+export type {
+  CreateRequestHandlerOptions,
+  GetLoadContextFunction,
+  HttpRequest,
+  HttpResponse,
+  ReactRouterLoadContext,
+  RequestHandler,
+} from "./handler.ts"

package/src/request.ts

@@ -0,0 +1,94 @@
+import { Readable } from "node:stream"
+
+import { createReadableStreamFromReadable } from "@react-router/node"
+import type { FastifyReply, FastifyRequest } from "fastify"
+
+/**
+ * Copies Fastify's normalized request headers into Web Fetch `Headers`.
+ *
+ * @param source Fastify request headers.
+ * @returns Fetch-compatible headers.
+ */
+export function createHeaders(source: FastifyRequest["headers"]): Headers {
+  let headers = new Headers()
+
+  for (let [name, value] of Object.entries(source)) {
+    if (value == null) continue
+
+    if (Array.isArray(value)) {
+      for (let item of value) {
+        headers.append(name, item)
+      }
+    } else {
+      headers.set(name, value)
+    }
+  }
+
+  return headers
+}
+
+/**
+ * Builds the absolute request URL that React Router expects.
+ *
+ * @param request Fastify request.
+ * @returns Absolute URL for the original incoming request.
+ */
+export function createUrl(request: FastifyRequest): string {
+  return `${request.protocol}://${request.host}${request.originalUrl}`
+}
+
+/**
+ * Adapts a Fastify request to a Web Fetch `Request`.
+ *
+ * @param request Fastify request.
+ * @param reply Fastify reply, used to abort work when the connection closes.
+ * @returns Fetch-compatible request for React Router.
+ */
+export function createRequest(
+  request: FastifyRequest,
+  reply: FastifyReply,
+): Request {
+  let controller: AbortController | null = new AbortController()
+
+  let init: RequestInit & { duplex?: "half" } = {
+    method: request.method,
+    headers: createHeaders(request.headers),
+    signal: controller.signal,
+  }
+
+  reply.raw.once("finish", () => {
+    controller = null
+  })
+  reply.raw.once("close", () => {
+    controller?.abort()
+  })
+
+  if (["GET", "HEAD"].includes(request.method) === false) {
+    init.body = getBody(request)
+    init.duplex = "half"
+  }
+
+  return new Request(createUrl(request), init)
+}
+
+function getBody(request: FastifyRequest): BodyInit | null {
+  let body = request.body
+
+  if (body == null) return createReadableStreamFromReadable(request.raw)
+  if (body instanceof Readable) return createReadableStreamFromReadable(body)
+  if (body instanceof ReadableStream) return body
+  if (body instanceof URLSearchParams) return body
+  if (body instanceof ArrayBuffer) return body
+  if (body instanceof Blob) return body
+  if (body instanceof FormData) return body
+  if (ArrayBuffer.isView(body)) {
+    return new Uint8Array(
+      body.buffer as ArrayBuffer,
+      body.byteOffset,
+      body.byteLength,
+    )
+  }
+  if (typeof body === "string") return body
+
+  return JSON.stringify(body)
+}

package/src/response.ts

@@ -0,0 +1,65 @@
+import { Readable } from "node:stream"
+
+import type { FastifyReply } from "fastify"
+
+/**
+ * Writes a Web Fetch `Response` through a Fastify reply.
+ *
+ * @param reply Fastify reply.
+ * @param response React Router response.
+ * @returns A promise that settles after the response is sent.
+ */
+export async function sendResponse(
+  reply: FastifyReply,
+  response: Response,
+): Promise<void> {
+  reply.status(response.status)
+  writeHeaders(reply, response.headers)
+
+  if (response.body == null) {
+    return reply.send()
+  }
+
+  return reply.send(readableFromWeb(response.body))
+}
+
+function writeHeaders(reply: FastifyReply, headers: Headers): void {
+  let cookies = readSetCookies(headers)
+
+  for (let [name, value] of headers) {
+    if (name.toLowerCase() === "set-cookie" && cookies.length > 0) continue
+    reply.header(name, value)
+  }
+
+  if (cookies.length > 0) {
+    reply.header("set-cookie", cookies)
+  }
+}
+
+function readSetCookies(headers: Headers): string[] {
+  let withCookies = headers as Headers & { getSetCookie?: () => string[] }
+  let cookies = withCookies.getSetCookie?.()
+  if (cookies && cookies.length > 0) return cookies
+
+  let cookie = headers.get("Set-Cookie")
+  return cookie ? [cookie] : []
+}
+
+function readableFromWeb(body: ReadableStream<Uint8Array>): Readable {
+  let reader = body.getReader()
+
+  return new Readable({
+    read() {
+      reader.read().then(
+        ({ done, value }) => {
+          this.push(done ? null : Buffer.from(value))
+        },
+        (error: unknown) => {
+          this.destroy(
+            error instanceof Error ? error : new Error(String(error)),
+          )
+        },
+      )
+    },
+  })
+}

package/src/vite-runtime.ts

@@ -0,0 +1,27 @@
+import type { DevEnvironment, ViteDevServer } from "vite"
+
+interface RunnableEnvironment extends DevEnvironment {
+  runner: {
+    import(id: string): Promise<Record<string, unknown>>
+  }
+}
+
+/**
+ * Imports an SSR module using Vite's current Environment runner, with
+ * `ssrLoadModule` as a compatibility fallback.
+ *
+ * @param vite Vite dev server.
+ * @param id Module ID to import.
+ * @returns Imported module namespace.
+ */
+export async function importSsrModule<T = Record<string, unknown>>(
+  vite: ViteDevServer,
+  id: string,
+): Promise<T> {
+  let ssr = vite.environments?.ssr as Partial<RunnableEnvironment> | undefined
+  if (typeof ssr?.runner?.import === "function") {
+    return ssr.runner.import(id) as Promise<T>
+  }
+
+  return vite.ssrLoadModule(id) as unknown as Promise<T>
+}