react-router-effect 2.1.0 → 2.3.0

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-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 };
+import { A as ThrowableRedirectError, C as RouteHandlers, D as AnyRouteError, E as makeEffectRouteFactory, M as WithRouteMeta, N as routeMetaKey, O as ReturnableDataError, S as RequestContextKey, T as RouteResult, _ as FactoryTypes, a as RegisteredMeta, c as Serialize, d as deferredFailureMessage, f as DeferHandled, g as ErrorHandler, h as EffectNext, i as Register, j as isRouteError, k as ThrowableDataError, l as DeferDiagnose, m as EffectMiddlewareArgs, n as EffectData, o as RegisteredRecover, p as DeferRecoverOf, r as EffectRouteArgs, s as RouteData, t as BrandData, u as DeferredPromise, w as RouteMetaArgs } from "./route-data-ByiuG-Yb.mjs";
+export { type AnyRouteError, type BrandData, type DeferDiagnose, type DeferHandled, type DeferRecoverOf, type DeferredPromise, 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 RouteMetaArgs, type RouteResult, type Serialize, ThrowableDataError, ThrowableRedirectError, type WithRouteMeta, deferredFailureMessage, isRouteError, makeEffectRouteFactory, routeMetaKey };

package/dist/index.mjs

@@ -1,12 +1,15 @@
-import { Context, Data, Effect, Predicate } from "effect";
-import { createContext, data, redirect } from "react-router";
+import { Cause, Context, Data, Effect, Exit, Option, Predicate, Scope } from "effect";
+import { UNSAFE_ErrorResponseImpl, createContext, data, redirect } from "react-router";
 import { HttpServerRespondable, HttpServerResponse } from "effect/http";
-// 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;
+// src/route-meta.ts
+/** The key that holds the metadata in loader and action data. */
+const routeMetaKey = "__meta";
+/**
+* True for a `data(...)` wrapper, by the same test React Router applies. A
+* class test fails when the app and the adapter load different copies of
+* React Router, as under the Vite dev server.
+*/
+const isDataWithResponseInit = (value) => Predicate.hasProperty(value, "type") && Predicate.hasProperty(value, "data") && Predicate.hasProperty(value, "init") && value.type === "DataWithResponseInit";
 /** True for a plain object, which can be copied without losing behavior. */
 const isPlainRecord = (value) => {
 	if (!Predicate.isObject(value) || Array.isArray(value)) return false;
@@ -14,21 +17,21 @@ const isPlainRecord = (value) => {
 	return prototype === Object.prototype || prototype === null;
 };
 /**
-* Attaches `meta` to the action result. A plain record gets a copy with the
+* Attaches `meta` to a loader or 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) => {
+const attachRouteMeta = (value, meta) => {
 	if (isDataWithResponseInit(value)) {
 		if (!isPlainRecord(value.data)) return value;
 		return data({
 			...value.data,
-			[actionMetaKey]: meta
+			[routeMetaKey]: meta
 		}, value.init ?? void 0);
 	}
 	return isPlainRecord(value) ? {
 		...value,
-		[actionMetaKey]: meta
+		[routeMetaKey]: meta
 	} : value;
 };
 // src/errors.ts
@@ -72,6 +75,84 @@ 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;
+// src/defer.ts
+/**
+* The scope that deferred work forks into. The route runner sets it for each
+* loader or action run, and closes it when the request aborts or the route
+* Effect fails. Outside a route runner it is unset, and deferred work runs
+* detached.
+*/
+const DeferScope = Context.Reference("react-router-effect/DeferScope", { defaultValue: () => void 0 });
+/**
+* Gives a route Effect a scope for its deferred work. The scope closes, and
+* interrupts the deferred fibers, when `signal` aborts or the Effect fails: a
+* failed loader sends no data, so no `<Await>` waits for the work.
+*/
+const withDeferScope = (effect, signal) => Effect.suspend(() => {
+	const scope = Scope.makeUnsafe("parallel");
+	const close = (exit) => Scope.close(scope, exit);
+	signal.addEventListener("abort", () => Effect.runFork(close(Exit.interrupt())), { once: true });
+	return effect.pipe(Effect.provideService(DeferScope, scope), Effect.onError((cause) => close(Exit.failCause(cause))));
+});
+/**
+* The message every deferred rejection has. The server logs the cause.
+*
+* @stability unstable
+*/
+const deferredFailureMessage = "Deferred route data failed";
+/**
+* The rejection the browser gets for a defect or an interrupt: a constant
+* message and no stack, in every server mode. React Router removes server
+* details only in production.
+*/
+const deferredFailure = () => {
+	const error = /* @__PURE__ */ new Error(deferredFailureMessage);
+	error.stack = void 0;
+	return error;
+};
+/**
+* Forks `self` into the run's defer scope and gives a promise of its result.
+* A failure rejects the promise with its `ErrorResponse`, which React Router
+* streams to `useAsyncError`. A defect or interrupt rejects it with
+* `deferredFailure`, and the server logs a defect's full cause.
+*/
+const forkDeferred = (self) => Effect.gen(function* () {
+	const scope = yield* DeferScope;
+	const work = self.pipe(Effect.tapCause((cause) => Cause.hasDies(cause) ? Effect.logError(deferredFailureMessage, cause) : Effect.void));
+	const fiber = yield* scope === void 0 ? Effect.forkDetach(work) : Effect.forkIn(work, scope);
+	const promise = new Promise((resolve, reject) => {
+		fiber.addObserver((exit) => {
+			if (Exit.isSuccess(exit)) return resolve(exit.value);
+			reject(Cause.hasDies(exit.cause) ? deferredFailure() : Option.getOrElse(Cause.findErrorOption(exit.cause), deferredFailure));
+		});
+	});
+	promise.catch(() => void 0);
+	return promise;
+});
+/** A thrown `data(...)` as an `ErrorResponse`, with React Router's defaults. */
+const toErrorResponse = (thrown) => new UNSAFE_ErrorResponseImpl(thrown.init?.status ?? 500, thrown.init?.statusText ?? "Internal Server Error", thrown.data);
+/**
+* A library route error raised in deferred work: `Respond.early` resolves the
+* promise with its value, and `Respond.throw` rejects it with an
+* `ErrorResponse`. A redirect cannot happen after the response started, so it
+* is a defect.
+*/
+const deferRouteError = (e) => {
+	if (e instanceof ReturnableDataError) return Effect.succeed(e.data);
+	if (e instanceof ThrowableDataError) return Effect.fail(toErrorResponse(data(e.data, e.init)));
+	return Effect.die(e);
+};
+/**
+* A handler's `Effect.fail(response)` in deferred work, as an `ErrorResponse`:
+* a `data(...)` as React Router converts a thrown one, and a `Response` with
+* its body read as React Router reads it, JSON or text. A redirect is a defect.
+*/
+const deferFailureResponse = (failure) => {
+	if (!(failure instanceof Response)) return Effect.fail(toErrorResponse(failure));
+	if (failure.status >= 300 && failure.status < 400) return Effect.die(failure);
+	const isJson = /\bapplication\/json\b/.test(failure.headers.get("Content-Type") ?? "");
+	return Effect.promise(() => isJson && failure.body !== null ? failure.json() : failure.text()).pipe(Effect.flatMap((body) => Effect.fail(new UNSAFE_ErrorResponseImpl(failure.status, failure.statusText, body))));
+};
 // src/factory.ts
 const internalServerError = () => Effect.fail(new Response("Internal Server Error", { status: 500 }));
 /**
@@ -187,7 +268,8 @@ function makeEffectRouteFactory() {
 			...Respond
 		};
 		const userHandlers = config.errorHandlers ?? {};
-		const isUserError = (e) => typeof e === "object" && e !== null && "_tag" in e && e._tag in userHandlers;
+		/** The tags of the registered domain errors. */
+		const userTags = Object.keys(userHandlers);
 		/**
 		* Runs a handler's effect to completion: dispatches its whole error channel
 		* (registered domain errors, library route errors, respondables, or the 500
@@ -196,9 +278,9 @@ function makeEffectRouteFactory() {
 		* - 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) => {
-				if (isUserError(e)) {
-					const out = userHandlers[e._tag](e);
+			const program = withDeferScope(effect, signal).pipe(Effect.catchIf((_e) => true, (e) => {
+				for (const tag of userTags) if (Predicate.isTagged(e, tag)) {
+					const out = userHandlers[tag](e);
 					return isRouteError(out) ? processRouteError(out) : out;
 				}
 				if (isRouteError(e)) return processRouteError(e);
@@ -268,19 +350,74 @@ function makeEffectRouteFactory() {
 		function runResult(result, args) {
 			return Effect.isEffect(result) ? runProgram(result, args.context, args.request.signal) : result;
 		}
-		const actionMeta = config.actionMeta;
+		/**
+		* A failure of deferred work, through the error handlers: a recovered
+		* value resolves the promise, a thrown response rejects it with an
+		* `ErrorResponse`. Anything else, such as a domain error with no handler,
+		* is a defect: the promise rejects with no server details.
+		*/
+		function dispatchDeferred(e) {
+			for (const tag of userTags) if (Predicate.isTagged(e, tag)) {
+				const out = userHandlers[tag](e);
+				return isRouteError(out) ? deferRouteError(out) : out.pipe(Effect.catch(deferFailureResponse));
+			}
+			return isRouteError(e) ? deferRouteError(e) : Effect.die(e);
+		}
+		/**
+		* Starts an Effect without waiting for it, and gives a promise of its
+		* result for loader data. React Router streams the promise to `<Await>`.
+		*
+		* The work gets the services and the span of the Effect that defers it.
+		* It keeps running after the loader returns, and is interrupted when the
+		* request aborts or the loader fails. A client-side navigation away does
+		* not abort the request, so the work then runs until it ends or the stream
+		* times out.
+		*
+		* The work may fail only with the factory's domain errors,
+		* `Respond.early` and `Respond.throw`. The error handlers turn them into
+		* the promise's value, or an `ErrorResponse` for `useAsyncError`, as they
+		* do for a loader. A handler that redirects, a domain error with no
+		* handler, a defect or an interrupt rejects the promise with an error that
+		* holds no server details, and the server logs the full cause.
+		*
+		* ```ts
+		* export const { Respond, defer } = routeFactory;
+		*
+		* export const loader = Effect.fn("loader")(function* () {
+		*   const user = yield* Users.current;
+		*   return {
+		*     user,
+		*     reviews: yield* defer(Reviews.list(user.id)),
+		*     stats: yield* Stats.load.pipe(
+		*       Effect.catchTag("StatsUnavailable", () => Effect.succeed(null)),
+		*       defer,
+		*     ),
+		*   };
+		* });
+		* ```
+		*
+		* @stability unstable
+		*/
+		function defer(self) {
+			const work = self.pipe(Effect.catch(dispatchDeferred));
+			return forkDeferred(work);
+		}
+		const routeMeta = config.routeMeta;
+		/** Runs a loader or action's result and attaches the route metadata to its data. */
+		async function withRouteMeta(result, args) {
+			const resolved = await runResult(result, args);
+			return routeMeta === void 0 ? resolved : attachRouteMeta(resolved, routeMeta(args));
+		}
 		return {
 			makeLoader: makeLoaderOrAction,
 			makeAction: makeLoaderOrAction,
 			makeMiddleware,
 			Respond: Respond$1,
+			defer,
 			/** 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));
-				},
+				loader: (fn) => async (args) => await withRouteMeta(fn(args), args),
+				action: (fn) => async (args) => await withRouteMeta(fn(args), args),
 				middleware: (fn) => async (args, next) => {
 					const routeArgs = args;
 					return runResult(fn({
@@ -295,4 +432,4 @@ function makeEffectRouteFactory() {
 		};
 	};
 }
-export { ReturnableDataError, ThrowableDataError, ThrowableRedirectError, actionMetaKey, isRouteError, makeEffectRouteFactory };
+export { ReturnableDataError, ThrowableDataError, ThrowableRedirectError, deferredFailureMessage, isRouteError, makeEffectRouteFactory, routeMetaKey };

package/dist/{route-data-MgSnnR33.d.mts → route-data-ByiuG-Yb.d.mts}

@@ -1,22 +1,22 @@
-import { Context, Effect, ManagedRuntime } from "effect";
+import { Context, Effect, ManagedRuntime, Scope } 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";
+/** The key that holds the metadata in loader and action data. */
+declare const routeMetaKey = "__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;
+type RecordWithMeta<T, Meta> = T extends Record<string, unknown> ? Omit<T, typeof routeMetaKey> & {
+  [routeMetaKey]?: Meta;
 } : T;
 /**
- * The type of action data after metadata is attached. A `data(...)` wrapper
+ * The type of loader or 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>;
+type WithRouteMeta<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>;
@@ -144,6 +144,25 @@ type ErrorHandlers<DomainError extends Tagged, Returns> = { [Tag in keyof Return
 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];
+/**
+ * The errors the factory's `defer` handles in deferred work: the declared
+ * domain errors, and `Respond.early` / `Respond.throw`. A redirect is not one
+ * of them: it cannot happen after the response started.
+ *
+ * @stability unstable
+ */
+type DeferHandled<DomainError> = DomainError | ReturnableDataError<unknown> | ThrowableDataError<unknown>;
+/**
+ * What a deferred promise resolves with when the work fails with `E`: the
+ * value of a `Respond.early` raised directly, and what the registered
+ * handlers recover. Unlike loader data, a recovered `Respond.early` gives its
+ * value without the `data(...)` wrapper: a promise has no response to set.
+ *
+ * @stability unstable
+ */
+type DeferRecoverOf<DomainError extends Tagged, Returns, E> = ReturnableBodyOf<E> | { [Tag in keyof Returns]: [Extract<E, Extract<DomainError, {
+  readonly _tag: Tag;
+}>>] extends [never] ? never : (Returns[Tag] extends ReturnableDataError<infer B> ? 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:
@@ -209,6 +228,12 @@ type Diagnose<E, R, DomainError, Provided, AlsoHandled = never> = IsAny<E> exten
  * 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
@@ -222,7 +247,7 @@ type Diagnose<E, R, DomainError, Provided, AlsoHandled = never> = IsAny<E> exten
  *
  * export const requestContext: RequestContextKey<RequestContext> = createContext();
  *
- * // middleware:
+ * // 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) }));
@@ -232,8 +257,8 @@ type Diagnose<E, R, DomainError, Provided, AlsoHandled = never> = IsAny<E> exten
  * ```
  */
 type RequestContextKey<ReqServices> = RouterContext<Context.Context<ReqServices>>;
-/** What `actionMeta` reads: the request and the router context of the action. */
-interface ActionMetaArgs {
+/** What `routeMeta` reads: the request and the router context of the loader or action. */
+interface RouteMetaArgs {
   readonly request: Request;
   readonly context: Readonly<RouterContextProvider>;
 }
@@ -399,27 +424,61 @@ declare function makeEffectRouteFactory<DomainError extends Tagged = never>(): <
    */
   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.
+   * Request-scoped metadata to attach to the data of every loader and action
+   * under `__meta`, read after the function resolves. The server adapter
+   * attaches it to every loader and action it runs, including plain functions
+   * and `makeLoader` / `makeAction` wrappers. A thrown result gets none. Only
+   * plain records and `data(...)` bodies include it; other values are returned
+   * unchanged.
    */
-  actionMeta?: (args: ActionMetaArgs) => Meta;
+  routeMeta?: (args: RouteMetaArgs) => 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>>;
+  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<WithRouteMeta<A | DirectRecover<E> | RecoverOf<DomainError, Returns, E>, Meta>>;
+  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<WithRouteMeta<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;
+  defer: <A, E, R>(self: Effect.Effect<A, E, R> & DeferDiagnose<E, DeferHandled<DomainError>>) => Effect.Effect<DeferredPromise<A | DeferRecoverOf<DomainError, Returns, E>>, never, R>;
   /** 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>;
 };
+/**
+ * The compile-time diagnostic of the factory's `defer`. A deferred Effect
+ * runs after the response started, so a failure cannot change the response.
+ * The Effect must handle every error it can fail with before it is deferred,
+ * except the `Handled` ones, which the error handlers turn into a value or an
+ * `ErrorResponse`. Resolves to `unknown` (a no-op intersection) when every
+ * error is handled.
+ *
+ * @stability unstable
+ */
+type DeferDiagnose<E, Handled> = IsAny<E> extends true ? unknown : [Exclude<E, Handled>] extends [never] ? unknown : {
+  "react-router-effect": "A deferred effect runs after the response started, so it can fail only with the factory's domain errors, Respond.early and Respond.throw. Handle the other errors before defer: recover them into data (e.g. Effect.catchTag), or make them defects with Effect.orDie.";
+  unhandledErrors: NameError<Exclude<E, Handled>>;
+};
+/**
+ * The promise that the factory's `defer` gives: a `Promise` of the deferred Effect's
+ * success, which React Router streams to `<Await>`. The work started when the
+ * Effect was deferred.
+ *
+ * It is a type of its own so that an Effect that succeeds with it states
+ * that the promise is not awaited on purpose. The language service's
+ * `promiseInEffectSuccess` rule reports only the global `Promise` type.
+ *
+ * @stability unstable
+ */
+interface DeferredPromise<A> extends Promise<A> {}
+/**
+ * The message every deferred rejection has. The server logs the cause.
+ *
+ * @stability unstable
+ */
+declare const deferredFailureMessage = "Deferred route data failed";
 /**
  * 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
@@ -440,8 +499,8 @@ declare function makeEffectRouteFactory<DomainError extends Tagged = never>(): <
  *   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> };
+ *     // What `routeMeta` returns.
+ *     routeMeta: { realtimeEventIds: ReadonlyArray<string> };
  *   }
  * }
  * ```
@@ -451,9 +510,9 @@ interface Register$1 {}
 type RegisteredRecover = Register$1 extends {
   readonly recover: infer Recover;
 } ? Recover : {};
-/** The registered action metadata, or `never` when there is none. */
+/** The registered route metadata, or `never` when there is none. */
 type RegisteredMeta = Register$1 extends {
-  readonly actionMeta: infer Meta;
+  readonly routeMeta: 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 {
@@ -468,9 +527,9 @@ 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.
+ * React Router serializes them, with the registered route metadata.
  */
-type EffectData<A, E> = WithActionMeta<Serialize<A | Recovered<E>>, RegisteredMeta>;
+type EffectData<A, E> = WithRouteMeta<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
@@ -507,7 +566,7 @@ type Unwrapped<A> = A extends Response ? never : A extends UNSAFE_DataWithRespon
  * 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>;
+type BrandData<A, E> = [A] extends [never] ? WithRouteMeta<Recovered<E>, RegisteredMeta> : [A] extends [void] ? unknown : WithRouteMeta<Unwrapped<A> | Recovered<E>, RegisteredMeta>;
 declare module "effect/Effect" {
   interface Effect<out A, out E, out R> {
     readonly unstable__ReactRouter_SerializesTo: [BrandData<A, E>];
@@ -540,4 +599,4 @@ type EffectRouteArgs<Args extends {
 }> = 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 };
+export { ThrowableRedirectError as A, RouteHandlers as C, AnyRouteError as D, makeEffectRouteFactory as E, WithRouteMeta as M, routeMetaKey as N, ReturnableDataError as O, RequestContextKey as S, RouteResult as T, FactoryTypes as _, RegisteredMeta as a, LibraryHandled as b, Serialize as c, deferredFailureMessage as d, DeferHandled as f, ErrorHandler as g, EffectNext as h, Register$1 as i, isRouteError as j, ThrowableDataError as k, DeferDiagnose as l, EffectMiddlewareArgs as m, EffectData as n, RegisteredRecover as o, DeferRecoverOf as p, EffectRouteArgs as r, RouteData as s, BrandData as t, DeferredPromise as u, FailureResponse as v, RouteMetaArgs as w, NameError as x, IsAny as y };