one 2.10.0 → 2.11.0

package/src/typed-routes/searchSchemaEntries.ts

@@ -0,0 +1,22 @@
+import { dirname, basename } from 'node:path/posix'
+
+const layoutFile = /^_layout(\+(ssg|ssr|spa))?\.[cm]?[jt]sx?$/
+
+/**
+ * The files whose components can read a route's search params: the route itself and
+ * the layouts above it. Both the generated link types and the loader validation
+ * start from this list, so they find the same schemas.
+ *
+ * Paths are relative to the router root, like `./(site)/_layout.tsx`.
+ */
+export function getSearchSchemaEntries(routePaths: string[], contextKey: string) {
+  const dir = dirname(contextKey)
+  const layouts = routePaths
+    .filter((path) => {
+      if (path === contextKey || !layoutFile.test(basename(path))) return false
+      const layoutDir = dirname(path)
+      return layoutDir === '.' || dir === layoutDir || dir.startsWith(`${layoutDir}/`)
+    })
+    .sort((a, b) => dirname(a).length - dirname(b).length)
+  return [contextKey, ...layouts]
+}

package/src/types.ts

@@ -9,13 +9,26 @@ export type Endpoint = (req: Request) => Response | string | object | null
 
 export type RenderApp = (props: RenderAppProps) => Promise<string>
 
-export type LoaderProps<Params extends object = Record<string, string | string[]>> = {
+export type LoaderProps<
+  Params extends object = Record<string, string | string[]>,
+  SearchParams extends object | undefined = undefined,
+> = {
   path: string
   search?: string
   subdomain?: string
   params: Params
   request?: Request
-}
+} & ([SearchParams] extends [object]
+  ? {
+      /**
+       * the query, validated by the schemas components under this route pass to
+       * `useSearchParams(schema)`. Present on ssr document and query-aware client
+       * loader requests, absent for build-time ssg and spa loaders. Native production
+       * initial loads use static data; refetch requests carry the query.
+       */
+      searchParams?: SearchParams
+    }
+  : {})
 
 export type RenderAppProps = {
   mode: One.RouteRenderMode | 'spa-shell'

package/src/useLoader.ts

@@ -1,19 +1,31 @@
 import { useCallback, useSyncExternalStore } from 'react'
 import { Platform } from 'react-native'
 import { registerDevtoolsFunction } from './devtools/registry'
-import { useParams, usePathname } from './hooks'
+import { useParams, usePathname, useRouteInfo } from './hooks'
 import { findNearestNotFoundRoute, setNotFoundState } from './notFoundState'
-import { useContextKey } from './router/Route'
+import { useContextKey, useRouteNode } from './router/Route'
 import { getContextKey } from './router/matchers'
 import { router } from './router/imperative-api'
-import { preloadedLoaderData, preloadingLoader, routeNode } from './router/router'
+import {
+  normalizeLoaderPath,
+  preloadedLoaderData,
+  preloadingLoader,
+  routeNode,
+} from './router/router'
 import { ssrLoaderData } from './server/ssrLoaderData'
 import {
   subscribeToClientMatches,
   getClientMatchesSnapshot,
   updateMatchLoaderData,
 } from './useMatches'
-import { getLoaderPath, getNativeLoaderPath } from './utils/cleanUrl'
+import {
+  appendLoaderQuery,
+  isLoaderBadRequest,
+  getLoaderPath,
+  getNativeLoaderPath,
+  splitLoaderKey,
+  toLoaderKey,
+} from './utils/cleanUrl'
 import { dynamicImport } from './utils/dynamicImport'
 import { weakKey } from './utils/weakKey'
 import { useServerContext } from './vite/one-server-only'
@@ -164,10 +176,13 @@ async function importNativeLoader(url: string): Promise<{ loader?: () => any }>
 }
 
 // cache-busted so the server reruns the loader; native passes its platform to get CJS back
-function importRefetchLoader(path: string): Promise<{ loader?: () => any } | null> {
-  const loaderJSUrl = getLoaderPath(path, true, `${Date.now()}`)
+function importRefetchLoader(key: string): Promise<{ loader?: () => any } | null> {
+  const [path, search] = splitLoaderKey(key)
+  const loaderJSUrl = getLoaderPath(path, true, `${Date.now()}`, search)
   if (process.env.TAMAGUI_TARGET === 'native') {
-    return importNativeLoader(`${loaderJSUrl}?platform=${Platform.OS}`).catch(() => null)
+    return importNativeLoader(
+      appendLoaderQuery(loaderJSUrl, 'platform', Platform.OS)
+    ).catch(() => null)
   }
   return dynamicImport(loaderJSUrl)?.catch(() => null)
 }
@@ -175,7 +190,7 @@ function importRefetchLoader(path: string): Promise<{ loader?: () => any } | nul
 /**
  * Imperatively refetch loader data for a given path.
  *
- * @param pathname - The route path to refetch (e.g., '/users/123')
+ * @param href - The route to refetch (e.g., '/users/123'). An ssr route's query is part of what is refetched.
  * @returns Promise that resolves when refetch completes
  * @link https://onestack.dev/docs/api/hooks/useLoaderState#refetchloader
  *
@@ -184,22 +199,25 @@ function importRefetchLoader(path: string): Promise<{ loader?: () => any } | nul
  * await refetchLoader('/users/123')
  * ```
  */
-export async function refetchLoader(pathname: string): Promise<void> {
+export async function refetchLoader(href: string): Promise<void> {
   const startTime = performance.now()
+  // state is keyed the way useLoader keys it: an ssr route keeps its query
+  const key = normalizeLoaderPath(href)
+  const pathname = splitLoaderKey(key)[0]
 
-  updateState(pathname, {
+  updateState(key, {
     state: 'loading',
     error: null,
   })
 
   try {
     const moduleLoadStart = performance.now()
-    const module = await importRefetchLoader(pathname)
+    const module = await importRefetchLoader(key)
     const moduleLoadTime = performance.now() - moduleLoadStart
 
     // gracefully handle missing loader (404, no loader export, etc)
     if (!module?.loader) {
-      updateState(pathname, {
+      updateState(key, {
         data: undefined,
         state: 'idle',
         hasLoadedOnce: true,
@@ -213,6 +231,11 @@ export async function refetchLoader(pathname: string): Promise<void> {
 
     const totalTime = performance.now() - startTime
 
+    // the server rejected the request and did not run the loader
+    if (isLoaderBadRequest(result)) {
+      throw new Error(result.__oneErrorMessage || 'Bad Request')
+    }
+
     // detect server redirect signal during refetch
     if (result?.__oneRedirect) {
       recordLoaderTiming?.({
@@ -223,7 +246,7 @@ export async function refetchLoader(pathname: string): Promise<void> {
         totalTime,
         source: 'refetch',
       })
-      updateState(pathname, {
+      updateState(key, {
         data: undefined,
         state: 'idle',
         hasLoadedOnce: true,
@@ -252,7 +275,7 @@ export async function refetchLoader(pathname: string): Promise<void> {
       return
     }
 
-    updateState(pathname, {
+    updateState(key, {
       data: result,
       state: 'idle',
       timestamp: Date.now(),
@@ -282,7 +305,7 @@ export async function refetchLoader(pathname: string): Promise<void> {
   } catch (err) {
     const totalTime = performance.now() - startTime
 
-    updateState(pathname, {
+    updateState(key, {
       error: err,
       state: 'idle',
     })
@@ -369,6 +392,13 @@ export function useLoaderState<
   // use just the pathname for matching, don't use resolveHref which adds params as query string
   // (the pathname is already resolved like /docs/getting-started, not /docs/[slug])
   const currentPath = pathname.replace(/\/index$/, '').replace(/\/$/, '') || '/'
+  // an ssr route's loader reads the query, so its data is stored and fetched per query
+  const isSsrPage = useRouteNode()?.type === 'ssr'
+  const href = useRouteInfo().unstable_globalHref
+  const loaderKey = isSsrPage
+    ? toLoaderKey(currentPath, new URL(href, 'http://example.com').search)
+    : currentPath
+  const [loaderPath, loaderSearch] = splitLoaderKey(loaderKey)
 
   // server-side only — use pre-resolved loader data so dev and prod behave identically
   // (no re-running loaders during render, data comes from the same source the client gets)
@@ -430,23 +460,29 @@ export function useLoaderState<
 
   // preloaded data from SSR/SSG - only use if server context path matches current path
   const serverContextPath = loaderPropsFromServerContext?.path
+  const serverContextKey =
+    isSsrPage && serverContextPath !== undefined
+      ? toLoaderKey(serverContextPath, loaderPropsFromServerContext?.search ?? '')
+      : serverContextPath
   const preloadedData =
-    serverContextPath === currentPath ? loaderDataFromServerContext : undefined
+    serverContextKey === loaderKey ? loaderDataFromServerContext : undefined
 
   // all hooks must be called unconditionally to satisfy React's rules of hooks
   const loaderStateEntry = useSyncExternalStore(
     subscribe,
-    () => getLoaderState(currentPath, preloadedData),
-    () => getLoaderState(currentPath, preloadedData)
+    () => getLoaderState(loaderKey, preloadedData),
+    () => getLoaderState(loaderKey, preloadedData)
   )
 
-  const refetch = useCallback(() => refetchLoader(currentPath), [currentPath])
+  const refetch = useCallback(() => refetchLoader(loaderKey), [loaderKey])
 
   // if the loader returns a routeId, look up data from matches instead of loaderState
   // only use this path when the match has data (layouts always have data preserved from SSR;
   // pages might have null loaderData during client navigation if preloading hasn't completed,
   // so they fall through to the regular loaderState path which handles suspension/loading)
-  if (matchRouteId) {
+  // an ssr page is excluded: matches are keyed by pathname and not rebuilt on back/forward,
+  // so they cannot tell one query of the page from another
+  if (matchRouteId && !isSsrPage) {
     const match = clientMatches.find((m) => m.routeId === matchRouteId)
     // for page matches (the deepest/last match), verify the pathname matches currentPath.
     // during back/forward navigation, clientMatches may be stale (popstate doesn't update them),
@@ -464,8 +500,8 @@ export function useLoaderState<
         // refetch updates both loaderState (for useLoaderState() consumers without a loader)
         // and the match entry (for this component and useMatches consumers)
         refetch: async () => {
-          await refetchLoader(currentPath)
-          const fresh = loaderState[currentPath]
+          await refetchLoader(loaderKey)
+          const fresh = loaderState[loaderKey]
           if (fresh?.data != null) {
             updateMatchLoaderData(matchRouteId, fresh.data)
           }
@@ -491,37 +527,37 @@ export function useLoaderState<
   ) {
     // check for already-resolved preloaded data first (synchronous)
     // use != null to also exclude null values (which indicate preload failures)
-    const resolvedPreloadData = preloadedLoaderData[currentPath]
+    const resolvedPreloadData = preloadedLoaderData[loaderKey]
     if (resolvedPreloadData != null) {
       // Data was preloaded and already resolved - use it directly
-      delete preloadedLoaderData[currentPath]
-      delete preloadingLoader[currentPath]
+      delete preloadedLoaderData[loaderKey]
+      delete preloadingLoader[loaderKey]
       loaderStateEntry.data = resolvedPreloadData
       loaderStateEntry.hasLoadedOnce = true
-    } else if (preloadingLoader[currentPath]) {
+    } else if (preloadingLoader[loaderKey]) {
       // Preload is in progress - wait for it
-      const preloadPromise = preloadingLoader[currentPath]!
+      const preloadPromise = preloadingLoader[loaderKey]!
       const promise = preloadPromise
         .then((val: any) => {
-          delete preloadingLoader[currentPath]
-          delete preloadedLoaderData[currentPath]
+          delete preloadingLoader[loaderKey]
+          delete preloadedLoaderData[loaderKey]
           // null means preload failed - don't mark as loaded, let initial load handle it
           if (val != null) {
-            updateState(currentPath, {
+            updateState(loaderKey, {
               data: val,
               hasLoadedOnce: true,
               promise: undefined,
             })
           } else {
-            updateState(currentPath, {
+            updateState(loaderKey, {
               promise: undefined,
             })
           }
         })
         .catch((err: any) => {
           console.error(`Error running loader()`, err)
-          delete preloadingLoader[currentPath]
-          updateState(currentPath, {
+          delete preloadingLoader[loaderKey]
+          updateState(loaderKey, {
             error: err,
             promise: undefined,
           })
@@ -538,10 +574,14 @@ export function useLoaderState<
             let nativeLoaderJSUrl: string
             if (process.env.NODE_ENV === 'development') {
               // dev: ?platform=native tells vite plugin to return CJS
-              nativeLoaderJSUrl = `${getLoaderPath(currentPath, true)}?platform=native`
+              nativeLoaderJSUrl = appendLoaderQuery(
+                getLoaderPath(loaderPath, true, undefined, loaderSearch),
+                'platform',
+                'native'
+              )
             } else {
               // prod: the uncached .native.js file, since metro can't inline ONE_CACHE_KEY
-              nativeLoaderJSUrl = getNativeLoaderPath(currentPath)
+              nativeLoaderJSUrl = getNativeLoaderPath(loaderPath)
             }
 
             try {
@@ -559,6 +599,10 @@ export function useLoaderState<
               const totalTime = performance.now() - startTime
 
               // detect server redirect signal on native
+              if (isLoaderBadRequest(data)) {
+                throw new Error(data.__oneErrorMessage || 'Bad Request')
+              }
+
               if (data?.__oneRedirect) {
                 recordLoaderTiming?.({
                   path: currentPath,
@@ -568,7 +612,7 @@ export function useLoaderState<
                   totalTime,
                   source: 'initial',
                 })
-                updateState(currentPath, {
+                updateState(loaderKey, {
                   data: undefined,
                   hasLoadedOnce: true,
                   promise: undefined,
@@ -597,7 +641,7 @@ export function useLoaderState<
                 return
               }
 
-              updateState(currentPath, {
+              updateState(loaderKey, {
                 data,
                 hasLoadedOnce: true,
                 promise: undefined,
@@ -619,7 +663,7 @@ export function useLoaderState<
                 `url: ${nativeLoaderJSUrl}`
               )
               const totalTime = performance.now() - startTime
-              updateState(currentPath, {
+              updateState(loaderKey, {
                 data: {},
                 promise: undefined,
               })
@@ -635,7 +679,7 @@ export function useLoaderState<
           }
 
           // web platform
-          const loaderJSUrl = getLoaderPath(currentPath, true)
+          const loaderJSUrl = getLoaderPath(loaderPath, true, undefined, loaderSearch)
 
           const moduleLoadStart = performance.now()
           const module = await dynamicImport(loaderJSUrl)?.catch(() => null)
@@ -643,7 +687,7 @@ export function useLoaderState<
 
           // gracefully handle missing loader (404, no loader export, etc)
           if (!module?.loader) {
-            updateState(currentPath, {
+            updateState(loaderKey, {
               data: undefined,
               hasLoadedOnce: true,
               promise: undefined,
@@ -657,6 +701,10 @@ export function useLoaderState<
 
           const totalTime = performance.now() - startTime
 
+          if (isLoaderBadRequest(result)) {
+            throw new Error(result.__oneErrorMessage || 'Bad Request')
+          }
+
           // detect server redirect signal (fallback if preload didn't catch it)
           if (result?.__oneRedirect) {
             recordLoaderTiming?.({
@@ -667,7 +715,7 @@ export function useLoaderState<
               totalTime,
               source: 'initial',
             })
-            updateState(currentPath, {
+            updateState(loaderKey, {
               data: undefined,
               hasLoadedOnce: true,
               promise: undefined,
@@ -695,7 +743,7 @@ export function useLoaderState<
             return
           }
 
-          updateState(currentPath, {
+          updateState(loaderKey, {
             data: result,
             hasLoadedOnce: true,
             promise: undefined,
@@ -712,7 +760,7 @@ export function useLoaderState<
         } catch (err) {
           const totalTime = performance.now() - startTime
 
-          updateState(currentPath, {
+          updateState(loaderKey, {
             error: err,
             promise: undefined,
           })

package/src/utils/cleanUrl.ts

@@ -49,17 +49,58 @@ export function getPreloadCSSPath(currentPath: string) {
   return `${clientSideURL}/assets/${cleanUrl(currentPath.slice(1))}${CSS_PRELOAD_JS_POSTFIX}`
 }
 
+// carries the page's query to the loader of an ssr route, which is the only
+// loader that can read it. a reserved key keeps it apart from `platform`.
+export const LOADER_SEARCH_PARAM = '__one_search'
+
+// a loader key is the pathname, plus the query when the route is ssr
+export function splitLoaderKey(key: string): [path: string, search: string] {
+  const index = key.indexOf('?')
+  return index === -1 ? [key, ''] : [key.slice(0, index), key.slice(index)]
+}
+
+// the same query can be written in several orders and encodings (the url, the
+// router state, a link). one canonical form keeps a page's data under one key.
+export function toLoaderKey(path: string, search: string) {
+  const params = new URLSearchParams(search)
+  params.sort()
+  const query = params.toString()
+  return query ? `${path}?${query}` : path
+}
+
+export function appendLoaderQuery(url: string, name: string, value: string) {
+  return `${url}${url.includes('?') ? '&' : '?'}${name}=${value}`
+}
+
+// the page's query as sent with a loader request, '' when there is none
+/**
+ * The marker a loader request answers with when the server rejected it with a 400, as
+ * it does for a query a search schema rejects. The loader did not run.
+ */
+export function isLoaderBadRequest(data: unknown) {
+  return (data as { __oneError?: number } | null | undefined)?.__oneError === 400
+}
+
+export function readLoaderSearch(url: URL) {
+  const search = url.searchParams.get(LOADER_SEARCH_PARAM)
+  return search ? `?${search}` : ''
+}
+
 export function getLoaderPath(
   currentPath: string,
   includeUrl = isNative,
-  cacheBust?: string
+  cacheBust?: string,
+  search = ''
 ) {
   const baseURL = includeUrl ? getURL() : ''
   const devPath = process.env.NODE_ENV === 'development' ? '/_one' : ''
 
   const cacheBustSegment = cacheBust ? `_refetch_${cacheBust}_` : ''
 
-  return `${baseURL}${devPath}/assets/${getLoaderFileStem(currentPath)}${cacheBustSegment}${LOADER_JS_POSTFIX}`
+  const loaderPath = `${baseURL}${devPath}/assets/${getLoaderFileStem(currentPath)}${cacheBustSegment}${LOADER_JS_POSTFIX}`
+  return search.length > 1
+    ? appendLoaderQuery(loaderPath, LOADER_SEARCH_PARAM, encodeURIComponent(search.slice(1)))
+    : loaderPath
 }
 
 // native prod reads the uncached .native.js copy the build writes beside each loader

package/src/validateParams.ts

@@ -6,7 +6,8 @@
  * to catch invalid routes early.
  */
 
-import type { StandardSchema, ZodLikeSchema, SearchValidatorFn } from './validateSearch'
+import { isStandardSchema, validateStandardSchemaSync } from './standardSchema'
+import type { StandardSchema, ZodLikeSchema, SearchValidatorFn } from './validateSearchParams'
 
 /**
  * All supported validator types for route params
@@ -94,18 +95,6 @@ export type RouteValidationFn = (
   props: ValidateRouteProps
 ) => ValidationResult | Promise<ValidationResult> | void | Promise<void>
 
-/**
- * Check if a value is a Standard Schema
- */
-function isStandardSchema(value: unknown): value is StandardSchema {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    '~standard' in value &&
-    typeof (value as any)['~standard']?.validate === 'function'
-  )
-}
-
 /**
  * Check if a value is a Zod-like schema
  */
@@ -137,7 +126,7 @@ export function validateParams<T extends ParamValidator>(
   input: Record<string, unknown>
 ): InferParamOutput<T> {
   if (isStandardSchema(validator)) {
-    const result = validator['~standard'].validate(input)
+    const result = validateStandardSchemaSync(validator, input)
     if (result.issues) {
       throw new ParamValidationError(
         'Route param validation failed',

package/src/{validateSearch.ts → validateSearchParams.ts}

@@ -5,21 +5,20 @@
  * Zod, Valibot, and custom validation functions.
  */
 
+import {
+  isStandardSchema,
+  validateStandardSchemaSync,
+  type StandardSchemaV1,
+} from './standardSchema'
+
 /**
- * Standard Schema interface (from standard-schema.dev)
- * Used by Valibot, ArkType, and others for interop.
+ * Standard Schema interface (from standardschema.dev), used by Zod, Valibot,
+ * ArkType and others for interop.
  */
-export interface StandardSchema<Input = unknown, Output = unknown> {
-  readonly '~standard': {
-    readonly version: 1
-    readonly vendor: string
-    readonly validate: (
-      value: unknown
-    ) =>
-      | { readonly value: Output; readonly issues?: undefined }
-      | { readonly value?: undefined; readonly issues: readonly unknown[] }
-  }
-}
+export type StandardSchema<Input = unknown, Output = Input> = StandardSchemaV1<
+  Input,
+  Output
+>
 
 /**
  * Zod-like schema interface
@@ -82,18 +81,6 @@ export class SearchValidationError extends Error {
   }
 }
 
-/**
- * Check if a value is a Standard Schema
- */
-function isStandardSchema(value: unknown): value is StandardSchema {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    '~standard' in value &&
-    typeof (value as any)['~standard']?.validate === 'function'
-  )
-}
-
 /**
  * Check if a value is a Zod-like schema
  */
@@ -112,6 +99,19 @@ function isValidatorFn(value: unknown): value is SearchValidatorFn<unknown, unkn
   return typeof value === 'function'
 }
 
+/**
+ * Sets an own property, even for a key like `__proto__` that plain assignment would
+ * turn into a prototype change. Query keys come from the URL, so any name can appear.
+ */
+export function setOwn(record: object, key: string, value: unknown) {
+  Object.defineProperty(record, key, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true,
+  })
+}
+
 /**
  * Parse search params from URL search string
  */
@@ -120,13 +120,13 @@ export function parseSearchString(search: string): Record<string, string | strin
   const searchParams = new URLSearchParams(search)
 
   searchParams.forEach((value, key) => {
-    const existing = params[key]
+    const existing = Object.hasOwn(params, key) ? params[key] : undefined
     if (existing === undefined) {
-      params[key] = value
+      setOwn(params, key, value)
     } else if (Array.isArray(existing)) {
       existing.push(value)
     } else {
-      params[key] = [existing, value]
+      setOwn(params, key, [existing, value])
     }
   })
 
@@ -141,12 +141,12 @@ export function parseSearchString(search: string): Record<string, string | strin
  * @returns The validated and transformed search params
  * @throws SearchValidationError if validation fails
  */
-export function validateSearch<T extends SearchValidator>(
+export function validateSearchParams<T extends SearchValidator>(
   validator: T,
   input: Record<string, unknown>
 ): InferSearchOutput<T> {
   if (isStandardSchema(validator)) {
-    const result = validator['~standard'].validate(input)
+    const result = validateStandardSchemaSync(validator, input)
     if (result.issues) {
       throw new SearchValidationError(
         'Search param validation failed',
@@ -180,12 +180,12 @@ export function validateSearch<T extends SearchValidator>(
     }
   }
 
-  throw new Error('Invalid validator provided to validateSearch')
+  throw new Error('Invalid validator provided to validateSearchParams')
 }
 
 /**
  * Create a search param validator from a Zod schema.
- * This adapter wraps Zod schemas for use with One's validateSearch.
+ * This adapter wraps Zod schemas for use with One's validateSearchParams.
  *
  * @example
  * ```ts
@@ -197,7 +197,7 @@ export function validateSearch<T extends SearchValidator>(
  *   filter: z.string().optional(),
  * })
  *
- * export const validateSearch = zodSearchValidator(searchSchema)
+ * const search = validateSearchParams(zodSearchValidator(searchSchema), input)
  * ```
  */
 export function zodSearchValidator<T extends ZodLikeSchema>(schema: T): T {

package/src/vercel/build/generate/createSsrServerlessFunction.ts

@@ -131,7 +131,41 @@ export async function createSsrServerlessFunction(
     }
 
     const exported = await import(route.serverJsPath.replace('${outDir}/','../'))
-    const loaderData = await exported.loader?.(loaderProps)
+
+    // a document request has the query of the page. a loader request has it under
+    // the reserved transport key, because its own query holds __loader and route
+    // params. a rewritten page path also carries the route params as query keys.
+    const { loaderResponseToModule, prepareSsrLoaderProps, readLoaderSearch } = entry.default.loaderRequest;
+    const pageUrl = new URL(url);
+    if (/\\[|%5B/i.test(url.pathname)) {
+      for (const param of paramNames) pageUrl.searchParams.delete(param.name);
+    }
+    const search = isLoaderRequest ? readLoaderSearch(url) : pageUrl.search;
+
+    const sendResponse = async (response) => {
+      res.statusCode = response.status;
+      response.headers.forEach((value, key) => res.setHeader(key, value));
+      res.end(Buffer.from(await response.arrayBuffer()));
+    };
+
+    // validation runs before the loader, a thrown Response (a rejected query, a
+    // redirect, an error status) is the answer
+    let loaderData;
+    let preparedLoaderProps = loaderProps;
+    try {
+      preparedLoaderProps = prepareSsrLoaderProps(exported, loaderProps, search);
+      loaderData = await exported.loader?.(preparedLoaderProps);
+    } catch (err) {
+      if (!(err instanceof Response)) throw err;
+      if (isLoaderRequest) {
+        const moduleResponse = loaderResponseToModule(err, url);
+        res.setHeader('Cache-Control', 'no-store');
+        await sendResponse(moduleResponse);
+      } else {
+        await sendResponse(err);
+      }
+      return;
+    }
 
     // For loader requests, return the loader data as a JavaScript module
     if (isLoaderRequest) {
@@ -148,7 +182,7 @@ export async function createSsrServerlessFunction(
     const rendered = await render({
       mode: route.type,
       loaderData,
-      loaderProps,
+      loaderProps: preparedLoaderProps,
       path: loaderProps?.path || '/',
       preloads,
       css,