@revealui/core 0.0.1-pre.1 → 0.0.1-pre.2

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

@@ -1,804 +0,0 @@
-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)`
-  )
-}