@revealui/core 0.0.1-pre.0

package/dist/core/renderer/page/index.ts

@@ -0,0 +1,804 @@
+export { renderPage, renderPage_addWrapper }
+
+import pc from "@brillout/picocolors"
+
+import {
+  PageContextBuiltInServerInternal,
+  PageContextServer,
+} from "../../../types/interfaces/context.js"
+import { PageConfigRuntime } from "../../../types/interfaces/page.js"
+import { assert } from "../../gaurds/assertions/assert/index.js"
+import { assertArguments } from "../../gaurds/assertions/assertArguments.js"
+import { assertUsage } from "../../gaurds/assertions/assertUsage/index.js"
+import { assertWarning } from "../../gaurds/assertions/assertWarning/index.js"
+import { PageContextDebugRouteMatches } from "../../gaurds/debugger/debugPageFiles.js"
+import { log404 } from "../../gaurds/logger/log404/index.js"
+import {
+  logRuntimeError,
+  logRuntimeInfo,
+} from "../../gaurds/logger/loggerRuntime.js"
+import { isConfigInvalid } from "../../gaurds/validators/isConfigInvalid.js"
+import { isNewError } from "../../gaurds/validators/isNewError.js"
+import {
+  getGlobalContext,
+  initGlobalContext_renderPage,
+} from "../../globals/contexts/globalContext/index.js"
+import { handleErrorWithoutErrorPage } from "../../handlers/handleErrorWithoutErrorPage.js"
+import { handlePageContextRequestUrl } from "../../handlers/handlePageContextRequestUrl.js"
+import { getErrorPageId } from "../../processing/getters/getErrorPageId.js"
+import getGlobalObject from "../../processing/getters/getGlobalObject.js"
+import {
+  serializePageContextAbort,
+  serializePageContextClientSide,
+} from "../../processing/serializers/serializePageContextClientSide.js"
+import {
+  assertNoInfiniteAbortLoop,
+  ErrorAbort,
+  getPageContextFromAllRewrites,
+  isAbortError,
+  logAbortErrorHandled,
+  PageContextFromRewrite,
+} from "../../router/abort.js"
+import { route } from "../../router/index.js"
+import {
+  createHttpResponseError,
+  createHttpResponseFavicon404,
+  createHttpResponsePageContextJson,
+  createHttpResponseRedirect,
+  HttpResponse,
+} from "../../targets/http/createHttpResponse.js"
+import {
+  addUrlOrigin,
+  assertEnv,
+  checkType,
+  createUrlFromComponents,
+  getUrlPretty,
+  hasProp,
+  isUri,
+  isUrl,
+  modifyUrlPathname,
+  normalizeUrlPathname,
+  objectAssign,
+  parseUrl,
+  prependBase,
+  removeBaseServer,
+  removeUrlOrigin,
+  type UrlPublic,
+} from "../stream/utils.js"
+import { loadUserFilesServerSide } from "./loadUserFilesServerSide.js"
+import {
+  getPageContextInitEnhanced,
+  getRenderContext,
+  PageContextInitEnhanced,
+  RenderContext,
+  renderPageAlreadyRouted,
+} from "./renderPageAlreadyRouted.js"
+import { resolveRedirects } from "./resolveRedirects.js"
+import {PageFile} from "../../__internal/index.js"
+
+const globalObject = getGlobalObject("runtime/renderPage.ts", {
+  httpRequestsCount: 0,
+})
+let renderPage_wrapper = async <PageContext>(
+  _httpRequestId: number,
+  ret: () => Promise<PageContext>
+) => ({
+  pageContextReturn: await ret(),
+})
+const renderPage_addWrapper = (wrapper: typeof renderPage_wrapper) => {
+  renderPage_wrapper = wrapper
+}
+
+type PageContextAfterRender = {
+  httpResponse: Promise<HttpResponse>
+} & Partial<PageContextBuiltInServerInternal>
+
+// `renderPage()` calls `renderPageNominal()` while ensuring that errors are `console.error(err)` instead of `throw err`, so that reveal never triggers a server shut down. (Throwing an error in an Express.js middleware shuts down the whole Express.js server.)
+async function renderPage<
+  PageContextUserAdded extends {},
+  PageContextInit extends {
+    /** @deprecated */
+    url?: string
+    /** The URL of the HTTP request */
+    urlOriginal: string
+  },
+>(
+  pageContextInit: PageContextInit
+): Promise<
+  // Partial because rendering may fail at any user hook.
+  // - `.pageContext.json` requests may fail while still returning the HTTP response `JSON.stringify({ serverSideError: true })`.
+  PageContextInit & { httpResponse: HttpResponse } & Partial<
+      PageContextServer & PageContextUserAdded
+    >
+> {
+  assertArguments(...arguments)
+  assert(hasProp(pageContextInit, "urlOriginal", "string")) // assertUsage() already implemented at assertArguments()
+  assertEnv()
+  assertIsUrl(pageContextInit.urlOriginal)
+  const urlPathnameWithBase = parseUrl(
+    pageContextInit.urlOriginal,
+    "/"
+  ).pathname
+  assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal)
+  if (urlPathnameWithBase.endsWith("/favicon.ico"))
+    return getPageContextHttpResponseFavicon404(pageContextInit) as any
+
+  const httpRequestId = getRequestId()
+  const urlOriginalPretty = getUrlPretty(pageContextInit.urlOriginal)
+  logHttpRequest(urlOriginalPretty, httpRequestId)
+
+  const { pageContextReturn } = await renderPage_wrapper(httpRequestId, () =>
+    renderPageAndPrepare(pageContextInit, httpRequestId)
+  )
+
+  logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn)
+
+  checkType<PageContextAfterRender>(pageContextReturn)
+  assert(pageContextReturn.httpResponse)
+  return pageContextReturn as any
+}
+async function renderPageAndPrepare(
+  pageContextInit: { urlOriginal: string } & Record<string, unknown>,
+  httpRequestId: number
+): Promise<PageContextAfterRender> {
+  // Invalid config
+  const handleInvalidConfig = (err: unknown) => {
+    logRuntimeInfo?.(
+      pc.bold(
+        pc.red("Error while loading a reveal config file, see error above.")
+      ),
+      httpRequestId,
+      "error"
+    )
+    const pageContextWithError = getPageContextHttpResponseError(
+      err,
+      pageContextInit,
+      null
+    )
+    return pageContextWithError
+  }
+  if (isConfigInvalid) {
+    if (
+      1 < 2 // Make TS happy
+    ) {
+      return handleInvalidConfig(isConfigInvalid.err)
+    }
+  }
+
+  // Prepare context
+  let renderContext: RenderContext
+  try {
+    await initGlobalContext_renderPage()
+    renderContext = await getRenderContext()
+  } catch (err) {
+    // Errors are expected since assertUsage() is used in both initGlobalContext_renderPage() and getRenderContext().
+    // initGlobalContext_renderPage() and getRenderContext() don't call any user hooks => err isn't thrown from user code.
+    assert(!isAbortError(err))
+    logRuntimeError(err, httpRequestId)
+    const pageContextWithError = getPageContextHttpResponseError(
+      err,
+      pageContextInit,
+      null
+    )
+    return pageContextWithError
+  }
+  if (isConfigInvalid) {
+    return handleInvalidConfig(isConfigInvalid.err)
+  } else {
+    // From now on, renderContext.pageConfigs contains all the configuration data; getrevealConfig() isn't called anymore for this request
+  }
+
+  // Check Base URL
+  assertBaseUrl(pageContextInit)
+
+  // Normalize URL
+  {
+    const pageContextHttpResponse = normalizeUrl(pageContextInit, httpRequestId)
+    if (pageContextHttpResponse) return pageContextHttpResponse
+  }
+
+  // Permanent redirects (HTTP status code `301`)
+  {
+    const pageContextHttpResponse = getPermanentRedirect(
+      pageContextInit,
+      httpRequestId
+    )
+    if (pageContextHttpResponse) return pageContextHttpResponse
+  }
+
+  return await renderPageAlreadyPrepared(
+    pageContextInit,
+    httpRequestId,
+    renderContext,
+    []
+  )
+}
+
+async function renderPageAlreadyPrepared(
+  pageContextInit: { urlOriginal: string } & Record<string, unknown>,
+  httpRequestId: number,
+  renderContext: RenderContext,
+  pageContextsFromRewrite: PageContextFromRewrite[]
+): Promise<PageContextAfterRender> {
+  assertNoInfiniteAbortLoop(
+    pageContextsFromRewrite.length,
+    // There doesn't seem to be a way to count the number of HTTP redirects (reveal don't have access to the HTTP request headers/cookies)
+    // https://stackoverflow.com/questions/9683007/detect-infinite-http-redirect-loop-on-server-side
+    0
+  )
+  let pageContextNominalPageSuccess:
+    | undefined
+    | Awaited<ReturnType<typeof renderPageNominal>>
+  let pageContextNominalPageInit = {}
+  {
+    const pageContextFromAllRewrites = getPageContextFromAllRewrites(
+      pageContextsFromRewrite
+    )
+    objectAssign(pageContextNominalPageInit, pageContextFromAllRewrites)
+  }
+  {
+    const pageContextInitEnhanced = getPageContextInitEnhancedSSR(
+      pageContextInit,
+      renderContext,
+      pageContextNominalPageInit._urlRewrite,
+      httpRequestId
+    )
+    objectAssign(pageContextNominalPageInit, pageContextInitEnhanced)
+  }
+  let errNominalPage: unknown
+  {
+    try {
+      pageContextNominalPageSuccess = await renderPageNominal(
+        pageContextNominalPageInit
+      )
+    } catch (err) {
+      errNominalPage = err
+      assert(errNominalPage)
+      logRuntimeError(errNominalPage, httpRequestId)
+    }
+    if (!errNominalPage) {
+      assert(pageContextNominalPageSuccess === pageContextNominalPageInit)
+    }
+  }
+
+  // Log upon 404
+  if (
+    pageContextNominalPageSuccess &&
+    "is404" in pageContextNominalPageSuccess &&
+    pageContextNominalPageSuccess.is404 === true
+  ) {
+    await log404(pageContextNominalPageSuccess)
+  }
+
+  if (errNominalPage === undefined) {
+    assert(pageContextNominalPageSuccess)
+    return {
+      ...pageContextNominalPageSuccess,
+      httpResponse: Promise.resolve(pageContextNominalPageSuccess.httpResponse),
+    }
+  } else {
+    assert(errNominalPage)
+    assert(pageContextNominalPageSuccess === undefined)
+    assert(pageContextNominalPageInit)
+    assert(hasProp(pageContextNominalPageInit, "urlOriginal", "string"))
+
+    const pageContextErrorPageInit = await getPageContextErrorPageInit(
+      pageContextInit,
+      errNominalPage,
+      pageContextNominalPageInit,
+      renderContext,
+      httpRequestId
+    )
+
+    // Handle `throw redirect()` and `throw render()` while rendering nominal page
+    if (isAbortError(errNominalPage)) {
+      const handled = await handleAbortError(
+        errNominalPage,
+        pageContextsFromRewrite,
+        pageContextInit,
+        pageContextNominalPageInit,
+        httpRequestId,
+        renderContext,
+        pageContextErrorPageInit
+      )
+      if (handled.pageContextReturn) {
+        // - throw redirect()
+        // - throw render(url)
+        // - throw render(abortStatusCode) if .pageContext.json request
+        return handled.pageContextReturn
+      } else {
+        // - throw render(abortStatusCode) if not .pageContext.json request
+      }
+      Object.assign(pageContextErrorPageInit, handled.pageContextAbort)
+    }
+
+    {
+      const errorPageId = getErrorPageId(
+        renderContext.pageFilesAll,
+        renderContext.pageConfigs
+      )
+      if (!errorPageId) {
+        objectAssign(pageContextErrorPageInit, { pageId: null })
+        const errorPageContext = await handleErrorWithoutErrorPage(
+          pageContextErrorPageInit
+        )
+        return Promise.resolve({
+          httpResponse: Promise.resolve(errorPageContext.httpResponse),
+        })
+      } else {
+        objectAssign(pageContextErrorPageInit, { pageId: errorPageId })
+      }
+    }
+
+    let pageContextErrorPage:
+      | undefined
+      | Awaited<ReturnType<typeof renderPageAlreadyRouted>>
+    try {
+      pageContextErrorPage = await renderPageAlreadyRouted(
+        pageContextErrorPageInit
+      )
+    } catch (errErrorPage) {
+      // Handle `throw redirect()` and `throw render()` while rendering error page
+      if (isAbortError(errErrorPage)) {
+        const handled = await handleAbortError(
+          errErrorPage,
+          pageContextsFromRewrite,
+          pageContextInit,
+          pageContextNominalPageInit,
+          httpRequestId,
+          renderContext,
+          pageContextErrorPageInit
+        )
+        // throw render(abortStatusCode)
+        if (!handled.pageContextReturn) {
+          const pageContextAbort = errErrorPage._pageContextAbort
+          assertWarning(
+            false,
+            `Failed to render error page because ${pc.cyan(
+              pageContextAbort._abortCall
+            )} was called: make sure ${pc.cyan(
+              pageContextAbort._abortCaller
+            )} doesn't occur while the error page is being rendered.`,
+            { onlyOnce: false }
+          )
+          const pageContextHttpWithError = getPageContextHttpResponseError(
+            errNominalPage,
+            pageContextInit,
+            pageContextErrorPageInit
+          )
+          return pageContextHttpWithError
+        }
+        // `throw redirect()` / `throw render(url)`
+        return handled.pageContextReturn
+      }
+      if (isNewError(errErrorPage, errNominalPage)) {
+        logRuntimeError(errErrorPage, httpRequestId)
+      }
+      const pageContextWithError = getPageContextHttpResponseError(
+        errNominalPage,
+        pageContextInit,
+        pageContextErrorPageInit
+      )
+      return pageContextWithError
+    }
+    return {
+      ...pageContextErrorPage,
+      httpResponse: Promise.resolve(pageContextErrorPage.httpResponse),
+    }
+  }
+}
+
+function logHttpRequest(urlOriginal: string, httpRequestId: number) {
+  logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), httpRequestId, "info")
+}
+function getRequestInfoMessage(urlOriginal: string) {
+  return `HTTP request: ${prettyUrl(urlOriginal)}`
+}
+async function logHttpResponse(
+  urlOriginalPretty: string,
+  httpRequestId: number,
+  pageContextReturn: PageContextAfterRender
+) {
+  const httpResponse = await pageContextReturn.httpResponse
+  const statusCode = httpResponse?.statusCode ?? null
+
+  let msg: `HTTP response ${string}` | `HTTP redirect ${string}`
+  let isNominal: boolean
+  {
+    const { errorWhileRendering } = pageContextReturn
+    const isSkipped = statusCode === null && !errorWhileRendering
+    if (isSkipped) {
+      // - URL doesn't include Base URL
+      //   - Can we abort earlier so that `logHttpResponse()` and `logHttpRequest()` aren't even called?
+      // - Error loading a reveal config file
+      //   - We should show `HTTP response ${urlOriginalPretty} ERR` instead.
+      //   - Maybe we can/should make the error available at pageContext.errorWhileRendering
+      assert(errorWhileRendering === null || errorWhileRendering === undefined)
+      msg = `HTTP response ${prettyUrl(urlOriginalPretty)} ${pc.dim("null")}`
+      // Erroneous value (it shoud sometimes be `false`) but it's fine as it doesn't seem to have much of an impact.
+      isNominal = true
+    } else {
+      const isSuccess =
+        statusCode !== null && statusCode >= 200 && statusCode <= 399
+      isNominal = isSuccess || statusCode === 404
+      const color = (s: number | string) =>
+        pc.bold(isSuccess ? pc.green(String(s)) : pc.red(String(s)))
+      const isRedirect = statusCode && 300 <= statusCode && statusCode <= 399
+      const type = isRedirect ? "redirect" : "response"
+      if (isRedirect) {
+        assert(pageContextReturn.httpResponse)
+        const headerRedirect = (await pageContextReturn.httpResponse).headers
+          .slice()
+          .reverse()
+          .find((header) => header[0] === "Location")
+        assert(headerRedirect)
+        const urlRedirect = headerRedirect[1]
+        urlOriginalPretty = urlRedirect
+      }
+      msg = `HTTP ${type} ${prettyUrl(urlOriginalPretty)} ${color(statusCode ?? "ERR")}`
+    }
+  }
+  logRuntimeInfo?.(msg, httpRequestId, isNominal ? "info" : "error")
+}
+function prettyUrl(url: string) {
+  return pc.bold(decodeURI(url))
+}
+
+function getPageContextHttpResponseError(
+  err: unknown,
+  pageContextInit: Record<string, unknown>,
+  pageContext: null | {
+    _pageFilesAll: PageFile[]
+    _pageConfigs: PageConfigRuntime[]
+  }
+): PageContextAfterRender {
+  const pageContextWithError = createPageContext(pageContextInit)
+  const httpResponse = createHttpResponseError(pageContext)
+  objectAssign(pageContextWithError, {
+    httpResponse,
+    errorWhileRendering: err,
+  })
+  return pageContextWithError
+}
+function getPageContextHttpResponseFavicon404(
+  pageContextInit: Record<string, unknown>
+): PageContextAfterRender {
+  const pageContext = createPageContext(pageContextInit)
+  const httpResponse = createHttpResponseFavicon404()
+  objectAssign(pageContext, {
+    httpResponse,
+  })
+  checkType<PageContextAfterRender>(pageContext)
+  return pageContext
+}
+
+function createPageContext(pageContextInit: Record<string, unknown>) {
+  const pageContext = {
+    _isPageContextObject: true,
+  }
+  Object.assign(pageContext, pageContextInit)
+  return pageContext
+}
+
+async function renderPageNominal(
+  pageContext: {
+    _urlRewrite: null | string
+    _httpRequestId: number
+  } & PageContextInitEnhanced
+) {
+  objectAssign(pageContext, { errorWhileRendering: null })
+
+  // Route
+  {
+    const pageContextFromRoute = await route(pageContext)
+    objectAssign(pageContext, pageContextFromRoute)
+    objectAssign(pageContext, { is404: pageContext.pageId ? null : true })
+    if (pageContext.pageId === null) {
+      const errorPageId = getErrorPageId(
+        pageContext._pageFilesAll,
+        pageContext._pageConfigs
+      )
+      if (!errorPageId) {
+        assert(hasProp(pageContext, "pageId", "null"))
+        return handleErrorWithoutErrorPage(pageContext)
+      }
+      objectAssign(pageContext, { pageId: errorPageId })
+    }
+  }
+  assert(hasProp(pageContext, "pageId", "string"))
+  assert(pageContext.errorWhileRendering === null)
+
+  // Render
+  const pageContextAfterRender = await renderPageAlreadyRouted(pageContext)
+  assert(pageContext === pageContextAfterRender)
+  return pageContextAfterRender
+}
+
+type PageContextErrorPageInit = Awaited<
+  ReturnType<typeof getPageContextErrorPageInit>
+>
+async function getPageContextErrorPageInit(
+  pageContextInit: { urlOriginal: string },
+  errNominalPage: unknown,
+  pageContextNominalPagePartial: Record<string, unknown>,
+  renderContext: RenderContext,
+  httpRequestId: number
+) {
+  const pageContextInitEnhanced = getPageContextInitEnhancedSSR(
+    pageContextInit,
+    renderContext,
+    null,
+    httpRequestId
+  )
+
+  assert(errNominalPage)
+  const pageContext = {}
+  objectAssign(pageContext, pageContextInitEnhanced)
+  objectAssign(pageContext, {
+    is404: false,
+    errorWhileRendering: errNominalPage as Error,
+    routeParams: {} as Record<string, string>,
+  })
+
+  objectAssign(pageContext, {
+    _debugRouteMatches:
+      (pageContextNominalPagePartial as PageContextDebugRouteMatches)
+        ._debugRouteMatches || "ROUTING_ERROR",
+  })
+
+  assert(pageContext.errorWhileRendering)
+  return pageContext
+}
+
+function getPageContextInitEnhancedSSR(
+  pageContextInit: { urlOriginal: string },
+  renderContext: RenderContext,
+  urlRewrite: null | string,
+  httpRequestId: number
+) {
+  const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(
+    pageContextInit.urlOriginal
+  )
+  const pageContextInitEnhanced = getPageContextInitEnhanced(
+    pageContextInit,
+    renderContext,
+    {
+      ssr: {
+        urlRewrite,
+        urlHandler: _urlHandler,
+        isClientSideNavigation,
+      },
+    }
+  )
+  objectAssign(pageContextInitEnhanced, { _httpRequestId: httpRequestId })
+  return pageContextInitEnhanced
+}
+
+function handlePageContextUrl(urlOriginal: string): {
+  isClientSideNavigation: boolean
+  _urlHandler: (urlOriginal: string) => string
+} {
+  const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal)
+  return {
+    isClientSideNavigation: isPageContextRequest,
+    _urlHandler: (url: string) =>
+      handlePageContextRequestUrl(url).urlWithoutPageContextRequestSuffix,
+  }
+}
+
+function getRequestId(): number {
+  const httpRequestId = ++globalObject.httpRequestsCount
+  assert(httpRequestId >= 1)
+  return httpRequestId
+}
+
+function assertIsUrl(urlOriginal: string) {
+  assertUsage(
+    isUrl(urlOriginal),
+    `${pc.code("renderPage(pageContextInit)")} (https://reveal.dev/renderPage) called with ${pc.code(
+      `pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`
+    )} which isn't a valid URL.`
+  )
+}
+function assertIsNotViteRequest(urlPathname: string, urlOriginal: string) {
+  const isViteRequest =
+    urlPathname.startsWith("/@vite/client") ||
+    urlPathname.startsWith("/@fs/") ||
+    urlPathname.startsWith("/__vite_ping")
+  assertUsage(
+    !isViteRequest,
+    `${pc.code("renderPage(pageContextInit)")} (https://reveal.dev/renderPage) called with ${pc.code(
+      `pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`
+    )} which is unexpected because this URL should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* reveal's middleware, see https://reveal.dev/renderPage`
+  )
+}
+
+function normalizeUrl(
+  pageContextInit: { urlOriginal: string },
+  httpRequestId: number
+) {
+  const { trailingSlash, disableUrlNormalization, baseServer } =
+    getGlobalContext()
+  if (disableUrlNormalization) return null
+  const { urlOriginal } = pageContextInit
+  const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal)
+  if (isPageContextRequest) return null
+  const urlNormalized = normalizeUrlPathname(
+    urlOriginal,
+    trailingSlash,
+    baseServer
+  )
+  if (!urlNormalized) return null
+  logRuntimeInfo?.(
+    `URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://reveal.dev/url-normalization)`,
+    httpRequestId,
+    "info"
+  )
+  const httpResponse = createHttpResponseRedirect(
+    { url: urlNormalized, statusCode: 301 },
+    pageContextInit.urlOriginal
+  )
+  const pageContextHttpResponse = createPageContext(pageContextInit)
+  objectAssign(pageContextHttpResponse, { httpResponse })
+  return pageContextHttpResponse
+}
+
+function getPermanentRedirect(
+  pageContextInit: { urlOriginal: string },
+  httpRequestId: number
+) {
+  const { redirects, baseServer } = getGlobalContext()
+  const urlWithoutBase = removeBaseServer(
+    pageContextInit.urlOriginal,
+    baseServer
+  )
+  let origin: null | string = null
+  let urlTargetExternal: null | string = null
+  let urlTarget = modifyUrlPathname(urlWithoutBase, (urlPathname) => {
+    const urlTarget = resolveRedirects(redirects, urlPathname)
+    if (urlTarget === null) return null
+    if (!isUrl(urlTarget)) {
+      // E.g. `urlTarget === 'mailto:some@example.com'`
+      assert(isUri(urlTarget))
+      urlTargetExternal = urlTarget
+      return null
+    }
+    const { urlModified, origin: origin_ } = removeUrlOrigin(urlTarget)
+    origin = origin_
+    return urlModified
+  })
+  if (urlTargetExternal) {
+    urlTarget = urlTargetExternal
+  } else {
+    if (origin) urlTarget = addUrlOrigin(urlTarget, origin)
+    if (urlTarget === urlWithoutBase) return null
+    urlTarget = prependBase(urlTarget, baseServer)
+    assert(urlTarget !== pageContextInit.urlOriginal)
+  }
+  logRuntimeInfo?.(
+    `Permanent redirect defined by your config.redirects (https://reveal.dev/redirects)`,
+    httpRequestId,
+    "info"
+  )
+  const httpResponse = createHttpResponseRedirect(
+    { url: urlTarget, statusCode: 301 },
+    urlWithoutBase
+  )
+  const pageContextHttpResponse = createPageContext(pageContextInit)
+  objectAssign(pageContextHttpResponse, { httpResponse })
+  return pageContextHttpResponse
+}
+
+async function handleAbortError(
+  errAbort: ErrorAbort,
+  pageContextsFromRewrite: PageContextFromRewrite[],
+  pageContextInit: { urlOriginal: string },
+  // handleAbortError() creates a new pageContext object and we don't merge pageContextNominalPageInit to it: we only use some pageContextNominalPageInit information.
+  pageContextNominalPageInit: {
+    urlOriginal: string
+    urlParsed: UrlPublic
+    _urlRewrite: null | string
+    isClientSideNavigation: boolean
+  },
+  httpRequestId: number,
+  renderContext: RenderContext,
+  pageContextErrorPageInit: PageContextErrorPageInit
+): Promise<
+  | { pageContextReturn: PageContextAfterRender; pageContextAbort?: never }
+  | { pageContextReturn?: never; pageContextAbort: Record<string, unknown> }
+> {
+  logAbortErrorHandled(
+    errAbort,
+    getGlobalContext().isProduction,
+    pageContextNominalPageInit
+  )
+
+  const pageContextAbort = errAbort._pageContextAbort
+  let pageContextSerialized: string
+  if (pageContextNominalPageInit.isClientSideNavigation) {
+    if (pageContextAbort.abortStatusCode) {
+      const errorPageId = getErrorPageId(
+        renderContext.pageFilesAll,
+        renderContext.pageConfigs
+      )
+      const abortCall = pageContextAbort._abortCall
+      assert(abortCall)
+      assertUsage(
+        errorPageId,
+        `You called ${pc.cyan(
+          abortCall
+        )} but you didn't define an error page, make sure to define one https://reveal.dev/error-page`
+      )
+      const pageContext = createPageContext({})
+      objectAssign(pageContext, { pageId: errorPageId })
+      objectAssign(pageContext, pageContextAbort)
+      objectAssign(pageContext, pageContextErrorPageInit)
+      objectAssign(pageContext, renderContext)
+      objectAssign(pageContext, await loadUserFilesServerSide(pageContext))
+      // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
+      pageContextSerialized = serializePageContextClientSide(pageContext)
+    } else {
+      pageContextSerialized = serializePageContextAbort(pageContextAbort)
+    }
+    const httpResponse = await createHttpResponsePageContextJson(
+      pageContextSerialized
+    )
+    const pageContextReturn = { httpResponse: await httpResponse }
+    return {
+      pageContextReturn: {
+        httpResponse: Promise.resolve(pageContextReturn.httpResponse),
+      },
+    }
+  }
+
+  if (pageContextAbort._urlRewrite) {
+    const pageContextReturn = await renderPageAlreadyPrepared(
+      pageContextInit,
+      httpRequestId,
+      renderContext,
+      [...pageContextsFromRewrite, pageContextAbort]
+    )
+    Object.assign(pageContextReturn, pageContextAbort)
+    return { pageContextReturn }
+  }
+  if (pageContextAbort._urlRedirect) {
+    const pageContextReturn = createPageContext(pageContextInit)
+    objectAssign(pageContextReturn, pageContextAbort)
+    const httpResponse = createHttpResponseRedirect(
+      pageContextAbort._urlRedirect,
+      (() => {
+        const { pathname, searchOriginal } =
+          pageContextNominalPageInit.urlParsed
+        const urlLogical = createUrlFromComponents(
+          null,
+          pathname,
+          searchOriginal,
+          // The server-side doesn't have access to the hash
+          null
+        )
+        return urlLogical
+      })()
+    )
+    objectAssign(pageContextReturn, { httpResponse })
+    return { pageContextReturn }
+  }
+  assert(pageContextAbort.abortStatusCode)
+  return { pageContextAbort }
+}
+
+function assertBaseUrl(pageContextInit: { urlOriginal: string }) {
+  const { baseServer } = getGlobalContext()
+  const { urlOriginal } = pageContextInit
+  const { urlWithoutPageContextRequestSuffix } =
+    handlePageContextRequestUrl(urlOriginal)
+  const { hasBaseServer } = parseUrl(
+    urlWithoutPageContextRequestSuffix,
+    baseServer
+  )
+  assertUsage(
+    hasBaseServer,
+    `${pc.code("renderPage(pageContextInit)")} (https://reveal.dev/renderPage) called with ${pc.code(
+      `pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`
+    )} which doesn't start with Base URL ${pc.code(baseServer)} (https://reveal.dev/base-url)`
+  )
+}