react-router-effect 2.0.0 → 2.1.0

package/dist/server.d.mts

@@ -0,0 +1,218 @@
+import { C as ReturnableDataError, _ as NameError, a as RegisteredMeta, g as LibraryHandled, h as IsAny, m as FailureResponse, o as RegisteredRecover, p as FactoryTypes, y as RouteHandlers } from "./route-data-MgSnnR33.mjs";
+import { Cause, Context, Effect, FileSystem, Path } from "effect";
+import { Register, ServerBuild } from "react-router";
+import { HttpPlatform, HttpServerError, HttpServerRequest, HttpServerResponse } from "effect/http";
+declare namespace server_d_exports {
+  export { App, BuildSource, ClientAssetServices, ClientBuildError, Options, make };
+}
+/** A React Router server build, or a function that loads it, as in `createRequestHandler`. */
+type BuildSource = ServerBuild | (() => ServerBuild | Promise<ServerBuild>);
+/** The options of {@link make}. */
+interface Options {
+  /** The server build: `() => import("virtual:react-router/server-build")`. */
+  readonly build: BuildSource;
+  /** The route factory whose runner, runtime and error model route Effects use. */
+  readonly factory: {
+    readonly handlers: RouteHandlers;
+  };
+  /** React Router's server mode. Defaults to `process.env.NODE_ENV`. */
+  readonly mode?: string | undefined;
+  /**
+   * Serves the client build before React Router: the files of the build's
+   * `assetsBuildDirectory`, under its `publicPath`. Files under `assets/` have
+   * hashed names and are cached for a year as immutable, other files for an
+   * hour. It serves like `express.static`: a directory serves its index file,
+   * such as a prerendered page, its path without the trailing slash redirects
+   * to the path with it, dotfiles are not served, and a request it does not
+   * serve goes to React Router. Like `express.static`, it looks each GET and
+   * HEAD request up in the file system. It serves only a build that it loads
+   * once: in production mode, or a build value. A
+   * development build is never served, since Vite serves the client there, nor
+   * is a `publicPath` on another origin. Making the app fails with a
+   * {@link ClientBuildError} when it cannot read the directory. Needs the
+   * platform's file system, which `NodeHttpServer.layer` and the other server
+   * layers provide.
+   */
+  readonly clientAssets?: boolean | undefined;
+  /**
+   * Builds the services of one request, before React Router runs. They join
+   * the request's effect context, so every middleware, loader and action sees
+   * them without a middleware that sets them.
+   */
+  readonly requestContext?: ((request: Request) => Context.Context<never>) | undefined;
+}
+/** The services that serving the client build needs. */
+type ClientAssetServices = FileSystem.FileSystem | Path.Path | HttpPlatform.HttpPlatform;
+declare const ClientBuildError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+  readonly _tag: "ClientBuildError";
+} & Readonly<A>;
+/**
+ * The app serves the client build, and cannot read its directory. The
+ * build's `assetsBuildDirectory` is relative to the working directory of the
+ * server, so `directory` is the path it resolved to.
+ */
+declare class ClientBuildError extends ClientBuildError_base<{
+  readonly message: string;
+  /** The resolved directory of the client build. */
+  readonly directory: string;
+  readonly cause: unknown;
+}> {}
+/** True when the options serve the client build. */
+type ServesClientAssets<O> = O extends {
+  readonly clientAssets: infer Serves;
+} ? [Serves] extends [false | undefined] ? false : true : false;
+/**
+ * The Effect HTTP app {@link make} makes. Serving the client build adds the
+ * static file server's errors to its errors.
+ */
+type App<O extends Options> = Effect.Effect<HttpServerResponse.HttpServerResponse, HttpServerError.RequestError | (ServesClientAssets<O> extends true ? HttpServerError.HttpServerError : never), HttpServerRequest.HttpServerRequest>;
+/**
+ * Makes the Effect HTTP app that serves React Router. Run the Effect once,
+ * when the server starts. In production it loads the build, and with
+ * `clientAssets` it reads the client build's directory, so a missing one fails
+ * the server's start with a {@link ClientBuildError} and not its requests.
+ *
+ * ```ts
+ * import { ReactRouterHttp } from "react-router-effect/server";
+ *
+ * export const reactRouterApp = ReactRouterHttp.make({
+ *   build: () => import("virtual:react-router/server-build"),
+ *   factory: routeFactory,
+ *   clientAssets: true,
+ * });
+ *
+ * // Serve it like any Effect HTTP app, with the app's own middleware.
+ * Layer.unwrap(
+ *   Effect.map(reactRouterApp, (app) => HttpServer.serve(app, HttpMiddleware.logger)),
+ * );
+ * ```
+ *
+ * In development, where the build changes, the app loads the build for each
+ * request, and making it does nothing else.
+ *
+ * The request signal aborts only when the response ends early: when the
+ * client leaves while React Router runs or while the body streams. A
+ * completed response never aborts it.
+ */
+declare const make: <const O extends Options>(options: O) => Effect.Effect<App<O>, ServesClientAssets<O> extends true ? ClientBuildError : never, ServesClientAssets<O> extends true ? ClientAssetServices : never>;
+/** The route modules React Router's typegen registers, keyed by route ID. */
+type RegisteredRouteModules = Register extends {
+  readonly routeModules: infer Modules;
+} ? Modules : {};
+/** What an effect middleware may succeed with: React Router's response, or nothing. */
+type MiddlewareResult = Response | void | undefined;
+/** What a failure says to do, under its `react-router-effect` key. */
+type FailureMessage = "This route Effect can fail with an error the route factory does not handle, or needs a service it does not provide. Catch the error in the Effect (for example with Effect.catchTag), add it to the factory's domain errors, or provide the service.";
+/**
+ * One export that fails the check. `unhandledErrors` lists each error the
+ * effect can fail with that the factory does not handle, by its `_tag`.
+ * `missingServices` lists each service that neither the runtime nor the
+ * request context provides. `invalidResults` lists what a middleware succeeds
+ * with that is not a `Response` or nothing.
+ *
+ * It is an inline object type, not an interface, so the compiler prints its
+ * fields in the error rather than an alias name.
+ */
+type RouteEffectFailure<Route, Export, Unhandled, Missing, Invalid> = {
+  readonly "react-router-effect": FailureMessage;
+  readonly route: Route;
+  readonly export: Export;
+  readonly unhandledErrors: Unhandled;
+  readonly missingServices: Missing;
+  readonly invalidResults: Invalid;
+};
+/**
+ * The failure of one route function, or `never` when it does not return an
+ * Effect or when its Effect is fully handled. An Effect whose error or
+ * service type is `any` comes from a mistake TypeScript already reports, so it
+ * is skipped rather than reported a second time.
+ */
+type FunctionFailure<Route, Export, F, Handled, Provided, Result> = F extends ((...args: never[]) => Effect.Effect<infer A, infer E, infer R>) ? true extends IsAny<E> | IsAny<R> ? never : [Exclude<E, Handled>, Exclude<R, Provided>, Exclude<A, Result>] extends [never, never, never] ? never : {
+  readonly "react-router-effect": FailureMessage;
+  readonly route: Route;
+  readonly export: Export;
+  readonly unhandledErrors: NameError<Exclude<E, Handled>>;
+  readonly missingServices: Exclude<R, Provided>;
+  readonly invalidResults: Exclude<A, Result>;
+} : never;
+/** The failures of one route module's loader, action and middleware. */
+type ModuleFailures<Route, Module, Handled, Provided> = (Module extends {
+  readonly loader: infer F;
+} ? FunctionFailure<Route, "loader", F, Handled, Provided, unknown> : never) | (Module extends {
+  readonly action: infer F;
+} ? FunctionFailure<Route, "action", F, Handled, Provided, unknown> : never) | (Module extends {
+  readonly middleware: ReadonlyArray<infer F>;
+} ? FunctionFailure<Route, "middleware", F, Handled | FailureResponse, Provided, MiddlewareResult> : never);
+/** The failures of every registered route module. */
+type AllFailures<Modules, Handled, Provided> = { [Route in keyof Modules]: ModuleFailures<Route, Modules[Route], Handled, Provided>; }[keyof Modules];
+/** The types of a route factory. */
+type TypesOf<Factory> = Factory extends {
+  readonly "~types": infer Types;
+} ? Types : never;
+/** What one error handler's return recovers into, or `never` when it throws. */
+type HandlerRecovered<Return> = Return extends ReturnableDataError<infer Body> ? Body : Return extends Effect.Effect<infer Success, infer _E, infer _R> ? Success : never;
+/** The factory's recover map: each error tag whose handler recovers, and its data. */
+type FactoryRecover<Returns> = { [Tag in keyof Returns as [HandlerRecovered<Returns[Tag]>] extends [never] ? never : Tag]: HandlerRecovered<Returns[Tag]>; };
+/** True when each type is assignable to the other. */
+type SameType<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
+/**
+ * A disagreement between the `Register` of `react-router-effect` and the
+ * factory, which would type plain Effect routes' data wrongly.
+ */
+interface RegisterMismatch<Key, Factory, Registered> {
+  readonly register: Key;
+  readonly factory: Factory;
+  readonly registered: Registered;
+}
+/** The registration mismatches of a factory's types. */
+type RegisterMismatches<Returns, Meta> = (SameType<FactoryRecover<Returns>, RegisteredRecover> extends true ? never : RegisterMismatch<"recover", FactoryRecover<Returns>, RegisteredRecover>) | (SameType<Meta, RegisteredMeta> extends true ? never : RegisterMismatch<"actionMeta", Meta, RegisteredMeta>);
+/** Every failure: the routes', then the registration's. */
+type Failures<Modules, Types> = Types extends FactoryTypes<infer DomainError, infer Returns, infer Services, infer Meta> ? AllFailures<Modules, LibraryHandled<DomainError>, Services> | RegisterMismatches<Returns, Meta> : never;
+/**
+ * The failures of every Effect route function across the route modules React
+ * Router's typegen registers, and the registration mismatches, as objects.
+ * `never` when everything is handled. `RouteEffectCheck` reports them.
+ */
+type RouteEffectFailures<Factory, Modules = RegisteredRouteModules> = Failures<Modules, TypesOf<Factory>>;
+/** A printable name for an error tag or another unhandled error type. */
+type ErrorName<Name> = Name extends string ? Name : "an untagged error";
+/** A printable name for a service: its key, such as `"app/Database"`. */
+type ServiceName<Service> = Service extends {
+  readonly key: infer Key extends string;
+} ? Key : "a service without a string key";
+/** The diagnostic lines of one failure, one per error, service or result. */
+type FailureLines<Failure> = Failure extends {
+  readonly route: infer Route extends string | number | symbol;
+  readonly export: infer Export extends string;
+  readonly unhandledErrors: infer Unhandled;
+  readonly missingServices: infer Missing;
+  readonly invalidResults: infer Invalid;
+} ? (Unhandled extends unknown ? `${Route & string}#${Export} must handle ${ErrorName<Unhandled>}` : never) | (Missing extends unknown ? `${Route & string}#${Export} needs a provider for ${ServiceName<Missing>}` : never) | ([Invalid] extends [never] ? never : `${Route & string}#${Export} must succeed with a Response or nothing`) : Failure extends {
+  readonly register: infer Key extends string;
+} ? `the Register of react-router-effect: ${Key} does not match the route factory` : never;
+/**
+ * Checks every loader, action and middleware that returns an Effect, across
+ * the route modules React Router's typegen registers. Each failure is a
+ * required property whose name says what to fix, so assigning `{}` fails to
+ * compile with a list such as:
+ *
+ * ```text
+ * Type '{}' is missing the following properties from type ...:
+ *   "routes/billing#loader must handle PlaidApiError",
+ *   "routes/admin#middleware needs a provider for app/Session"
+ * ```
+ *
+ * ```ts
+ * import type { RouteEffectCheck } from "react-router-effect/server";
+ *
+ * export const routeEffects: RouteEffectCheck<typeof routeFactory> = {};
+ * ```
+ *
+ * An Effect may fail with the factory's domain errors, the library's `Respond`
+ * errors, and `HttpServerRespondable` errors, and require the services of the
+ * factory's runtime and request context. A middleware may also fail with what
+ * its `next()` fails with. The check also fails when the `Register` of
+ * `react-router-effect` disagrees with the factory.
+ */
+type RouteEffectCheck<Factory, Modules = RegisteredRouteModules> = { readonly [Line in FailureLines<RouteEffectFailures<Factory, Modules>>]: Line; };
+export { server_d_exports as ReactRouterHttp, type RegisterMismatch, type RouteEffectCheck, type RouteEffectFailure, type RouteEffectFailures };

package/dist/server.mjs

@@ -0,0 +1,337 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { Cause, Context, Data, Effect, Exit, FileSystem, Option, Path, Scope, Stream, Tracer } from "effect";
+import { RouterContextProvider, createContext, createRequestHandler } from "react-router";
+import { Cookies, HttpServerRequest, HttpServerResponse, HttpStaticServer } from "effect/http";
+// src/server.ts
+/**
+* Serves a React Router framework-mode build from Effect's Node HTTP server.
+*
+* The adapter converts each `HttpServerRequest` into a Web `Request`, calls
+* React Router's own request handler, and streams the `Response` back. React
+* Router keeps doing everything it does for any other server adapter:
+* documents, `.data` requests, streamed promises, resource routes, the lazy
+* route manifest, and middleware.
+*
+* The adapter owns everything between the Effect HTTP request and React
+* Router: the Web `Request` and its abort signal, the route factory, and the
+* conversion of React Router's `Response`, cookies and streamed body included.
+* Listening, static files, compression, proxies, tracing and the other server
+* concerns stay with the app's Effect HTTP server.
+*
+* Before React Router sees the build, the adapter wraps every loader, action
+* and middleware with the route factory's runner. A route function that
+* returns an Effect runs through the factory's error model, with the factory's
+* runtime and the request's effect context. Any other route function passes
+* through unchanged, so existing promise loaders and `makeLoader` wrappers keep
+* working.
+*
+* @since 2.1.0
+*/
+var server_exports = /* @__PURE__ */ __exportAll({
+	ClientBuildError: () => ClientBuildError,
+	make: () => make
+});
+/**
+* Converts React Router's response. Its `Set-Cookie` values become the
+* response's cookies, as `HttpServerResponse.fromWeb` converts them, so
+* middleware after the adapter can read and change them. Effect keeps one
+* cookie per name, the last one, and only the attributes it knows.
+*
+* Effect gives a streamed body without a content type
+* `application/octet-stream`, so a route that sends a body sets its own.
+*
+* When the body stream ends before it finished, because the client left or a
+* write failed, the request signal aborts: React Router then stops streamed
+* promises, and route code sees the abort. A completed response never aborts it.
+*/
+const toHttpResponse = (response, controller) => {
+	const headers = new Headers(response.headers);
+	headers.delete("set-cookie");
+	const init = {
+		status: response.status,
+		statusText: response.statusText === "" ? void 0 : response.statusText,
+		headers,
+		cookies: Cookies.fromSetCookie(response.headers.getSetCookie())
+	};
+	const body = response.body;
+	return body === null ? HttpServerResponse.empty(init) : HttpServerResponse.stream(Stream.fromReadableStream({
+		evaluate: () => body,
+		onError: (error) => error
+	}).pipe(Stream.onExit((exit) => Exit.isSuccess(exit) ? Effect.void : Effect.sync(() => controller.abort()))), init);
+};
+/** The `Cache-Control` of the files under `assets/`, whose names include a content hash. */
+const hashedCacheControl = "public, max-age=31536000, immutable";
+/** The `Cache-Control` of the other client files, such as `favicon.ico`. */
+const otherCacheControl = "public, max-age=3600";
+/**
+* True for a path with a segment that starts with a dot, such as `.vite/`,
+* which is never served. Effect's static server serves dotfiles, and Vite
+* writes its manifest there. `express.static` ignores them.
+*/
+const hasDotSegment = (path) => path.split("/").some((segment) => segment.startsWith("."));
+/** True when a static lookup found no file, so the request goes on to React Router. */
+const isNotFound = (error) => error.reason._tag === "RouteNotFound";
+/**
+* The app serves the client build, and cannot read its directory. The
+* build's `assetsBuildDirectory` is relative to the working directory of the
+* server, so `directory` is the path it resolved to.
+*/
+var ClientBuildError = class extends Data.TaggedError("ClientBuildError") {};
+/**
+* The client files of a build, or `undefined` when the adapter does not serve
+* them. Making them reads the build's directory, so a missing client build
+* fails the server's start and not its requests.
+*/
+const makeClientFiles = (build) => Effect.gen(function* () {
+	if (build.assets.hmr !== void 0 || !build.publicPath.startsWith("/")) return void 0;
+	const fileSystem = yield* FileSystem.FileSystem;
+	const root = (yield* Path.Path).resolve(build.assetsBuildDirectory);
+	yield* fileSystem.readDirectory(root).pipe(Effect.mapError((cause) => new ClientBuildError({
+		message: `Cannot read the client build at ${root}`,
+		directory: root,
+		cause
+	})));
+	const files = (cacheControl) => HttpStaticServer.make({
+		root,
+		cacheControl
+	}).pipe(Effect.orDie);
+	return {
+		prefix: build.publicPath.replace(/\/$/, ""),
+		hashed: yield* files(hashedCacheControl),
+		other: yield* files(otherCacheControl)
+	};
+});
+/** The decoded path of a URL, or `undefined` when it does not decode. */
+const decodePath = (path) => {
+	try {
+		return decodeURIComponent(path);
+	} catch {
+		return;
+	}
+};
+/**
+* Serves the request from the client build, or returns `None` when the build
+* has no such file: a path the build does not have, a directory without an
+* index file, a dotfile, a path outside the `publicPath`, or a method other
+* than GET and HEAD.
+*/
+const serveClientFile = (files, request) => {
+	const path = request.url.split("?")[0] ?? "";
+	if (request.method !== "GET" && request.method !== "HEAD" || !path.startsWith(`${files.prefix}/`)) return Effect.succeedNone;
+	const url = request.url.slice(files.prefix.length);
+	const file = decodePath(url.split("?")[0] ?? "");
+	if (file === void 0 || hasDotSegment(file)) return Effect.succeedNone;
+	return (url.startsWith("/assets/") ? files.hashed : files.other).pipe(Effect.provideService(HttpServerRequest.HttpServerRequest, request.modify({ url })), Effect.map(Option.some), Effect.catchIf(isNotFound, () => Effect.succeedNone));
+};
+/**
+* The span of a traced request: the server span of Effect's HTTP tracer, with
+* a tracer that exports spans. Without it, the adapter adds no spans.
+*/
+const requestSpanKey = createContext(void 0);
+/**
+* The span of the request fiber, when a tracer exports it: not the native
+* tracer, whose spans go nowhere, and not an unsampled span.
+*/
+const exportedSpan = (context) => {
+	const span = Context.getOrUndefined(context, Tracer.ParentSpan);
+	return span?._tag === "Span" && span.sampled && Context.get(context, Tracer.Tracer) !== Tracer.nativeTracer ? span : void 0;
+};
+/** Calls a route function and captures its result, a synchronous throw included. */
+const settle = (call) => {
+	try {
+		return Promise.resolve(call()).then((value) => ({
+			ok: true,
+			value
+		}), (error) => ({
+			ok: false,
+			error
+		}));
+	} catch (error) {
+		return Promise.resolve({
+			ok: false,
+			error
+		});
+	}
+};
+/** The status of a thrown `Response` or `data(...)`, which React Router sends as a response. */
+const thrownStatus = (error) => {
+	if (error instanceof Response) return error.status;
+	if (typeof error !== "object" || error === null || !("type" in error)) return void 0;
+	if (error.type !== "DataWithResponseInit" || !("init" in error)) return void 0;
+	const init = error.init;
+	return typeof init === "object" && init !== null && "status" in init && typeof init.status === "number" ? init.status : 200;
+};
+/**
+* A thrown value is an error of the span unless React Router sends it as a
+* response below 500, such as a redirect or `data(..., 404)`.
+*/
+const isSpanError = (error) => {
+	const status = thrownStatus(error);
+	return status === void 0 || status >= 500;
+};
+/**
+* Runs a route function in a span of its own when the request is traced,
+* such as `react-router.loader routes/home`, and sets `http.route` on the
+* request's span.
+*
+* The spans follow React Router's structure. A middleware's span is the
+* parent of everything its `next()` runs: the next middleware, then the
+* loaders and the action. A route Effect nests under its function's span, and
+* so do the clients an OpenTelemetry instrumentation traces, since Effect's
+* OpenTelemetry tracer makes the span active while the function is called.
+*
+* The request store's parent span passes the structure down. A loader or an
+* action reads it once, when it is called. A middleware's span stays there
+* for the rest of the chain, until the middleware finishes; an Effect
+* middleware's own spans around `next()` take its place there.
+*/
+const traced = (operation, routeId, storeKey, fn) => (args, ...rest) => {
+	const requestSpan = args.context.get(requestSpanKey);
+	if (requestSpan === void 0) return fn(args, ...rest);
+	if (typeof args.pattern === "string") {
+		const route = args.pattern.startsWith("/") ? args.pattern : `/${args.pattern}`;
+		requestSpan.attribute("http.route", route);
+	}
+	const store = args.context.get(storeKey);
+	const program = Effect.useSpan(`react-router.${operation} ${routeId}`, {
+		kind: "internal",
+		attributes: {
+			"react_router.operation.name": operation,
+			"react_router.route.id": routeId
+		}
+	}, (span) => Effect.sync(() => {
+		args.context.set(storeKey, Context.add(store, Tracer.ParentSpan, span));
+		const settled = settle(() => fn(args, ...rest));
+		if (operation !== "middleware") args.context.set(storeKey, store);
+		return settled;
+	}).pipe(Effect.withParentSpan(span), Effect.flatMap((settled) => Effect.promise(() => settled)), Effect.flatMap((result) => result.ok || !isSpanError(result.error) ? Effect.succeed(result) : Effect.fail(result.error))));
+	return Effect.runPromiseExitWith(store)(program).then((exit) => {
+		if (operation === "middleware") args.context.set(storeKey, store);
+		if (Exit.isFailure(exit)) throw Cause.squash(exit.cause);
+		if (exit.value.ok) return exit.value.value;
+		throw exit.value.error;
+	});
+};
+/**
+* Wraps a route module's loader, action and middleware with the factory's
+* runner, and traces them. The module itself is left as it is.
+*/
+const wrapModule = (routeId, module, handlers) => {
+	const store = handlers.requestContext;
+	return {
+		...module,
+		loader: module.loader === void 0 ? void 0 : traced("loader", routeId, store, handlers.loader(module.loader)),
+		action: module.action === void 0 ? void 0 : traced("action", routeId, store, handlers.action(module.action)),
+		middleware: module.middleware?.map((fn) => traced("middleware", routeId, store, handlers.middleware(fn)))
+	};
+};
+/** Wraps every route module of a build. */
+const wrapBuild = (build, handlers) => ({
+	...build,
+	routes: Object.fromEntries(Object.entries(build.routes).map(([id, route]) => [id, route === void 0 ? void 0 : {
+		...route,
+		module: wrapModule(id, route.module, handlers)
+	}]))
+});
+/**
+* Loads the build and returns React Router's request handler for it. The
+* handler is built once per build value: React Router rebuilds its route
+* tables on every request when it is given a function, so the adapter
+* resolves the build itself. In development a new build after a change gets a
+* new handler. The last handler is kept across runs of {@link make}'s Effect,
+* since a development server can make the app for each request.
+*/
+const makeBuildLoader = (options, mode) => {
+	let cached;
+	return Effect.promise(async () => {
+		const build = typeof options.build === "function" ? await options.build() : options.build;
+		if (cached?.build !== build) cached = {
+			build,
+			handler: createRequestHandler(wrapBuild(build, options.factory.handlers), mode)
+		};
+		return cached;
+	});
+};
+/**
+* Calls React Router. The call starts in the request fiber, so code that
+* reads the async context, such as an OpenTelemetry tracer whose context the
+* Effect tracer sets, sees the request's. When the request fiber is
+* interrupted, because the client left, the request signal aborts, and a
+* response that React Router resolves afterwards has its body cancelled.
+*
+* Effect's HTTP server runs the app uninterruptible, and interrupts the fiber
+* only where the app opts in, so the call is interruptible.
+*/
+const callRouter = (handler, request, context, controller) => Effect.callback((resume) => {
+	let interrupted = false;
+	handler(request, context).then((response) => {
+		if (interrupted) {
+			response.body?.cancel().catch(() => void 0);
+			return;
+		}
+		resume(Effect.succeed(response));
+	}, (error) => {
+		if (!interrupted) resume(Effect.die(error));
+	});
+	return Effect.sync(() => {
+		interrupted = true;
+		controller.abort();
+	});
+}).pipe(Effect.interruptible);
+/**
+* Makes the Effect HTTP app that serves React Router. Run the Effect once,
+* when the server starts. In production it loads the build, and with
+* `clientAssets` it reads the client build's directory, so a missing one fails
+* the server's start with a {@link ClientBuildError} and not its requests.
+*
+* ```ts
+* import { ReactRouterHttp } from "react-router-effect/server";
+*
+* export const reactRouterApp = ReactRouterHttp.make({
+*   build: () => import("virtual:react-router/server-build"),
+*   factory: routeFactory,
+*   clientAssets: true,
+* });
+*
+* // Serve it like any Effect HTTP app, with the app's own middleware.
+* Layer.unwrap(
+*   Effect.map(reactRouterApp, (app) => HttpServer.serve(app, HttpMiddleware.logger)),
+* );
+* ```
+*
+* In development, where the build changes, the app loads the build for each
+* request, and making it does nothing else.
+*
+* The request signal aborts only when the response ends early: when the
+* client leaves while React Router runs or while the body streams. A
+* completed response never aborts it.
+*/
+const make = (options) => {
+	const mode = options.mode ?? process.env.NODE_ENV;
+	const loadBuild = makeBuildLoader(options, mode);
+	const settled = typeof options.build !== "function" || mode === "production";
+	return Effect.gen(function* () {
+		if (!settled) return serve(options, loadBuild, void 0);
+		const loaded = yield* loadBuild;
+		const files = options.clientAssets === true ? yield* makeClientFiles(loaded.build) : void 0;
+		return serve(options, Effect.succeed(loaded), files);
+	});
+};
+/** The app for one loaded build source, and the client files it serves, if any. */
+const serve = (options, loadBuild, files) => Effect.gen(function* () {
+	const httpRequest = yield* HttpServerRequest.HttpServerRequest;
+	if (files !== void 0) {
+		const file = yield* serveClientFile(files, httpRequest);
+		if (Option.isSome(file)) return file.value;
+	}
+	const { handler } = yield* loadBuild;
+	const fiberContext = Context.omit(Scope.Scope)(yield* Effect.context());
+	const controller = new AbortController();
+	const request = yield* HttpServerRequest.toWeb(httpRequest, { signal: controller.signal });
+	const routerContext = new RouterContextProvider();
+	routerContext.set(options.factory.handlers.requestContext, Context.merge(fiberContext, options.requestContext?.(request) ?? Context.empty()));
+	routerContext.set(requestSpanKey, exportedSpan(fiberContext));
+	const response = yield* callRouter(handler, request, routerContext, controller);
+	return toHttpResponse(response, controller);
+}).pipe(Effect.catchDefect((defect) => Effect.logError("React Router adapter failed", defect).pipe(Effect.as(HttpServerResponse.empty({ status: 500 })))));
+export { server_exports as ReactRouterHttp };

package/dist/vite.d.mts

@@ -0,0 +1,27 @@
+import { Effect } from "effect";
+import { HttpServerRequest, HttpServerResponse } from "effect/http";
+import * as Http from "node:http";
+declare namespace vite_d_exports {
+  export { ViteDevServer, devMiddleware };
+}
+/** The part of a Vite dev server the middleware uses: its Connect middleware stack. */
+interface ViteDevServer {
+  readonly middlewares: (request: Http.IncomingMessage, response: Http.ServerResponse, next: (error?: unknown) => void) => void;
+}
+/**
+ * Passes each request to Vite first, and the requests Vite passes on to the
+ * app. Use it in development only, with Vite in middleware mode:
+ *
+ * ```ts
+ * import { ReactRouterVite } from "react-router-effect/vite";
+ *
+ * const vite = await createServer({ server: { middlewareMode: true } });
+ * HttpServer.serve(Effect.flatten(reactRouterApp).pipe(ReactRouterVite.devMiddleware(vite)));
+ * ```
+ *
+ * A request Vite answers gets an empty `HttpServerResponse`, which Effect's
+ * Node server does not write, since Vite has ended the Node response. A Vite
+ * error fails the request as a defect.
+ */
+declare const devMiddleware: (vite: ViteDevServer) => <E, R>(app: Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R | HttpServerRequest.HttpServerRequest>;
+export { vite_d_exports as ReactRouterVite };

package/dist/vite.mjs

@@ -0,0 +1,46 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { Effect } from "effect";
+import { HttpServerRequest, HttpServerResponse } from "effect/http";
+import * as NodeHttpServerRequest from "@effect/platform-node/NodeHttpServerRequest";
+// src/vite.ts
+var vite_exports = /* @__PURE__ */ __exportAll({ devMiddleware: () => devMiddleware });
+/**
+* Runs Vite's middleware on the Node request. Succeeds with `true` when Vite
+* passes the request on, and `false` when Vite answered it, or the client left
+* while Vite answered.
+*/
+const passThroughVite = (vite, request, response) => Effect.callback((resume) => {
+	let settled = false;
+	const settle = (result) => {
+		if (settled) return;
+		settled = true;
+		response.off("finish", answered);
+		response.off("close", answered);
+		resume(result);
+	};
+	const answered = () => settle(Effect.succeed(false));
+	response.once("finish", answered);
+	response.once("close", answered);
+	try {
+		vite.middlewares(request, response, (error) => settle(error === void 0 ? Effect.succeed(true) : Effect.die(error)));
+	} catch (error) {
+		settle(Effect.die(error));
+	}
+});
+/**
+* Passes each request to Vite first, and the requests Vite passes on to the
+* app. Use it in development only, with Vite in middleware mode:
+*
+* ```ts
+* import { ReactRouterVite } from "react-router-effect/vite";
+*
+* const vite = await createServer({ server: { middlewareMode: true } });
+* HttpServer.serve(Effect.flatten(reactRouterApp).pipe(ReactRouterVite.devMiddleware(vite)));
+* ```
+*
+* A request Vite answers gets an empty `HttpServerResponse`, which Effect's
+* Node server does not write, since Vite has ended the Node response. A Vite
+* error fails the request as a defect.
+*/
+const devMiddleware = (vite) => (app) => HttpServerRequest.HttpServerRequest.use((request) => passThroughVite(vite, NodeHttpServerRequest.toIncomingMessage(request), NodeHttpServerRequest.toServerResponse(request)).pipe(Effect.flatMap((passed) => passed ? app : Effect.succeed(HttpServerResponse.empty()))));
+export { vite_exports as ReactRouterVite };