react-router-effect 2.0.0 → 2.1.0

package/dist/index.d.mts

@@ -1,342 +1,2 @@
-import { Context, Effect, ManagedRuntime } from "effect";
-import { HttpServerRespondable } from "effect/http";
-import { ActionFunctionArgs, LoaderFunctionArgs, MiddlewareFunction, RouterContext, UNSAFE_DataWithResponseInit } from "react-router";
-//#region src/errors.d.ts
-declare const ReturnableDataError_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]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "ReturnableRouteError";
-} & Readonly<A>;
-/** Recoverable: short-circuits the loader but returns `data(...)` the component reads. */
-export declare class ReturnableDataError<D> extends ReturnableDataError_base<{
-  data: D;
-  init?: number | ResponseInit;
-}> {}
-declare const ThrowableDataError_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]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "ThrowableRouteError";
-} & Readonly<A>;
-/** Throwable: rejects with `data(...)` → boundary as an `ErrorResponse`. */
-export declare class ThrowableDataError<D> extends ThrowableDataError_base<{
-  data: D;
-  init?: number | ResponseInit;
-}> {}
-declare const ThrowableRedirectError_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]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "ThrowableRedirectError";
-} & Readonly<A>;
-/** Throwable: rejects with a redirect `Response`. */
-export declare class ThrowableRedirectError extends ThrowableRedirectError_base<{
-  url: string;
-  init?: number | ResponseInit;
-}> {}
-/** Every library route error, as a single union. */
-type AnyRouteError = ReturnableDataError<unknown> | ThrowableDataError<unknown> | ThrowableRedirectError;
-/**
- * The library's base helpers for raising route errors (`early` / `throw` /
- * `redirect`). This is internal: it isn't exported from the package. The factory
- * hands it to your config builder and returns it (merged with any `respond`
- * extensions) so your app imports a single `Respond`:
- *
- * ```ts
- * export const { makeLoader, Respond } = makeEffectRouteFactory<DomainErrors>()(
- *   (Respond) => ({
- *     respond: { formError: (reply) => new FormError({ reply }) },
- *     errorHandlers: { FormError: (e) => Respond.early({ reply: e.reply }) },
- *   }),
- * );
- * ```
- */
-declare const Respond: {
-  /** Recover: short-circuit and hand `value` to the component as loader/action data. */
-  early: <D>(value: D, init?: number | ResponseInit) => ReturnableDataError<D>;
-  /** Throw: short-circuit to the error boundary with `data(value, init)`. */
-  throw: <D>(value: D, init?: number | ResponseInit) => ThrowableDataError<D>;
-  /** Throw: short-circuit with a redirect `Response`. */
-  redirect: (url: string, init?: number | ResponseInit) => ThrowableRedirectError;
-};
-/** Narrows an unknown value to one of the library's route errors. */
-export declare const isRouteError: (value: unknown) => value is AnyRouteError;
-//#endregion
-//#region src/factory.d.ts
-/** The library's base `Respond` helpers (`early` / `throw` / `redirect`). */
-type BaseRespond = typeof Respond;
-type Tagged = {
-  readonly _tag: string;
-};
-/**
- * Everything a failure branch rejects with. React Router routes a thrown
- * `DataWithResponseInit` to the boundary as an `ErrorResponse`, and a thrown
- * `Response` (including `redirect(...)`) as-is. Pinning every `Effect.fail` branch
- * to this union keeps inference from fixing the error channel to the first one.
- */
-type FailureResponse = UNSAFE_DataWithResponseInit<unknown> | Response;
-/**
- * What a handler may return, to *remap* a domain error:
- *  - a **library route error** — `Respond.early(value)` (recover), `Respond.throw(data)`
- *    or `Respond.redirect(url)` (throw) — which the library then processes; or
- *  - an **`Effect`** — `Effect.succeed(value)` to recover with `value`, or
- *    `Effect.fail(response)` to throw `response`.
- */
-type ErrorHandler<Err> = (error: Err) => AnyRouteError | Effect.Effect<unknown, FailureResponse>;
-/** The body of every `ReturnableDataError` raised directly in `E` (`Respond.early`). */
-type ReturnableBodyOf<E> = E extends ReturnableDataError<infer Body> ? Body : never;
-/**
- * The recover contribution of a `Respond.early` raised directly in the loader.
- * Guarded so a loader that never recovers directly doesn't leak
- * `DataWithResponseInit<never>` into its return type.
- */
-type DirectRecover<E> = [ReturnableBodyOf<E>] extends [never] ? never : UNSAFE_DataWithResponseInit<ReturnableBodyOf<E>>;
-/** What a handler may return: a library route error or an `Effect` failing with a response. */
-type HandlerReturn = AnyRouteError | Effect.Effect<unknown, FailureResponse>;
-/** A `Route.MiddlewareFunction` (or the base `MiddlewareFunction`) — `(args, next) => ...`. */
-type AnyMiddlewareFunction = (...args: never[]) => unknown;
-/**
- * The `args` a `Route.MiddlewareFunction` (or the base `MiddlewareFunction`) is called
- * with — inferred from the type argument so `makeMiddleware` can be pinned to a specific
- * generated route's middleware type.
- */
-type MiddlewareArgsOf<Middleware extends AnyMiddlewareFunction> = Parameters<Middleware>[0];
-/**
- * The `next` a `Route.MiddlewareFunction` (or the base `MiddlewareFunction`) is called
- * with — react-router's own `() => Promise<Result>`, not exported under its own name.
- */
-type MiddlewareNextOf<Middleware extends AnyMiddlewareFunction> = Parameters<Middleware>[1];
-/**
- * The `Result` a `Route.MiddlewareFunction` (or the base `MiddlewareFunction`) resolves
- * with — i.e. what its `next()` resolves to, and what the middleware itself may return.
- * Read through `Awaited` because react-router declares `next` as an *interface* with a
- * call signature (`MiddlewareNextFunction`), and a route's own may resolve synchronously.
- */
-type MiddlewareResultOf<Middleware extends AnyMiddlewareFunction> = MiddlewareNextOf<Middleware> extends ((...args: never[]) => infer Result) ? Awaited<Result> : never;
-/**
- * The inferred map of handler RETURN types, keyed by domain-error tag. Making the
- * factory generic over *this* (rather than the whole handler map) is what lets
- * `errorHandlers` contextually type each handler's `error` param from its key —
- * no annotation needed — while still capturing precise return types for recovery.
- */
-type HandlerReturns<DomainError extends Tagged> = Partial<Record<DomainError["_tag"], HandlerReturn>>;
-/**
- * The `errorHandlers` field shape for a given return map: one entry per registered
- * tag, whose `error` is the matching domain error (so it autocompletes and types
- * itself) and whose return is the precise, inferred `Returns[Tag]`.
- */
-type ErrorHandlers<DomainError extends Tagged, Returns> = { [Tag in keyof Returns]: (error: Extract<DomainError, {
-  readonly _tag: Tag;
-}>) => Returns[Tag]; };
-/**
- * What the registered handlers recover into loader/action data — from each
- * handler's return type, but only for handlers whose error can actually occur in
- * `E`:
- *  - a remapped `ReturnableDataError<B>` recovers as `DataWithResponseInit<B>`;
- *  - an `Effect.succeed(value)` recovers as `value`;
- *  - throwables, redirects and `Effect.fail(...)` contribute nothing.
- */
-type RecoverOf<DomainError extends Tagged, Returns, E> = { [Tag in keyof Returns]: [Extract<E, Extract<DomainError, {
-  readonly _tag: Tag;
-}>>] extends [never] ? never : (Returns[Tag] extends ReturnableDataError<infer B> ? UNSAFE_DataWithResponseInit<B> : never) | (Returns[Tag] extends Effect.Effect<infer SuccessValue, any, any> ? SuccessValue : never); }[keyof Returns];
-/**
- * Errors the library deals with on the handler's behalf — so the loader/action/
- * middleware needn't handle them itself:
- *  - the app's **declared domain errors** (`DomainError`) — handled by a registered
- *    handler, or left to the 500 / auto-respond default;
- *  - **library route errors** raised directly via `Respond`;
- *  - anything that renders itself via **`HttpServerRespondable`**;
- *  - `AlsoHandled` — extra, call-site-specific already-handled errors. Only
- *    `makeMiddleware` uses this, to admit the `FailureResponse` its `next()`
- *    fails with (a downstream throw, already a finished response — the library
- *    re-throws it as-is, so the middleware needn't catch it just to re-raise it).
- */
-type LibraryHandled<DomainError, AlsoHandled = never> = DomainError | AnyRouteError | HttpServerRespondable.Respondable | AlsoHandled;
-/**
- * What remains in a handler's error channel that the library will NOT handle —
- * i.e. service-specific errors the route consumes that aren't declared domain
- * errors. The loader/action/middleware must handle these itself (catch or map them).
- */
-type Unhandled<E, DomainError, AlsoHandled = never> = Exclude<E, LibraryHandled<DomainError, AlsoHandled>>;
-/**
- * A readable compile-time diagnostic. It's intersected onto the *effect return type*
- * of `fn` — so the effect's `A`/`E`/`R` still infer directly (naked), while a mismatch
- * reports this message, and the offending types, *at the `makeLoader`/`makeAction`
- * call* instead of the opaque "Expected 2 arguments". Resolves to `unknown` (a no-op
- * intersection) when the effect is fully handled and all its requirements are provided:
- *
- *  - **Unhandled error** — the effect can fail with something that isn't a declared
- *    domain error, a library route error, or respondable; `unhandledErrors` names them.
- *  - **Missing requirement** — the effect requires a service that neither the
- *    `runtime` nor the `requestContext` provides; `missingRequirements` names them.
- *
- * The message lives in an *inline* object literal (no named alias) so tsc/tsgo print
- * its text verbatim rather than collapsing it to an alias name.
- */
-/**
- * Names the unhandled errors for the diagnostic: a tagged error becomes its `_tag`
- * (the string you'd pass to `Effect.catchTag`), anything untagged stays as its type.
- */
-type NameError<U> = U extends {
-  readonly _tag: infer Tag extends string;
-} ? Tag : U;
-/**
- * True exactly when `T` is (or, for a union, includes) `any` — not `unknown`, not
- * `never`, not any other type. An unrelated mistake elsewhere in the effect (a typo,
- * a call with the wrong number of arguments, a genuine syntax error) commonly makes
- * TypeScript infer `any` for `E`/`R` instead of reporting a clean type; running
- * `Diagnose` on that `any` produces a confusing "unhandled errors: any" message that
- * buries the real mistake. Guarding on this and bailing to `unknown` lets tsc's own,
- * on-site error surface instead. (`1 & T` is `any` when `T` is `any` — including when
- * `any` only appears as a union member, since intersection distributes over unions —
- * and `0` is assignable to `any` but not to any concrete type built from `1 & T`.)
- */
-type IsAny<T> = 0 extends 1 & T ? true : false;
-type Diagnose<E, R, DomainError, Provided, AlsoHandled = never> = IsAny<E> extends true ? unknown : IsAny<R> extends true ? unknown : [Unhandled<E, DomainError, AlsoHandled>] extends [never] ? [Exclude<R, Provided>] extends [never] ? unknown : {
-  "react-router-effect": "This loader/action/middleware requires a service the factory does not provide. Add it to your runtime or requestContext, or handle it in the effect.";
-  missingRequirements: Exclude<R, Provided>;
-} : {
-  "react-router-effect": "This loader/action/middleware can fail with an error the library does not handle. Catch it in the effect (e.g. Effect.catchTag), make it Respondable, or add it to your DomainError union.";
-  unhandledErrors: NameError<Unhandled<E, DomainError, AlsoHandled>>;
-};
-/**
- * A React Router context key holding a per-request effect `Context.Context`. Set
- * it in middleware and pass it to the factory's `requestContext` — the runner
- * reads it on every request and provides its services to the loader/action.
- *
- * It's just a `RouterContext`; create one with React Router's `createContext`:
- *
- * ```ts
- * import { createContext } from "react-router";
- * import { Context } from "effect";
- * import type { RequestContextKey } from "react-router-effect";
- *
- * class RequestContext extends Context.Service<RequestContext, {
- *   readonly userId: string;
- * }>()("app/RequestContext") {}
- *
- * export const requestContext: RequestContextKey<RequestContext> = createContext();
- *
- * // middleware:
- * export const middleware: Route.MiddlewareFunction[] = [
- *   ({ context, request }, next) => {
- *     context.set(requestContext, Context.make(RequestContext, { userId: readUser(request) }));
- *     return next();
- *   },
- * ];
- * ```
- */
-type RequestContextKey<ReqServices> = RouterContext<Context.Context<ReqServices>>;
-/**
- * Build `makeLoader` / `makeAction` / `makeMiddleware` for an application, wired to
- * its domain errors.
- *
- * Declare the app's **domain errors** as the type argument, then register an
- * *optional* handler per domain error in `errorHandlers`. The handler keys
- * autocomplete to your domain-error tags and each `error` parameter is typed from
- * its key — no annotation needed. It's curried so you can pin the domain errors
- * while the handler return types are still inferred:
- *
- * ```ts
- * type DomainErrors = MyDomainError | DbError | NotAuthorizedError;
- *
- * export const { makeLoader, makeAction, Respond } =
- *   makeEffectRouteFactory<DomainErrors>()((Respond) => ({
- *     errorHandlers: {
- *       // `error` is typed as MyDomainError automatically. throw → error boundary
- *       MyDomainError: (error) => Respond.throw({ message: error.message }, 400),
- *       // DbError has no handler → falls through to the 500 default.
- *     },
- *   }));
- * ```
- *
- * The inner config is a **builder** — it receives the library's `Respond` helpers so
- * your handlers can recover/throw with them, and returns the config. `Respond` is
- * also returned from the factory (extended with any `respond` helpers you add), so
- * your app imports a *single* `Respond` — no auto-import ambiguity with a library one.
- *
- * A handler *remaps* the error by returning either a library route error
- * (`Respond.early` to recover; `Respond.throw` / `Respond.redirect` to throw) or an
- * `Effect` (`Effect.succeed(value)` to recover `value`; `Effect.fail(response)` to
- * throw). Recovered values become loader/action data, typed precisely.
- *
- * **Declared domain errors** may be left unhandled: if one implements
- * `HttpServerRespondable` it's rendered automatically, otherwise it falls through
- * to a 500. **Any other error** — a service-specific error the route consumes that
- * isn't a declared domain error — *must* be handled in the loader/action, or
- * `makeLoader`/`makeAction` fails to type-check.
- *
- * Pass a `runtime` (a `ManagedRuntime`, e.g. from `ManagedRuntime.make(AppLayer)`)
- * to provide your app's services once. Loader/action effects may then require those
- * services directly — no per-call `Effect.provide`:
- *
- * ```ts
- * const { makeLoader, makeAction } = makeEffectRouteFactory<DomainErrors>()(() => ({
- *   runtime: getAppRuntime(), // provides Database, MyService, ...
- *   errorHandlers: { ... },
- * }));
- *
- * // `MyService` is satisfied by the runtime, not provided here:
- * const loader = makeLoader((args: Route.LoaderArgs) =>
- *   Effect.gen(function* () {
- *     const svc = yield* MyService;
- *     return { data: yield* svc.load(args) };
- *   }),
- * );
- * ```
- *
- * `makeMiddleware` wraps a `Route.MiddlewareFunction` the same way: write it as an
- * effect, and register the same domain errors/handlers. Pin it to the route's
- * generated `Route.MiddlewareFunction` (a type argument, since middleware has no
- * separate args-only type) to type `args` and `next`'s result from that route; it
- * defaults to React Router's own `MiddlewareFunction`. The `next` handed to the
- * effect is `() => Effect.Effect<Result, FailureResponse>` — call it with `yield*`
- * to run the rest of the chain, and a downstream throw (e.g. a nested loader's
- * redirect) surfaces as a typed failure instead of a rejected promise:
- *
- * ```ts
- * const middleware = makeMiddleware<Route.MiddlewareFunction>((args, next) =>
- *   Effect.gen(function* () {
- *     const user = yield* getUser(args); // may fail with a declared domain error
- *     if (!user) yield* Respond.redirect("/login");
- *     return yield* next();
- *   }),
- * );
- * ```
- */
-export declare function makeEffectRouteFactory<DomainError extends Tagged = never>(): <const Returns extends HandlerReturns<DomainError> = {}, RServices = never, ReqServices = never, const ExtraRespond extends Record<string, (...args: never[]) => unknown> = {}>(builder: (respond: BaseRespond) => {
-  /**
-   * An optional handler per declared domain error, keyed by its tag. The keys
-   * autocomplete to your domain-error tags and each handler's `error` parameter
-   * is typed automatically — no annotation needed. A handler *remaps* the error
-   * by returning a library route error (the builder's `Respond.early` / `throw`
-   * / `redirect`) or an `Effect` (`Effect.succeed`/`fail`). Omit to register none.
-   */
-  errorHandlers?: ErrorHandlers<DomainError, Returns>;
-  /**
-   * The app runtime that provides services to loader/action effects. When
-   * set, effects may require its services (`RServices`, inferred from here)
-   * without providing layers, and runs go through `runtime.runPromise`. When
-   * omitted, `RServices` is `never` and effects must require nothing.
-   */
-  runtime?: ManagedRuntime.ManagedRuntime<RServices, any>;
-  /**
-   * A React Router context key (a {@link RequestContextKey}) holding a
-   * per-request effect `Context.Context`. Middleware sets it for each request;
-   * the runner reads `args.context.get(requestContext)` and provides those
-   * services to the effect. Loader/action effects may then require
-   * `ReqServices` (inferred from here) in addition to the runtime's services.
-   */
-  requestContext?: RequestContextKey<ReqServices>;
-  /**
-   * App-specific `Respond` helpers — merged onto the base `Respond` that the
-   * factory returns, so your app imports one `Respond`. Typically opinionated
-   * error constructors; annotate their parameters, e.g.
-   * `{ formError: (reply: string) => new FormError({ reply }) }`. The base
-   * helpers (`early` / `throw` / `redirect`) always win the merge.
-   */
-  respond?: ExtraRespond;
-}) => {
-  makeLoader: <Args extends LoaderFunctionArgs | ActionFunctionArgs, A, E, R>(fn: (args: Args) => Effect.Effect<A, E, R> & Diagnose<E, R, DomainError, RServices | ReqServices>) => (args: Args) => Promise<A | DirectRecover<E> | RecoverOf<DomainError, Returns, E>>;
-  makeAction: <Args extends LoaderFunctionArgs | ActionFunctionArgs, A, E, R>(fn: (args: Args) => Effect.Effect<A, E, R> & Diagnose<E, R, DomainError, RServices | ReqServices>) => (args: Args) => Promise<A | DirectRecover<E> | RecoverOf<DomainError, Returns, E>>;
-  makeMiddleware: <Middleware extends AnyMiddlewareFunction = MiddlewareFunction, E = LibraryHandled<DomainError, FailureResponse>, R = RServices | ReqServices>(fn: (args: MiddlewareArgsOf<Middleware>, next: () => Effect.Effect<MiddlewareResultOf<Middleware>, FailureResponse>) => Effect.Effect<MiddlewareResultOf<Middleware> | void, E, R> & Diagnose<E, R, DomainError, RServices | ReqServices, FailureResponse>) => (args: MiddlewareArgsOf<Middleware>, next: MiddlewareNextOf<Middleware>) => Promise<MiddlewareResultOf<Middleware> | undefined>;
-  Respond: {
-    early: <D>(value: D, init?: number | ResponseInit) => ReturnableDataError<D>;
-    throw: <D>(value: D, init?: number | ResponseInit) => ThrowableDataError<D>;
-    redirect: (url: string, init?: number | ResponseInit) => ThrowableRedirectError;
-  } & ExtraRespond;
-};
-//#endregion
-export type { AnyRouteError, ErrorHandler, RequestContextKey };
+import { C as ReturnableDataError, D as WithActionMeta, E as isRouteError, O as actionMetaKey, S as AnyRouteError, T as ThrowableRedirectError, a as RegisteredMeta, b as RouteResult, c as Serialize, d as EffectNext, f as ErrorHandler, i as Register, l as ActionMetaArgs, n as EffectData, o as RegisteredRecover, p as FactoryTypes, r as EffectRouteArgs, s as RouteData, t as BrandData, u as EffectMiddlewareArgs, v as RequestContextKey, w as ThrowableDataError, x as makeEffectRouteFactory, y as RouteHandlers } from "./route-data-MgSnnR33.mjs";
+export { type ActionMetaArgs, type AnyRouteError, type BrandData, type EffectData, type EffectMiddlewareArgs, type EffectNext, type EffectRouteArgs, type ErrorHandler, type FactoryTypes, type Register, type RegisteredMeta, type RegisteredRecover, type RequestContextKey, ReturnableDataError, type RouteData, type RouteHandlers, type RouteResult, type Serialize, ThrowableDataError, ThrowableRedirectError, type WithActionMeta, actionMetaKey, isRouteError, makeEffectRouteFactory };

package/dist/index.mjs

@@ -1,7 +1,37 @@
-import { Data, Effect } from "effect";
+import { Context, Data, Effect, Predicate } from "effect";
+import { createContext, data, redirect } from "react-router";
 import { HttpServerRespondable, HttpServerResponse } from "effect/http";
-import { data, redirect } from "react-router";
-//#region src/errors.ts
+// src/action-meta.ts
+/** The key that holds the metadata in action data. */
+const actionMetaKey = "__meta";
+const DataWithResponseInitClass = data(void 0).constructor;
+/** True for a `data(...)` wrapper, never for a business field that looks like one. */
+const isDataWithResponseInit = (value) => value instanceof DataWithResponseInitClass;
+/** True for a plain object, which can be copied without losing behavior. */
+const isPlainRecord = (value) => {
+	if (!Predicate.isObject(value) || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+/**
+* Attaches `meta` to the action result. A plain record gets a copy with the
+* metadata key; a `data(...)` wrapper gets it on its body and keeps its init.
+* Any other value is returned unchanged.
+*/
+const attachActionMeta = (value, meta) => {
+	if (isDataWithResponseInit(value)) {
+		if (!isPlainRecord(value.data)) return value;
+		return data({
+			...value.data,
+			[actionMetaKey]: meta
+		}, value.init ?? void 0);
+	}
+	return isPlainRecord(value) ? {
+		...value,
+		[actionMetaKey]: meta
+	} : value;
+};
+// src/errors.ts
 /** Recoverable: short-circuits the loader but returns `data(...)` the component reads. */
 var ReturnableDataError = class extends Data.TaggedError("ReturnableRouteError") {};
 /** Throwable: rejects with `data(...)` → boundary as an `ErrorResponse`. */
@@ -11,7 +41,7 @@ var ThrowableRedirectError = class extends Data.TaggedError("ThrowableRedirectEr
 /**
 * The library's base helpers for raising route errors (`early` / `throw` /
 * `redirect`). This is internal: it isn't exported from the package. The factory
-* hands it to your config builder and returns it (merged with any `respond`
+* passes it to your config builder and returns it (merged with any `respond`
 * extensions) so your app imports a single `Respond`:
 *
 * ```ts
@@ -24,7 +54,7 @@ var ThrowableRedirectError = class extends Data.TaggedError("ThrowableRedirectEr
 * ```
 */
 const Respond = {
-	/** Recover: short-circuit and hand `value` to the component as loader/action data. */
+	/** Recover: short-circuit and pass `value` to the component as loader/action data. */
 	early: (value, init) => new ReturnableDataError({
 		data: value,
 		init
@@ -42,11 +72,10 @@ const Respond = {
 };
 /** Narrows an unknown value to one of the library's route errors. */
 const isRouteError = (value) => value instanceof ReturnableDataError || value instanceof ThrowableDataError || value instanceof ThrowableRedirectError;
-//#endregion
-//#region src/factory.ts
+// src/factory.ts
 const internalServerError = () => Effect.fail(new Response("Internal Server Error", { status: 500 }));
 /**
-* A raw `FailureResponse` — a downstream `next()`'s rejection, in `makeMiddleware` —
+* A raw `FailureResponse` - a downstream `next()`'s rejection, in `makeMiddleware` -
 * is already a finished response; re-throwing it as-is (rather than 500ing it) lets
 * a nested loader's redirect/thrown response pass back up through the middleware chain.
 */
@@ -58,13 +87,27 @@ const processRouteError = (e) => {
 	return Effect.fail(redirect(e.url, e.init));
 };
 /**
+* The request store of a factory that configures no `requestContext`. It holds
+* whatever the server adapter and effect middleware put there, and starts empty.
+*/
+const defaultRequestContext = createContext(Context.empty());
+/**
+* The entries of `current` that `started` lacks or holds with another value:
+* what a fiber that began with `started` has provided since.
+*/
+const providedSince = (started, current) => {
+	const provided = /* @__PURE__ */ new Map();
+	for (const [key, value] of current.mapUnsafe) if (started.mapUnsafe.get(key) !== value) provided.set(key, value);
+	return Context.makeUnsafe(provided);
+};
+/**
 * Build `makeLoader` / `makeAction` / `makeMiddleware` for an application, wired to
 * its domain errors.
 *
 * Declare the app's **domain errors** as the type argument, then register an
 * *optional* handler per domain error in `errorHandlers`. The handler keys
 * autocomplete to your domain-error tags and each `error` parameter is typed from
-* its key — no annotation needed. It's curried so you can pin the domain errors
+* its key - no annotation needed. It's curried so you can pin the domain errors
 * while the handler return types are still inferred:
 *
 * ```ts
@@ -80,10 +123,10 @@ const processRouteError = (e) => {
 *   }));
 * ```
 *
-* The inner config is a **builder** — it receives the library's `Respond` helpers so
+* The inner config is a **builder** - it receives the library's `Respond` helpers so
 * your handlers can recover/throw with them, and returns the config. `Respond` is
 * also returned from the factory (extended with any `respond` helpers you add), so
-* your app imports a *single* `Respond` — no auto-import ambiguity with a library one.
+* your app imports a *single* `Respond` - no auto-import ambiguity with a library one.
 *
 * A handler *remaps* the error by returning either a library route error
 * (`Respond.early` to recover; `Respond.throw` / `Respond.redirect` to throw) or an
@@ -92,13 +135,13 @@ const processRouteError = (e) => {
 *
 * **Declared domain errors** may be left unhandled: if one implements
 * `HttpServerRespondable` it's rendered automatically, otherwise it falls through
-* to a 500. **Any other error** — a service-specific error the route consumes that
-* isn't a declared domain error — *must* be handled in the loader/action, or
+* to a 500. **Any other error** - a service-specific error the route consumes that
+* isn't a declared domain error - *must* be handled in the loader/action, or
 * `makeLoader`/`makeAction` fails to type-check.
 *
 * Pass a `runtime` (a `ManagedRuntime`, e.g. from `ManagedRuntime.make(AppLayer)`)
 * to provide your app's services once. Loader/action effects may then require those
-* services directly — no per-call `Effect.provide`:
+* services directly - no per-call `Effect.provide`:
 *
 * ```ts
 * const { makeLoader, makeAction } = makeEffectRouteFactory<DomainErrors>()(() => ({
@@ -120,9 +163,9 @@ const processRouteError = (e) => {
 * generated `Route.MiddlewareFunction` (a type argument, since middleware has no
 * separate args-only type) to type `args` and `next`'s result from that route; it
 * defaults to React Router's own `MiddlewareFunction`. The `next` handed to the
-* effect is `() => Effect.Effect<Result, FailureResponse>` — call it with `yield*`
+* effect is `() => Effect.Effect<Result, FailureResponse>` - call it with `yield*`
 * to run the rest of the chain, and a downstream throw (e.g. a nested loader's
-* redirect) surfaces as a typed failure instead of a rejected promise:
+* redirect) becomes a typed failure instead of a rejected promise:
 *
 * ```ts
 * const middleware = makeMiddleware<Route.MiddlewareFunction>((args, next) =>
@@ -138,7 +181,7 @@ function makeEffectRouteFactory() {
 	return function defineErrorHandlers(builder) {
 		const config = builder(Respond);
 		const runtime = config.runtime;
-		const requestContextKey = config.requestContext;
+		const storeKey = config.requestContext ?? defaultRequestContext;
 		const Respond$1 = {
 			...config.respond,
 			...Respond
@@ -150,7 +193,7 @@ function makeEffectRouteFactory() {
 		* (registered domain errors, library route errors, respondables, or the 500
 		* default), provides the per-request context, and executes against the
 		* configured runtime. Shared by `makeLoader`/`makeAction` and `makeMiddleware`
-		* — they differ only in how they build the effect and what `context` they read.
+		* - they differ only in how they build the effect and what `context` they read.
 		*/
 		function runProgram(effect, context, signal) {
 			const program = effect.pipe(Effect.catchIf((_e) => true, (e) => {
@@ -163,7 +206,8 @@ function makeEffectRouteFactory() {
 				if (isFailureResponse(e)) return Effect.fail(e);
 				return internalServerError();
 			}));
-			const provided = requestContextKey ? Effect.provideContext(program, context.get(requestContextKey)) : program;
+			const store = readRequestStore(context);
+			const provided = store === void 0 ? program : Effect.provideContext(program, store);
 			return runtime ? runtime.runPromise(provided, { signal }) : Effect.runPromise(provided, { signal });
 		}
 		function makeLoaderOrAction(fn) {
@@ -176,13 +220,13 @@ function makeEffectRouteFactory() {
 		* args-only type) to type `args`, `next` and the result from that route; it defaults
 		* to React Router's own `MiddlewareFunction`.
 		*
-		* The errors the library deals with for a loader/action it deals with here too —
-		* declared domain errors, library route errors and respondables — plus the
+		* The errors the library deals with for a loader/action it deals with here too -
+		* declared domain errors, library route errors and respondables - plus the
 		* `FailureResponse` `next()` fails with. Anything else must be handled in the effect,
 		* as must any service neither the `runtime` nor the `requestContext` provides.
 		*
-		* The wrapper is typed as the route's own middleware — `(args, next) =>
-		* Promise<Result | undefined>` — so it drops straight into a
+		* The wrapper is typed as the route's own middleware - `(args, next) =>
+		* Promise<Result | undefined>` - so it drops straight into a
 		* `Route.MiddlewareFunction[]`. A handler that recovers (`Respond.early`) resolves
 		* with `data(...)`, which react-router's server middleware pipeline turns into the
 		* short-circuit `Response`.
@@ -190,21 +234,65 @@ function makeEffectRouteFactory() {
 		function makeMiddleware(fn) {
 			const run = fn;
 			return (args, next) => {
-				const effectNext = () => Effect.tryPromise({
-					try: next,
-					catch: (e) => e
-				});
 				const { context, request } = args;
+				const effectNext = makeEffectNext(context, next);
 				return runProgram(run(args, effectNext), context, request.signal);
 			};
 		}
+		/**
+		* Reads the request's effect context from the router context. A test that
+		* passes args without a router context gets none, as before.
+		*/
+		function readRequestStore(context) {
+			return typeof context?.get === "function" ? context.get(storeKey) : void 0;
+		}
+		/**
+		* Wraps React Router's `next` as an effect. Before it runs the rest of the
+		* chain, it adds to the request's effect context what the calling fiber
+		* provides beyond the context the middleware started with: services it
+		* provides around `next()`, log annotations, and its current span. Updates
+		* the middleware made with `context.set` stay. A downstream rejection is
+		* already a finished response, so it fails with that response as-is.
+		*/
+		function makeEffectNext(context, next) {
+			const started = readRequestStore(context);
+			return () => Effect.withFiber((fiber) => {
+				if (started !== void 0) context.set(storeKey, Context.merge(context.get(storeKey), providedSince(started, fiber.context)));
+				return Effect.tryPromise({
+					try: next,
+					catch: (e) => e
+				});
+			});
+		}
+		/** Runs a loader or action's result: an Effect through the error model, anything else as-is. */
+		function runResult(result, args) {
+			return Effect.isEffect(result) ? runProgram(result, args.context, args.request.signal) : result;
+		}
+		const actionMeta = config.actionMeta;
 		return {
 			makeLoader: makeLoaderOrAction,
 			makeAction: makeLoaderOrAction,
 			makeMiddleware,
-			Respond: Respond$1
+			Respond: Respond$1,
+			/** The route runner the server adapter applies to every route module. */
+			handlers: {
+				loader: (fn) => async (args) => runResult(fn(args), args),
+				action: (fn) => async (args) => {
+					const result = await runResult(fn(args), args);
+					return actionMeta === void 0 ? result : attachActionMeta(result, actionMeta(args));
+				},
+				middleware: (fn) => async (args, next) => {
+					const routeArgs = args;
+					return runResult(fn({
+						...args,
+						next: makeEffectNext(routeArgs.context, next)
+					}, next), routeArgs);
+				},
+				requestContext: storeKey
+			},
+			/** Type-only: what the adapter's route check and `Register` read. */
+			"~types": void 0
 		};
 	};
 }
-//#endregion
-export { ReturnableDataError, ThrowableDataError, ThrowableRedirectError, isRouteError, makeEffectRouteFactory };
+export { ReturnableDataError, ThrowableDataError, ThrowableRedirectError, actionMetaKey, isRouteError, makeEffectRouteFactory };

package/dist/rolldown-runtime-D8jQpDG7.mjs

@@ -0,0 +1,12 @@
+// \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+export { __exportAll as t };