react-router-effect 2.0.0 → 2.2.0

package/dist/server.mjs

@@ -0,0 +1,483 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { Array, Cause, Context, Data, Effect, Exit, FileSystem, Layer, Option, Path, Predicate, Record, Scope, Stream, Struct, Tracer } from "effect";
+import { RouterContextProvider, createContext, createRequestHandler } from "react-router";
+import { Cookies, HttpMethod, HttpRouter, HttpServerRequest, HttpServerRespondable, HttpServerResponse, HttpStaticServer } from "effect/http";
+// src/server.ts
+/**
+* Serves a React Router framework-mode build from Effect's 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.
+*
+* The adapter's API is unstable: a minor version can change it.
+*
+* @stability unstable
+* @since 2.1.0
+*/
+/**
+* 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. A cookie
+* whose name Effect's parser rejects is dropped, and `handleRequest` logs it.
+*
+* 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, cookies, 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
+	};
+	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 names of the `Set-Cookie` values that are not in `cookies`, because
+* Effect's parser rejects them, such as a name with `/` or `:`. A value whose
+* name another value repeats is not dropped: Effect keeps the last cookie of
+* each name. Each value is parsed alone only when the counts differ.
+*/
+const droppedCookies = (values, cookies) => Object.keys(cookies.cookies).length === values.length ? [] : values.filter((value) => Cookies.isEmpty(Cookies.fromSetCookie(value))).map((value) => value.split(/[=;]/, 1)[0]?.trim() ?? "");
+/**
+* The server span of a traced request, which gets `http.route`. Without it,
+* the adapter adds no spans. The `react-router.*` spans nest under the
+* request fiber's own span instead, through the request store.
+*/
+const requestSpanKey = createContext(void 0);
+/**
+* The server span of the request, when a tracer exports it: not the native
+* tracer, whose spans go nowhere, and not an unsampled span. A route-scoped
+* router middleware can open spans of its own between the request fiber's
+* span and the server span, so the search goes up to the span of kind
+* `server` that Effect's HTTP tracer opens. It runs once per request. The
+* search goes by kind: an app's own span of kind `server` inside the request
+* would get `http.route` instead.
+*/
+const serverSpan = (context) => {
+	if (Context.get(context, Tracer.Tracer) === Tracer.nativeTracer) return void 0;
+	let span = Context.getOrUndefined(context, Tracer.ParentSpan);
+	while (Predicate.isTagged(span, "Span") && span.kind !== "server") span = Option.getOrUndefined(span.parent);
+	return Predicate.isTagged(span, "Span") && span.sampled ? span : void 0;
+};
+/**
+* The `http.route` of a routed pattern, such as `/posts/:id`. React Router
+* joins the route paths, so a root route without a path leaves out the
+* leading slash.
+*/
+const httpRoute = (pattern) => pattern.startsWith("/") ? pattern : `/${pattern}`;
+/**
+* Sets `http.route` on the server span to the pattern of the routes that
+* React Router matched, once per request, after React Router answered. React
+* Router 8 gives the pattern to this request handler hook, also for a page
+* that runs no route function. A request that matched no route keeps the
+* router's `*`.
+*/
+const routeLabel = { handler(handler) {
+	handler.instrument({ async request(handleRequest, { context }) {
+		const { meta } = await handleRequest();
+		const span = context?.get(requestSpanKey);
+		if (span !== void 0 && meta !== void 0 && meta.pattern !== "") span.attribute("http.route", httpRoute(meta.pattern));
+	} });
+} };
+/** 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`. `routeLabel` sets `http.route`.
+*
+* 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) => {
+	if (args.context.get(requestSpanKey) === void 0) return fn(args, ...rest);
+	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.promise(() => {
+		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((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, and adds the adapter's
+* instrumentations after the app's own in the server entry module. An app
+* often does not export `instrumentations`, and `Struct.evolve` changes only
+* the keys that an object has, so the key is set with `Struct.assign`.
+*/
+const wrapBuild = (build, handlers, instrumentations) => Struct.evolve(build, {
+	entry: (entry) => Struct.evolve(entry, { module: (module) => Struct.assign(module, { instrumentations: Array.appendAll(module.instrumentations ?? [], instrumentations) }) }),
+	routes: (routes) => Record.map(routes, (route, id) => route === void 0 ? void 0 : Struct.evolve(route, { module: (module) => wrapModule(id, 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 requests, since a development
+* build loads for each request.
+*/
+const makeBuildLoader = (options, mode, instrumentations) => {
+	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, instrumentations), 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);
+/**
+* The methods of React Router's routes. Not the method `*`, which also
+* registers HEAD: the router answers HEAD with the GET route of a path only
+* when no HEAD route matches it, so a HEAD route on `*` takes HEAD from every
+* GET route of the app.
+*/
+const routeMethods = Array.filter(HttpMethod.all, (method) => method !== "HEAD");
+/**
+* React Router, as a service of the Effect HTTP app. `ReactRouter.layer`
+* provides it, and `ReactRouter.routes` registers it on the app's router as
+* the catch-all route.
+*
+* ```ts
+* export const App = ReactRouter.routes.pipe(
+*   Layer.provide(
+*     ReactRouter.layer({
+*       build: () => import("virtual:react-router/server-build"),
+*       factory: routeFactory,
+*       mode: import.meta.env.MODE,
+*     }),
+*   ),
+* );
+* ```
+*
+* @stability unstable
+*/
+var ReactRouter = class ReactRouter extends Context.Service()("react-router-effect/ReactRouter") {
+	/**
+	* Provides React Router. A build value, or a build function in production
+	* mode, loads when the layer builds. Provide one value of this layer to
+	* every layer that reads the service: two values load the build twice.
+	*
+	* @stability unstable
+	*/
+	static layer = (options) => Layer.effect(ReactRouter, makeReactRouter(options));
+	/**
+	* Registers React Router as the catch-all route of the app's router, on
+	* `*`, for every method of `HttpMethod.all` but HEAD. A route that the app
+	* registers itself wins over it, also a route on `/`, such as the
+	* prerendered home page of `ReactRouterAssets.layer`. A HEAD request uses
+	* the GET route of its path, React Router's or the app's own, as Express
+	* does. A method outside `HttpMethod.all` gets the router's 404. Register
+	* it at the root of the router: under a prefix, React Router does not get
+	* the path that it expects.
+	*
+	* @stability unstable
+	*/
+	static routes = HttpRouter.use((router) => Effect.flatMap(ReactRouter, ({ handle }) => router.addAll(routeMethods.map((method) => HttpRouter.route(method, "*", handle)))));
+};
+/**
+* Makes the service. A build value, or a build function in production mode,
+* loads once here, so a build that does not load stops the server's start.
+* Any other build loads for each request, and gets a new React Router handler
+* when its value changes.
+*/
+const makeReactRouter = Effect.fnUntraced(function* (options) {
+	const mode = options.mode;
+	const tracer = yield* Effect.tracer;
+	const loadBuild = makeBuildLoader(options, mode, tracer === Tracer.nativeTracer ? [] : [routeLabel]);
+	const handlers = options.factory.handlers;
+	const services = yield* Effect.context();
+	const { loadContext } = options;
+	const provided = loadContext === void 0 ? void 0 : (request) => Effect.updateContext(loadContext(request), (requestContext) => Context.merge(services, requestContext));
+	if (typeof options.build === "function" && (mode === "development" || mode === "test")) return ReactRouter.of({
+		build: Option.none(),
+		handle: handleRequest(handlers, loadBuild, provided)
+	});
+	const loaded = yield* loadBuild;
+	return ReactRouter.of({
+		build: Option.some(loaded.build),
+		handle: handleRequest(handlers, Effect.succeed(loaded), provided)
+	});
+});
+/**
+* Answers the current request with React Router. Route Effects get the
+* request fiber's context without its scope, so they see the services that
+* the app's router middleware provides. A route that needs a scope opens its
+* own with `Effect.scoped`.
+*/
+const handleRequest = (handlers, loadBuild, loadContext) => Effect.gen(function* () {
+	const httpRequest = yield* HttpServerRequest.HttpServerRequest;
+	const { handler } = yield* loadBuild;
+	const fiberContext = Context.omit(Scope.Scope)(yield* Effect.context());
+	const routerContext = loadContext === void 0 ? new RouterContextProvider() : yield* loadContext(httpRequest);
+	const controller = new AbortController();
+	const converted = yield* HttpServerRequest.toWeb(httpRequest, { signal: controller.signal });
+	const request = converted === httpRequest.source && !converted.bodyUsed && converted.body?.locked !== true ? new Request(converted, { signal: AbortSignal.any([converted.signal, controller.signal]) }) : converted;
+	routerContext.set(handlers.requestContext, fiberContext);
+	routerContext.set(requestSpanKey, serverSpan(fiberContext));
+	const response = yield* callRouter(handler, request, routerContext, controller);
+	const setCookies = response.headers.getSetCookie();
+	const cookies = Cookies.fromSetCookie(setCookies);
+	const dropped = droppedCookies(setCookies, cookies);
+	if (dropped.length > 0) yield* Effect.logError("React Router adapter dropped cookies that Effect cannot send", dropped);
+	return toHttpResponse(response, cookies, controller);
+}).pipe(Effect.catchDefect((defect) => Effect.logError("React Router adapter failed", defect).pipe(Effect.as(HttpServerResponse.empty({ status: 500 })))));
+// src/assets.ts
+/**
+* Serves the client build of a React Router app from the app's Effect HTTP
+* router, as the `express.static` lines of React Router's Express template
+* do.
+*
+* Its API is unstable: a minor version can change it.
+*
+* @stability unstable
+* @since 2.2.0
+*/
+var assets_exports = /* @__PURE__ */ __exportAll({
+	ClientBuildError: () => ClientBuildError,
+	layer: () => layer
+});
+/**
+* The layer cannot serve the client build: it cannot read the directory, or
+* a file name has a `*`, which the router cannot match. The build's
+* `assetsBuildDirectory` is relative to the working directory of the server,
+* so `directory` is the path that it resolved to.
+*
+* @stability unstable
+* @since 2.2.0
+*/
+var ClientBuildError = class extends Data.TaggedError("ClientBuildError") {};
+/** The `Cache-Control` of the files in the hashed directory, whose names include a content hash. */
+const hashedCacheControl = "public, max-age=31536000, immutable";
+/** The `Cache-Control` of the other files of the client build. */
+const otherCacheControl = "public, max-age=3600";
+/**
+* The index file of a directory. React Router writes a prerendered page as
+* the `index.html` of its path's directory, and it is the default index of
+* `HttpStaticServer.make`.
+*/
+const indexFile = "index.html";
+/**
+* The directory of the hashed files, relative to `publicPath`, from the URL
+* of the manifest that the build plugin writes in it. `None` when the
+* manifest is not under `publicPath`, or is at its root.
+*/
+const hashedDirectory = (build, path) => {
+	const manifest = build.assets.url;
+	if (!manifest.startsWith(build.publicPath)) return Option.none();
+	const directory = path.dirname(manifest.slice(build.publicPath.length - 1));
+	return directory === "/" ? Option.none() : Option.some(directory);
+};
+/**
+* The handler of a static server. A missing file is a 404. Any other error,
+* such as a file that the server cannot read, goes to the app's loggers
+* before the 500.
+*/
+const makeHandler = (options) => HttpStaticServer.make(options).pipe(Effect.orDie, Effect.map((files) => files.pipe(Effect.catchReason("HttpServerError", "RouteNotFound", HttpServerRespondable.toResponse), Effect.catch((error) => Effect.logError("Cannot serve a client file", error).pipe(Effect.andThen(HttpServerRespondable.toResponse(error)))))));
+/**
+* Registers the routes of the client build on the app's router, for GET and
+* HEAD, under the build's `publicPath`.
+*
+* The hashed directory is the directory of the build's manifest URL, such as
+* `/assets`. The build plugin writes the files with a content hash in their
+* names there. Its files are cached for a year as immutable, and a request
+* under it for a file that the directory does not have gets a 404. The
+* files are served from that directory only, so a path with `..` does not
+* reach the other files of the client build.
+*
+* Each other file gets its own route, and is cached for an hour. A directory
+* with an `index.html`, such as a prerendered page, gets a route that serves
+* its `index.html`, and its path without the trailing slash redirects. The
+* layer serves no path with a segment that starts with a dot, such as
+* `.vite/`, as `express.static` ignores dotfiles. A root `index.html`, such
+* as a prerendered home page, gets the route `/`, which wins over the
+* catch-all of `ReactRouter.routes`. Any other request goes on to the app's
+* other routes.
+*
+* The layer reads the client build when it builds, so a file that something
+* adds outside the hashed directory later is served after a restart. It
+* fails with a {@link ClientBuildError} when it cannot read the client build
+* directory, or when a file name has a `*`, which the router cannot match.
+* A route of the app with the path of a file fails the server's start.
+*
+* The layer registers nothing for a build that loads for each request, such
+* as a development build, since Vite serves the client there. It also
+* registers nothing for a `publicPath` on another origin.
+*
+* The routes of this layer get the middleware that the app provides to this
+* layer. To leave the server's request logger out of file requests:
+*
+* ```ts
+* ReactRouterAssets.layer.pipe(Layer.provide(HttpRouter.disableLogger))
+* ```
+*
+* @stability unstable
+*/
+const layer = HttpRouter.use((router) => Effect.gen(function* () {
+	const { build: loaded } = yield* ReactRouter;
+	if (Option.isNone(loaded)) return;
+	const build = loaded.value;
+	if (!build.publicPath.startsWith("/")) return;
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const root = path.resolve(build.assetsBuildDirectory);
+	const readError = (cause) => new ClientBuildError({
+		message: `Cannot read the client build at ${root}`,
+		directory: root,
+		cause
+	});
+	const entries = yield* fileSystem.readDirectory(root, { recursive: true }).pipe(Effect.mapError(readError));
+	const hashed = hashedDirectory(build, path);
+	if (Option.isSome(hashed)) {
+		const handler = yield* makeHandler({
+			root: path.join(root, hashed.value),
+			index: void 0,
+			cacheControl: hashedCacheControl
+		});
+		yield* router.prefixed(build.publicPath).prefixed(hashed.value).addAll([HttpRouter.route("GET", "/*", handler), HttpRouter.route("HEAD", "/*", handler)]);
+	}
+	/** The URL path of an entry of the client build, relative to `publicPath`. */
+	const urlPath = (entry) => `/${entry.split(path.sep).join("/")}`;
+	const isServed = (url) => !url.split("/").some((segment) => segment.startsWith(".")) && Option.match(hashed, {
+		onNone: () => true,
+		onSome: (directory) => url !== directory && !url.startsWith(`${directory}/`)
+	});
+	const files = yield* Effect.filter(entries.filter((entry) => isServed(urlPath(entry))), (entry) => fileSystem.stat(path.join(root, entry)).pipe(Effect.map((info) => info.type === "File"), Effect.mapError(readError)));
+	const directories = files.filter((file) => path.basename(file) === indexFile).map((file) => path.dirname(file));
+	const urls = Array.appendAll(files.map(urlPath), directories.map((directory) => directory === "." ? "/" : urlPath(directory)));
+	const unmatchable = Array.findFirst(urls, (url) => url.includes("*"));
+	if (Option.isSome(unmatchable)) return yield* new ClientBuildError({
+		message: `Cannot serve ${unmatchable.value} of the client build at ${root}: the router cannot match a * in a path`,
+		directory: root,
+		cause: void 0
+	});
+	const handler = yield* makeHandler({
+		root,
+		index: indexFile,
+		cacheControl: otherCacheControl
+	});
+	yield* (build.publicPath === "/" ? router : router.prefixed(build.publicPath)).addAll(urls.flatMap((url) => {
+		const route = `/${url.slice(1).replaceAll(":", "::")}`;
+		return [HttpRouter.route("GET", route, handler), HttpRouter.route("HEAD", route, handler)];
+	}));
+}));
+export { ReactRouter, assets_exports as ReactRouterAssets };

package/dist/vite.d.mts

@@ -0,0 +1,48 @@
+import { Layer, Scope } from "effect";
+import { HttpRouter } from "effect/http";
+import * as Http from "node:http";
+declare namespace vite_d_exports {
+  export { ViteDevServer, layer };
+}
+/**
+ * The parts of a Vite dev server that the adapter uses.
+ *
+ * @stability unstable
+ */
+interface ViteDevServer {
+  /** Vite's Connect middleware stack. */
+  readonly middlewares: (request: Http.IncomingMessage, response: Http.ServerResponse, next: (error?: unknown) => void) => void;
+  /**
+   * Maps the stack of an error to the source files, as the Express template
+   * does. Vite's dev server has it.
+   */
+  readonly ssrFixStacktrace?: ((error: Error) => void) | undefined;
+}
+/**
+ * Serves the app in development, as the Express template does. Give it to
+ * `HttpRouter.serve` in place of the app's `App`:
+ *
+ * ```js
+ * const vite = await createServer({ server: { middlewareMode: true } });
+ * const App = ReactRouterVite.layer(vite, () =>
+ *   vite.ssrLoadModule("./server/app.ts").then((module) => module.App),
+ * );
+ * ```
+ *
+ * The layer registers one catch-all route on the server's router. Its
+ * handler passes each request to Vite first. For a request that Vite passes
+ * on, it calls `loadApp`. When `loadApp` returns a new `App` value, such as
+ * after an edit of the app's server code, the layer builds the new `App` with
+ * its own router and closes the old one. Concurrent requests share one build
+ * of each `App`. Then the request goes through the current `App`.
+ *
+ * A request that Vite answers gets an empty `HttpServerResponse`, which
+ * Effect's Node server does not write, since Vite has ended the Node
+ * response. A defect, such as a Vite error, a `loadApp` that rejects or an
+ * `App` that fails to build, goes to the app's loggers, after
+ * `ssrFixStacktrace` maps its stack, and the client gets an empty 500.
+ *
+ * @stability unstable
+ */
+declare const layer: <E, R>(vite: ViteDevServer, loadApp: () => PromiseLike<Layer.Layer<never, E, R>>) => Layer.Layer<never, never, HttpRouter.HttpRouter | HttpRouter.Request<"Error", import("effect/http/HttpServerError").HttpServerError> | Exclude<Exclude<HttpRouter.Request.Without<R>, HttpRouter.HttpRouter>, Scope.Scope> | Exclude<HttpRouter.Request.From<"Error", HttpRouter.Request.Only<"Error", R>>, Scope.Scope> | Exclude<HttpRouter.Request.From<"Error", HttpRouter.Request.Only<"GlobalError", R>>, Scope.Scope> | Exclude<HttpRouter.Request.From<"Requires", Exclude<Exclude<Exclude<Exclude<Exclude<HttpRouter.Request.Without<R>, HttpRouter.HttpRouter>, Scope.Scope>, Layer.CurrentMemoMap>, Exclude<HttpRouter.Request.Without<R>, HttpRouter.HttpRouter>>, HttpRouter.Provided>>, Scope.Scope> | Exclude<HttpRouter.Request.From<"Requires", Exclude<HttpRouter.Request.Only<"GlobalRequires", R>, HttpRouter.Provided>>, Scope.Scope> | Exclude<HttpRouter.Request.From<"Requires", Exclude<HttpRouter.Request.Only<"Requires", R>, HttpRouter.Provided>>, Scope.Scope>>;
+export { vite_d_exports as ReactRouterVite };

package/dist/vite.mjs

@@ -0,0 +1,80 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { Effect, Exit, Layer, Option, Predicate, Scope, SynchronizedRef, Tuple } from "effect";
+import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
+import * as NodeHttpServerRequest from "@effect/platform-node/NodeHttpServerRequest";
+// src/vite.ts
+var vite_exports = /* @__PURE__ */ __exportAll({ layer: () => layer });
+/**
+* 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));
+	}
+});
+/**
+* Serves the app in development, as the Express template does. Give it to
+* `HttpRouter.serve` in place of the app's `App`:
+*
+* ```js
+* const vite = await createServer({ server: { middlewareMode: true } });
+* const App = ReactRouterVite.layer(vite, () =>
+*   vite.ssrLoadModule("./server/app.ts").then((module) => module.App),
+* );
+* ```
+*
+* The layer registers one catch-all route on the server's router. Its
+* handler passes each request to Vite first. For a request that Vite passes
+* on, it calls `loadApp`. When `loadApp` returns a new `App` value, such as
+* after an edit of the app's server code, the layer builds the new `App` with
+* its own router and closes the old one. Concurrent requests share one build
+* of each `App`. Then the request goes through the current `App`.
+*
+* A request that Vite answers gets an empty `HttpServerResponse`, which
+* Effect's Node server does not write, since Vite has ended the Node
+* response. A defect, such as a Vite error, a `loadApp` that rejects or an
+* `App` that fails to build, goes to the app's loggers, after
+* `ssrFixStacktrace` maps its stack, and the client gets an empty 500.
+*
+* @stability unstable
+*/
+const layer = (vite, loadApp) => HttpRouter.use((router) => Effect.gen(function* () {
+	const layerScope = yield* Effect.scope;
+	const services = yield* Effect.context();
+	/** Builds `app` in `scope`. The services of this layer do not replace either. */
+	const build = (app, scope) => HttpRouter.toHttpEffect(app).pipe(Scope.provide(scope), Effect.provideServiceEffect(Layer.CurrentMemoMap, Layer.makeMemoMap), Effect.provideContext(services));
+	const state = yield* SynchronizedRef.make(Option.none());
+	/** The handler of `app`, built once for each `App` value. */
+	const handlerOf = (app) => SynchronizedRef.modifyEffect(state, (previous) => Effect.gen(function* () {
+		if (Option.isSome(previous) && previous.value.app === app) return Tuple.make(previous.value.handler, previous);
+		const scope = yield* Scope.fork(layerScope);
+		const handler = yield* build(app, scope).pipe(Effect.onExit((exit) => Exit.isSuccess(exit) ? Effect.void : Scope.close(scope, exit)), Effect.orDie);
+		if (Option.isSome(previous)) yield* Scope.close(previous.value.scope, Exit.void);
+		return Tuple.make(handler, Option.some({
+			app,
+			handler,
+			scope
+		}));
+	}).pipe(Effect.uninterruptible));
+	const handler = HttpServerRequest.HttpServerRequest.use((request) => passThroughVite(vite, NodeHttpServerRequest.toIncomingMessage(request), NodeHttpServerRequest.toServerResponse(request)).pipe(Effect.flatMap((passed) => passed ? Effect.promise(loadApp).pipe(Effect.flatMap(handlerOf), Effect.flatten) : Effect.succeed(HttpServerResponse.empty())), Effect.catchDefect((defect) => {
+		if (Predicate.isError(defect)) vite.ssrFixStacktrace?.(defect);
+		return Effect.logError("Request failed in development", defect).pipe(Effect.as(HttpServerResponse.empty({ status: 500 })));
+	})));
+	yield* router.add("*", "*", handler);
+}));
+export { vite_exports as ReactRouterVite };