react-router-effect 2.0.0 → 2.2.0

package/dist/route-data-CWBxnNAA.d.mts

@@ -0,0 +1,549 @@
+import { Context, Effect, ManagedRuntime } from "effect";
+import { ActionFunctionArgs, LoaderFunctionArgs, MiddlewareFunction, RouterContext, RouterContextProvider, UNSAFE_DataWithResponseInit, useLoaderData } from "react-router";
+import { HttpServerRespondable } from "effect/http";
+/** The key that holds the metadata in action data. */
+declare const actionMetaKey = "__meta";
+/**
+ * Adds optional metadata to a record. Only records get metadata, because a
+ * structural type cannot tell a plain object from a class instance, and other
+ * values (strings, arrays, `Response`s) have nowhere to put it.
+ */
+type RecordWithMeta<T, Meta> = T extends Record<string, unknown> ? Omit<T, typeof actionMetaKey> & {
+  [actionMetaKey]?: Meta;
+} : T;
+/**
+ * The type of action data after metadata is attached. A `data(...)` wrapper
+ * gets metadata on its body. With no configured metadata (`Meta` is `never`)
+ * the data is unchanged.
+ */
+type WithActionMeta<T, Meta> = [Meta] extends [never] ? T : T extends UNSAFE_DataWithResponseInit<infer Body> ? UNSAFE_DataWithResponseInit<RecordWithMeta<Body, Meta>> : RecordWithMeta<T, Meta>;
+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. */
+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`. */
+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`. */
+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
+ * passes 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 pass `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. */
+declare const isRouteError: (value: unknown) => value is AnyRouteError;
+/** 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 handler map as a whole) 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` lists them.
+ *  - **Missing requirement** - the effect requires a service that neither the
+ *    `runtime` nor the `requestContext` provides; `missingRequirements` lists them.
+ *
+ * The message is in an *inline* object literal (no named alias) so tsc/tsgo print
+ * its text verbatim rather than collapsing it to an alias name.
+ */
+/**
+ * Lists 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 actual mistake. Guarding on this and bailing to `unknown` lets tsc's own,
+ * on-site error appear 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.
+ *
+ * With the server adapter, do not set it to a new context. The adapter sets it
+ * to the request fiber's context before React Router runs, and a new context
+ * replaces those services, such as `HttpServerRequest` and the server span.
+ * Provide request services with a router middleware on `ReactRouter.routes`.
+ * The middleware below is for an app without the adapter.
+ *
+ * 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, in an app without the server adapter:
+ * 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>>;
+/** What `actionMeta` reads: the request and the router context of the action. */
+interface ActionMetaArgs {
+  readonly request: Request;
+  readonly context: Readonly<RouterContextProvider>;
+}
+/** The `next` an effect middleware gets: runs the rest of the chain as an effect. */
+type EffectNext<Result> = () => Effect.Effect<Result, FailureResponse>;
+/**
+ * The arguments of an effect middleware: React Router's own middleware args,
+ * plus `next` as an effect. The second parameter stays React Router's
+ * promise-returning `next`, so a plain middleware works unchanged.
+ */
+type EffectMiddlewareArgs<Middleware extends AnyMiddlewareFunction = MiddlewareFunction> = MiddlewareArgsOf<Middleware> & {
+  readonly next: EffectNext<MiddlewareResultOf<Middleware>>;
+};
+/** The router context and signal every route function receives. */
+interface RouteArgs {
+  readonly request: Request;
+  readonly context: Readonly<RouterContextProvider>;
+}
+/**
+ * What a route function resolves with: an Effect's success, or the awaited
+ * value. A failure that a handler recovers resolves with its data too.
+ */
+type RouteResult<Out> = Out extends Effect.Effect<infer A, infer _E, infer _R> ? A : Awaited<Out>;
+/**
+ * Turns route functions into the promise-returning functions React Router
+ * calls. An Effect result runs through the factory's error model with the
+ * factory's runtime and the request's effect context; any other result passes
+ * through. The server adapter applies these to every route module, and tests
+ * can call them directly.
+ *
+ * Each is generic over the route's own args, so a test can pass a route's
+ * `Route.LoaderArgs` without a cast. React Router always supplies `request`
+ * and `context`.
+ */
+interface RouteHandlers {
+  readonly loader: <Args extends RouteArgs, Out>(fn: (args: Args) => Out) => (args: Args) => Promise<RouteResult<Out>>;
+  readonly action: <Args extends RouteArgs, Out>(fn: (args: Args) => Out) => (args: Args) => Promise<RouteResult<Out>>;
+  /**
+   * The wrapped middleware takes React Router's args, without `next`: the
+   * runner adds `next` as an effect.
+   */
+  readonly middleware: <Args extends RouteArgs, Next extends () => Promise<unknown>, Out>(fn: (args: Args, next: Next) => Out) => (args: Omit<Args, "next">, next: Next) => Promise<RouteResult<Out> | undefined>;
+  /** The router context key that holds the request's effect context. */
+  readonly requestContext: RouterContext<Context.Context<never>>;
+}
+/**
+ * The types a factory exposes for the server adapter's route check and for
+ * `Register`. Never present at runtime.
+ */
+interface FactoryTypes<DomainError, Returns, Services, Meta> {
+  readonly DomainError: DomainError;
+  readonly Returns: Returns;
+  readonly Services: Services;
+  readonly Meta: Meta;
+}
+/**
+ * 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) becomes 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();
+ *   }),
+ * );
+ * ```
+ */
+declare function makeEffectRouteFactory<DomainError extends Tagged = never>(): <const Returns extends HandlerReturns<DomainError> = {}, RServices = never, ReqServices = never, const ExtraRespond extends Record<string, (...args: never[]) => unknown> = {}, Meta = never>(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;
+  /**
+   * Request-scoped metadata to attach to every action's data under `__meta`,
+   * read after the action resolves. The server adapter attaches it to every
+   * action it runs, including plain functions and `makeAction` wrappers. A
+   * thrown result gets none. Only plain records and `data(...)` bodies include
+   * it; other values are returned unchanged.
+   */
+  actionMeta?: (args: ActionMetaArgs) => Meta;
+}) => {
+  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<WithActionMeta<A | DirectRecover<E> | RecoverOf<DomainError, Returns, E>, Meta>>;
+  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;
+  /** The route runner the server adapter applies to every route module. */
+  handlers: RouteHandlers;
+  /** Type-only: what the adapter's route check and `Register` read. */
+  "~types": FactoryTypes<DomainError, Returns, RServices | ReqServices, Meta>;
+};
+/**
+ * Registers what the app's route factory turns failures into, so that a
+ * loader or action written as a plain `Effect.fn` types its data the way a
+ * `makeLoader` call would.
+ *
+ * A `makeLoader` call sees the factory's handlers as type arguments. A plain
+ * Effect loader does not, so without this an error that a handler recovers
+ * into data, such as a form error that becomes `{ reply }`, would be missing
+ * from `useLoaderData`, `useFetcher` and `Route.ComponentProps`.
+ *
+ * Declare the types directly rather than reading them from the factory's
+ * value: the factory's type depends on every Effect in the app, and so on
+ * this registration. The server adapter's `RouteEffectCheck` fails when the
+ * registration and the factory disagree.
+ *
+ * ```ts
+ * declare module "react-router-effect" {
+ *   interface Register {
+ *     // Each error tag a handler recovers, and the data it recovers into.
+ *     recover: { FormValidationError: { reply: SubmissionResponse } };
+ *     // What `actionMeta` returns.
+ *     actionMeta: { realtimeEventIds: ReadonlyArray<string> };
+ *   }
+ * }
+ * ```
+ */
+interface Register$1 {}
+/** The registered recover map: error tag to recovered data. */
+type RegisteredRecover = Register$1 extends {
+  readonly recover: infer Recover;
+} ? Recover : {};
+/** The registered action metadata, or `never` when there is none. */
+type RegisteredMeta = Register$1 extends {
+  readonly actionMeta: infer Meta;
+} ? Meta : never;
+/** What a failure of type `E` recovers into: `Respond.early` bodies and registered handlers. */
+type Recovered<E> = (E extends ReturnableDataError<infer Body> ? Body : never) | (E extends {
+  readonly _tag: infer Tag extends keyof RegisteredRecover;
+} ? RegisteredRecover[Tag] : never);
+/**
+ * React Router's own serialization of loader data. React Router does not
+ * export it, but a zero-argument function is a server loader to its public
+ * `useLoaderData` type, so this gives the same type.
+ */
+type Serialize<T> = ReturnType<typeof useLoaderData<() => Promise<T>>>;
+/**
+ * The data an Effect that succeeds with `A` and fails with `E` gives the
+ * component: its success and what its failures recover into, serialized as
+ * React Router serializes them, with the registered action metadata.
+ */
+type EffectData<A, E> = WithActionMeta<Serialize<A | Recovered<E>>, RegisteredMeta>;
+/**
+ * The route data of a loader or action, for React Router's hooks:
+ * `useFetcher<RouteData<typeof action>>()`. A function that returns an Effect
+ * gives its `EffectData`. Any other function passes through, so the hook
+ * reads it as it always has.
+ */
+type RouteData<F> = F extends ((...args: never[]) => Effect.Effect<infer A, infer E, infer _R>) ? EffectData<A, E> : F;
+/**
+ * Loader data as React Router reads it before serializing: a `Response` adds
+ * nothing, and a `data(...)` wrapper gives its body.
+ */
+type Unwrapped<A> = A extends Response ? never : A extends UNSAFE_DataWithResponseInit<infer Body> ? Body : A;
+/**
+ * The data React Router reads from an Effect through `unstable_SerializesTo`.
+ *
+ * TypeScript compares this brand whenever it relates two Effects
+ * structurally, so it must keep the subtype order of `A` and `E`: when
+ * `Effect<A1, E1>` is assignable to `Effect<A2, E2>`, `BrandData<A1, E1>` must
+ * be assignable to `BrandData<A2, E2>`. React Router's `Serialize` does not
+ * (it turns `unknown` into `undefined`), so the brand holds the data before
+ * serialization; `RouteData` applies the actual serialization.
+ *
+ * - A `void` or `any` success gives `unknown`, which accepts every other brand.
+ * - A `never` success gives only what the failures recover into.
+ *
+ * `Effect` declares its parameters `out`, and TypeScript verifies that
+ * annotation against this member, and against it again in every Effect type
+ * that declares variance (`Exit`, `Config`, ...). It relates two conditional
+ * types branch by branch when their check types are related and their
+ * `extends` types are identical. So every conditional here, and in the types
+ * it uses, checks `A` or `E` (or a tuple of one) against a type that does not
+ * depend on them. A conditional with `A` or `E` on its `extends` side, such as
+ * `0 extends 1 & A` to detect `any`, fails the verification: a consumer that
+ * checks library types (`skipLibCheck: false`) then gets TS2636 in Effect's own
+ * declarations. `test/consumer` checks the built package for that.
+ */
+type BrandData<A, E> = [A] extends [never] ? WithActionMeta<Recovered<E>, RegisteredMeta> : [A] extends [void] ? unknown : WithActionMeta<Unwrapped<A> | Recovered<E>, RegisteredMeta>;
+declare module "effect/Effect" {
+  interface Effect<out A, out E, out R> {
+    readonly unstable__ReactRouter_SerializesTo: [BrandData<A, E>];
+  }
+}
+declare module "effect/Cause" {
+  interface YieldableError {
+    readonly unstable__ReactRouter_SerializesTo: [never];
+  }
+}
+/**
+ * Route args for a loader or action written as a plain `Effect.fn`, such as
+ * `EffectRouteArgs<Route.ActionArgs>`. It keeps hooks that take `typeof loader`
+ * or `typeof action` typed, such as `useFetcher<typeof action>()`.
+ *
+ * Those hooks read a function's data through React Router's `SerializeFrom`.
+ * It treats a function whose argument extends `ClientDataFunctionArgs` as a
+ * client function, and gives its raw return value without serialization.
+ * Typegen's `Route.LoaderArgs` and `Route.ActionArgs` have the same members as
+ * `ClientDataFunctionArgs`, so a server function typed with them matches too.
+ * For an Effect, the raw return value is the Effect itself: only serialization
+ * reads the `unstable_SerializesTo` brand.
+ *
+ * `pattern` is optional here, so the argument no longer matches and the hooks
+ * read the brand. `Route.ComponentProps` and `RouteData` don't go through
+ * `SerializeFrom`, so they are correct without it.
+ */
+type EffectRouteArgs<Args extends {
+  readonly pattern: string;
+}> = Omit<Args, "pattern"> & {
+  readonly pattern?: string;
+};
+export { ReturnableDataError as C, WithActionMeta as D, isRouteError as E, actionMetaKey as O, AnyRouteError as S, ThrowableRedirectError as T, NameError as _, RegisteredMeta as a, RouteResult as b, Serialize as c, EffectNext as d, ErrorHandler as f, LibraryHandled as g, IsAny as h, Register$1 as i, ActionMetaArgs as l, FailureResponse as m, EffectData as n, RegisteredRecover as o, FactoryTypes as p, EffectRouteArgs as r, RouteData as s, BrandData as t, EffectMiddlewareArgs as u, RequestContextKey as v, ThrowableDataError as w, makeEffectRouteFactory as x, RouteHandlers as y };