react-router-effect 2.1.0 → 2.2.0

package/dist/server.mjs

@@ -1,10 +1,10 @@
 import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
-import { Cause, Context, Data, Effect, Exit, FileSystem, Option, Path, Scope, Stream, Tracer } from "effect";
+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, HttpServerRequest, HttpServerResponse, HttpStaticServer } from "effect/http";
+import { Cookies, HttpMethod, HttpRouter, HttpServerRequest, HttpServerRespondable, HttpServerResponse, HttpStaticServer } from "effect/http";
 // src/server.ts
 /**
-* Serves a React Router framework-mode build from Effect's Node HTTP server.
+* 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
@@ -25,17 +25,17 @@ import { Cookies, HttpServerRequest, HttpServerResponse, HttpStaticServer } from
 * 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
 */
-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.
+* 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.
@@ -44,14 +44,14 @@ var server_exports = /* @__PURE__ */ __exportAll({
 * 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 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: Cookies.fromSetCookie(response.headers.getSetCookie())
+		cookies
 	};
 	const body = response.body;
 	return body === null ? HttpServerResponse.empty(init) : HttpServerResponse.stream(Stream.fromReadableStream({
@@ -59,83 +59,54 @@ const toHttpResponse = (response, controller) => {
 		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.
+* 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 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";
+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 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.
+* 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.
 */
-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;
-	}
-};
+const requestSpanKey = createContext(void 0);
 /**
-* 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.
+* 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 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));
+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 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.
+* 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 requestSpanKey = createContext(void 0);
+const httpRoute = (pattern) => pattern.startsWith("/") ? pattern : `/${pattern}`;
 /**
-* The span of the request fiber, when a tracer exports it: not the native
-* tracer, whose spans go nowhere, and not an unsampled span.
+* 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 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;
-};
+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 {
@@ -171,8 +142,7 @@ const isSpanError = (error) => {
 };
 /**
 * 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.
+* 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
@@ -186,12 +156,7 @@ const isSpanError = (error) => {
 * 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);
-	}
+	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",
@@ -199,12 +164,12 @@ const traced = (operation, routeId, storeKey, fn) => (args, ...rest) => {
 			"react_router.operation.name": operation,
 			"react_router.route.id": routeId
 		}
-	}, (span) => Effect.sync(() => {
+	}, (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((settled) => Effect.promise(() => settled)), Effect.flatMap((result) => result.ok || !isSpanError(result.error) ? Effect.succeed(result) : Effect.fail(result.error))));
+	}).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);
@@ -225,29 +190,31 @@ const wrapModule = (routeId, module, handlers) => {
 		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)
-	}]))
+/**
+* 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 runs of {@link make}'s Effect,
-* since a development server can make the app for each request.
+* new handler. The last handler is kept across requests, since a development
+* build loads for each request.
 */
-const makeBuildLoader = (options, mode) => {
+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), mode)
+			handler: createRequestHandler(wrapBuild(build, options.factory.handlers, instrumentations), mode)
 		};
 		return cached;
 	});
@@ -279,59 +246,238 @@ const callRouter = (handler, request, context, controller) => Effect.callback((r
 	});
 }).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.
+* 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
-* 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)),
+* export const App = ReactRouter.routes.pipe(
+*   Layer.provide(
+*     ReactRouter.layer({
+*       build: () => import("virtual:react-router/server-build"),
+*       factory: routeFactory,
+*       mode: import.meta.env.MODE,
+*     }),
+*   ),
 * );
 * ```
 *
-* 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.
+* @stability unstable
 */
-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);
-	});
+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)))));
 };
-/** The app for one loaded build source, and the client files it serves, if any. */
-const serve = (options, loadBuild, files) => Effect.gen(function* () {
+/**
+* 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;
-	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 routerContext = loadContext === void 0 ? new RouterContextProvider() : yield* loadContext(httpRequest);
 	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 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);
-	return toHttpResponse(response, 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 })))));
-export { server_exports as ReactRouterHttp };
+// 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

@@ -1,27 +1,48 @@
-import { Effect } from "effect";
-import { HttpServerRequest, HttpServerResponse } from "effect/http";
+import { Layer, Scope } from "effect";
+import { HttpRouter } from "effect/http";
 import * as Http from "node:http";
 declare namespace vite_d_exports {
-  export { ViteDevServer, devMiddleware };
+  export { ViteDevServer, layer };
 }
-/** The part of a Vite dev server the middleware uses: its Connect middleware stack. */
+/**
+ * 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;
 }
 /**
- * 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";
+ * 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 } });
- * HttpServer.serve(Effect.flatten(reactRouterApp).pipe(ReactRouterVite.devMiddleware(vite)));
+ * const App = ReactRouterVite.layer(vite, () =>
+ *   vite.ssrLoadModule("./server/app.ts").then((module) => module.App),
+ * );
  * ```
  *
- * 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.
+ * 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 devMiddleware: (vite: ViteDevServer) => <E, R>(app: Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R | HttpServerRequest.HttpServerRequest>;
+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 };