@revealui/core 0.0.1-pre.0

package/dist/core/processing/getters/getRevealConfig/index.ts

@@ -0,0 +1,1641 @@
+export {
+  getConfigValueInterfaceFile,
+  getRevealConfig,
+  isRevealConfigFile,
+  isV1Design,
+  reloadRevealConfig,
+  revealConfigDependencies,
+}
+export type { InterfaceFile, InterfaceValueFile, RevealConfigObject }
+
+import pc from "@brillout/picocolors"
+import path from "path"
+import type { ResolvedConfig } from "vite"
+
+import { getConfigFileExport } from "../../../../plugins/importUserCode/getConfigFileExport.js"
+import {
+  assert,
+  assertIsNotProductionRuntime,
+  assertKeys,
+  assertLog,
+  assertPosixPath,
+  assertUsage,
+  assertWarning,
+  getMostSimilar,
+  getOutDirs,
+  hasProp,
+  includes,
+  isNpmPackageImport,
+  isObject,
+  joinEnglish,
+  lowerFirst,
+  makeFirst,
+  objectEntries,
+  objectFromEntries,
+  objectKeys,
+  reverse,
+} from "../../../../plugins/utils.js"
+import type { Config } from "../../../../types/interfaces/config.js"
+import type { FilePathResolved } from "../../../../types/interfaces/file.js"
+import type {
+  ConfigEnvInternal,
+  ConfigValueSource,
+  ConfigValueSources,
+  ConfigValuesComputed,
+  DefinedAtFilePath,
+  PageConfigBuildTime,
+  PageConfigGlobalBuildTime,
+} from "../../../../types/interfaces/page.js"
+import {
+  assertExtensionsConventions,
+  assertExtensionsPeerDependencies,
+} from "../../../gaurds/assertions/assertExtensions/base.js"
+import {
+  logConfigError,
+  logConfigErrorRecover,
+} from "../../../gaurds/logger/loggerNotProd.js"
+import {
+  removeSuperfluousViteLog_disable,
+  removeSuperfluousViteLog_enable,
+} from "../../../gaurds/logger/loggerVite/removeSuperfluousViteLog.js"
+import {
+  isConfigInvalid,
+  isConfigInvalid_set,
+} from "../../../gaurds/validators/isConfigInvalid.js"
+import { getViteDevServer } from "../../../globals/contexts/globalContext/index.js"
+import { getConfigDefinedAt } from "../getConfigDefinedAt.js"
+import { getConfigReveal } from "../getConfigReveal.js"
+import { getConfigValueBuildTime } from "../getConfigValueBuildTime.js"
+import { getFilePathResolved } from "../getFilePath.js"
+import {
+  type ConfigDefinitionInternal,
+  type ConfigDefinitions,
+  type ConfigNameGlobal,
+  configDefinitionsBuiltIn,
+  configDefinitionsBuiltInGlobal,
+} from "./configDefinitionsBuiltIn.js"
+import { crawlPlusFiles } from "./crawlPlusFiles.js"
+import {
+  type LocationId,
+  applyFilesystemRoutingRootEffect,
+  getFilesystemRouteDefinedBy,
+  getFilesystemRouteString,
+  getLocationId,
+  isGlobalLocation,
+  isInherited,
+  sortAfterInheritanceOrder,
+} from "./filesystemRouting.js"
+import {
+  type ConfigFile,
+  ImportedFilesLoaded,
+  loadConfigFile,
+  loadImportedFile,
+  loadValueFile,
+} from "./loadFileAtConfigTime.js"
+import {
+  clearFilesEnvMap,
+  resolvePointerImportOfConfig,
+} from "./resolvePointerImport.js"
+import { isTemporaryBuildFile } from "./transpileAndExecuteFile.js"
+
+assertIsNotProductionRuntime()
+
+type InterfaceFile = InterfaceConfigFile | InterfaceValueFile
+type InterfaceFileCommons = {
+  locationId: LocationId
+  filePath: FilePathResolved
+  fileExportsByConfigName: Record<ConfigName, { configValue?: unknown }>
+}
+// +config.js
+type InterfaceConfigFile = InterfaceFileCommons & {
+  isConfigFile: true
+  isValueFile: false
+  extendsFilePaths: string[]
+  isConfigExtend: boolean
+}
+// +{configName}.js
+type InterfaceValueFile = InterfaceFileCommons & {
+  isConfigFile: false
+  isValueFile: true
+  configName: string
+}
+type ConfigName = string
+type InterfaceFilesByLocationId = Record<LocationId, InterfaceFile[]>
+
+type RevealConfigObject = {
+  pageConfigs: PageConfigBuildTime[]
+  pageConfigGlobal: PageConfigGlobalBuildTime
+  globalRevealConfig: Record<string, unknown>
+}
+
+let devServerIsCorrupt = false
+let wasConfigInvalid: boolean | null = null
+let revealConfigPromise: Promise<RevealConfigObject> | null = null
+
+const revealConfigDependencies: Set<string> = new Set()
+
+function reloadRevealConfig(userRootDir: string, outDirRoot: string) {
+  revealConfigDependencies.clear()
+  clearFilesEnvMap()
+  revealConfigPromise = loadRevealConfig_withErrorHandling(
+    userRootDir,
+    outDirRoot,
+    true,
+    true
+  )
+  handleReloadSideEffects()
+}
+async function handleReloadSideEffects() {
+  wasConfigInvalid = !!isConfigInvalid
+  const revealConfigPromisePrevious = revealConfigPromise
+  try {
+    await revealConfigPromise
+  } catch (err) {
+    // handleReloadSideEffects() is only called in dev.
+    // In dev, if loadRevealConfig_withErrorHandling() throws an error, then it's a reveal bug.
+    console.error(err)
+    assert(false)
+  }
+  if (revealConfigPromise !== revealConfigPromisePrevious) {
+    // Let the next handleReloadSideEffects() call handle side effects
+    return
+  }
+  if (!isConfigInvalid) {
+    if (wasConfigInvalid) {
+      wasConfigInvalid = false
+      logConfigErrorRecover()
+    }
+    if (devServerIsCorrupt) {
+      devServerIsCorrupt = false
+      const viteDevServer = getViteDevServer()
+      assert(viteDevServer)
+      removeSuperfluousViteLog_enable()
+      await viteDevServer.restart(true)
+      removeSuperfluousViteLog_disable()
+    }
+  }
+}
+async function getRevealConfig(
+  config: ResolvedConfig,
+  isDev: boolean,
+  {
+    crawlWithGit,
+    tolerateInvalidConfig,
+  }: {
+    crawlWithGit?: null | boolean
+    tolerateInvalidConfig?: true
+  } = {}
+): Promise<RevealConfigObject> {
+  const { outDirRoot } = getOutDirs(config)
+  const userRootDir = config.root
+  if (!revealConfigPromise) {
+    const crawlWithGit_ =
+      crawlWithGit !== undefined
+        ? crawlWithGit
+        : (await getConfigReveal(config)).crawl.git
+    revealConfigPromise = loadRevealConfig_withErrorHandling(
+      userRootDir,
+      outDirRoot,
+      isDev,
+      crawlWithGit_,
+      tolerateInvalidConfig
+    )
+  }
+  return await revealConfigPromise
+}
+
+async function isV1Design(
+  config: ResolvedConfig,
+  isDev: boolean
+): Promise<boolean> {
+  const revealConfig = await getRevealConfig(config, isDev)
+  const { pageConfigs } = revealConfig
+  const isV1Design = pageConfigs.length > 0
+  return isV1Design
+}
+
+async function loadInterfaceFiles(
+  userRootDir: string,
+  outDirRoot: string,
+  isDev: boolean,
+  crawlWithGit: null | boolean
+): Promise<InterfaceFilesByLocationId> {
+  const plusFiles = await findPlusFiles(
+    userRootDir,
+    outDirRoot,
+    isDev,
+    crawlWithGit
+  )
+  const configFiles: FilePathResolved[] = []
+  const valueFiles: FilePathResolved[] = []
+  plusFiles.forEach((f) => {
+    if (getConfigName(f.filePathAbsoluteFilesystem) === "config") {
+      configFiles.push(f)
+    } else {
+      valueFiles.push(f)
+    }
+  })
+
+  let interfaceFilesByLocationId: InterfaceFilesByLocationId = {}
+
+  await Promise.allSettled([
+    // Config files
+    ...configFiles.map(async (filePath) => {
+      const { filePathAbsoluteUserRootDir } = filePath
+      assert(filePathAbsoluteUserRootDir)
+      const { configFile, extendsConfigs } = await loadConfigFile(
+        filePath,
+        userRootDir,
+        [],
+        false
+      )
+      assert(filePath.filePathAbsoluteUserRootDir)
+      const locationId = getLocationId(filePathAbsoluteUserRootDir)
+      const interfaceFile = getInterfaceFileFromConfigFile(
+        configFile,
+        false,
+        locationId
+      )
+
+      interfaceFilesByLocationId[locationId] =
+        interfaceFilesByLocationId[locationId] ?? []
+      interfaceFilesByLocationId[locationId]!.push(interfaceFile)
+      extendsConfigs.forEach((extendsConfig) => {
+        /* We purposely use the same locationId because the Reveal extension's config should only apply to where it's being extended from, for example:
+        ```js
+        // /pages/admin/+config.js (Reveal extension)
+        import revealReact from 'reveal/config'
+        // Should only apply to /pages/marketing/** (Reveal extension)
+        export default { extends: [revealReact] } // Reveal extension
+        
+        */
+        const interfaceFile = getInterfaceFileFromConfigFile(
+          extendsConfig,
+          true,
+          locationId
+        )
+        assertExtensionsConventions(interfaceFile)
+        interfaceFilesByLocationId[locationId]!.push(interfaceFile)
+      })
+    }),
+    // Value files
+    ...valueFiles.map(async (filePath) => {
+      const { filePathAbsoluteUserRootDir } = filePath
+      assert(filePathAbsoluteUserRootDir)
+
+      const configName = getConfigName(filePathAbsoluteUserRootDir)
+      assert(configName)
+
+      const locationId = getLocationId(filePathAbsoluteUserRootDir)
+
+      const interfaceFile: InterfaceValueFile = {
+        locationId,
+        filePath,
+        fileExportsByConfigName: {
+          [configName]: {},
+        },
+        isConfigFile: false,
+        isValueFile: true,
+        configName,
+      }
+      {
+        // We don't have access to the custom config definitions defined by the user yet.
+        //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
+        //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
+        const configDef = getConfigDefinitionOptional(
+          configDefinitionsBuiltIn,
+          configName
+        )
+        if (configDef && isLoadableAtBuildTime(configDef)) {
+          await loadValueFile(interfaceFile, configName, userRootDir)
+        }
+      }
+      {
+        interfaceFilesByLocationId[locationId] =
+          interfaceFilesByLocationId[locationId] ?? []
+        interfaceFilesByLocationId[locationId]!.push(interfaceFile)
+      }
+    }),
+  ])
+
+  assertAllConfigsAreKnown(interfaceFilesByLocationId)
+
+  return interfaceFilesByLocationId
+}
+function getInterfaceFileFromConfigFile(
+  configFile: ConfigFile,
+  isConfigExtend: boolean,
+  locationId: LocationId
+): InterfaceFile {
+  const { fileExports, filePath, extendsFilePaths } = configFile
+  const interfaceFile: InterfaceConfigFile = {
+    locationId,
+    filePath,
+    fileExportsByConfigName: {},
+    isConfigFile: true,
+    isValueFile: false,
+    isConfigExtend,
+    extendsFilePaths,
+  }
+  const fileExport = getConfigFileExport(
+    fileExports,
+    filePath.filePathToShowToUser
+  )
+  Object.entries(fileExport).forEach(([configName, configValue]) => {
+    interfaceFile.fileExportsByConfigName[configName] = { configValue }
+  })
+  return interfaceFile
+}
+/** Show error message upon unknown config */
+function assertAllConfigsAreKnown(
+  interfaceFilesByLocationId: InterfaceFilesByLocationId
+) {
+  objectEntries(interfaceFilesByLocationId).forEach(
+    ([locationId, interfaceFiles]) => {
+      const interfaceFilesRelevant = getInterfaceFilesRelevant(
+        interfaceFilesByLocationId,
+        locationId
+      )
+      const configDefinitions = getConfigDefinitions(interfaceFilesRelevant)
+      interfaceFiles.forEach((interfaceFile) => {
+        Object.keys(interfaceFile.fileExportsByConfigName).forEach(
+          (configName) => {
+            assertConfigExists(
+              configName,
+              Object.keys(configDefinitions),
+              interfaceFile.filePath.filePathToShowToUser
+            )
+          }
+        )
+      })
+    }
+  )
+}
+
+async function loadRevealConfig_withErrorHandling(
+  userRootDir: string,
+  outDirRoot: string,
+  isDev: boolean,
+  crawlWithGit: null | boolean,
+  tolerateInvalidConfig?: boolean
+): Promise<RevealConfigObject> {
+  let hasError = false
+  let ret: RevealConfigObject | undefined
+  let err: unknown
+  try {
+    ret = await loadRevealConfig(userRootDir, outDirRoot, isDev, crawlWithGit)
+  } catch (err_) {
+    hasError = true
+    err = err_
+  }
+  if (!hasError) {
+    assert(ret)
+    assert(err === undefined)
+    isConfigInvalid_set(false)
+    return ret
+  } else {
+    assert(ret === undefined)
+    assert(err)
+    isConfigInvalid_set({ err })
+    if (!isDev) {
+      assert(getViteDevServer() === null)
+      throw err
+    } else {
+      logConfigError(err)
+      if (!tolerateInvalidConfig) {
+        devServerIsCorrupt = true
+      }
+      const dummyData: RevealConfigObject = {
+        pageConfigs: [],
+        pageConfigGlobal: {
+          configDefinitions: {},
+          configValueSources: {},
+        },
+        globalRevealConfig: {},
+      }
+      return dummyData
+    }
+  }
+}
+async function loadRevealConfig(
+  userRootDir: string,
+  outDirRoot: string,
+  isDev: boolean,
+  crawlWithGit: null | boolean
+): Promise<RevealConfigObject> {
+  const interfaceFilesByLocationId = await loadInterfaceFiles(
+    userRootDir,
+    outDirRoot,
+    isDev,
+    crawlWithGit
+  )
+
+  const importedFilesLoaded: ImportedFilesLoaded = {}
+
+  const { globalRevealConfig, pageConfigGlobal } = await getGlobalConfigs(
+    interfaceFilesByLocationId,
+    userRootDir,
+    importedFilesLoaded
+  )
+
+  const pageConfigs: PageConfigBuildTime[] = (
+    await Promise.allSettled(
+      objectEntries(interfaceFilesByLocationId)
+        .filter(([pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
+        .map(async ([locationId]) => {
+          const interfaceFilesRelevant = getInterfaceFilesRelevant(
+            interfaceFilesByLocationId,
+            locationId
+          )
+          const interfaceFilesRelevantList: InterfaceFile[] = Object.values(
+            interfaceFilesRelevant
+          ).flat(1)
+
+          assertExtensionsPeerDependencies(interfaceFilesRelevantList)
+
+          const configDefinitions = getConfigDefinitions(interfaceFilesRelevant)
+
+          // Load value files of custom config-only configs
+          await Promise.allSettled(
+            interfaceFilesRelevantList.map(async (interfaceFile) => {
+              if (!interfaceFile.isValueFile) return
+              const { configName } = interfaceFile
+              if (isGlobalConfig(configName)) return
+              const configDef = getConfigDefinition(
+                configDefinitions,
+                configName,
+                interfaceFile.filePath.filePathToShowToUser
+              )
+              if (!isLoadableAtBuildTime(configDef)) return
+              const isAlreadyLoaded =
+                interfacefileIsAlreaydLoaded(interfaceFile)
+              if (isAlreadyLoaded) return
+              // Value files of built-in configs should have already been loaded at loadInterfaceFiles()
+              assert(!(configName in configDefinitionsBuiltIn))
+              await loadValueFile(interfaceFile, configName, userRootDir)
+            })
+          )
+
+          let configValueSources: ConfigValueSources = {}
+          await Promise.allSettled(
+            objectEntries(configDefinitions)
+              .filter(([configName]) => !isGlobalConfig(configName))
+              .map(async ([configName, configDef]) => {
+                const sources = await resolveConfigValueSources(
+                  configName,
+                  configDef,
+                  interfaceFilesRelevant,
+                  userRootDir,
+                  importedFilesLoaded
+                )
+                if (sources.length === 0) return
+                configValueSources[configName] = sources
+              })
+          )
+          configValueSources = sortConfigValueSources(
+            configValueSources,
+            locationId
+          )
+
+          const { routeFilesystem, isErrorPage } = determineRouteFilesystem(
+            locationId,
+            configValueSources
+          )
+
+          applyEffectsAll(configValueSources, configDefinitions)
+          const configValuesComputed = getComputed(
+            configValueSources,
+            configDefinitions
+          )
+
+          assertUsageGlobalConfigs(
+            interfaceFilesRelevantList,
+            configDefinitions,
+            interfaceFilesByLocationId
+          )
+
+          const pageConfig: PageConfigBuildTime = {
+            pageId: locationId,
+            isErrorPage,
+            routeFilesystem,
+            configDefinitions,
+            configValueSources,
+            configValuesComputed,
+          }
+          return pageConfig
+        })
+    )
+  )
+    .filter(
+      (result): result is PromiseFulfilledResult<PageConfigBuildTime> =>
+        result.status === "fulfilled"
+    )
+    .map((result) => result.value)
+
+  assertPageConfigs(pageConfigs)
+
+  return { pageConfigs, pageConfigGlobal, globalRevealConfig }
+}
+
+// TODO/soon: refactor
+//  - Dedupe: most of the assertUsageGlobalConfigs() code below is a copy-paste of the assertUsage() logic inside getGlobalConfigs()
+//    - This assertUsage() message is slightly better: use this one for getGlobalConfigs()
+// Global configs should be defined at global locations
+function assertUsageGlobalConfigs(
+  interfaceFilesRelevantList: InterfaceFile[],
+  configDefinitions: ConfigDefinitions,
+  interfaceFilesByLocationId: InterfaceFilesByLocationId
+) {
+  interfaceFilesRelevantList.forEach((interfaceFile) => {
+    const configNames: string[] = []
+    if (interfaceFile.isValueFile) {
+      configNames.push(interfaceFile.configName)
+    } else {
+      configNames.push(...Object.keys(interfaceFile.fileExportsByConfigName))
+    }
+    configNames.forEach((configName) => {
+      if (isGlobalConfig(configName)) return
+      const configDef = getConfigDefinition(
+        configDefinitions,
+        configName,
+        interfaceFile.filePath.filePathToShowToUser
+      )
+      if (configDef.global) {
+        const locationIds = objectKeys(interfaceFilesByLocationId)
+        if (!isGlobalLocation(interfaceFile.locationId, locationIds)) {
+          const interfaceFilesGlobal = objectFromEntries(
+            objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
+              return isGlobalLocation(locationId, locationIds)
+            })
+          )
+          const configFilesGlobal: string[] = []
+          objectEntries(interfaceFilesGlobal).forEach(
+            ([locationId, interfaceFiles]) => {
+              assert(isGlobalLocation(locationId, locationIds))
+              interfaceFiles.forEach((interfaceFile) => {
+                if (!interfaceFile.isConfigFile) return
+                const {
+                  filePath: { filePathAbsoluteUserRootDir },
+                } = interfaceFile
+                if (filePathAbsoluteUserRootDir) {
+                  configFilesGlobal.push(filePathAbsoluteUserRootDir)
+                }
+              })
+            }
+          )
+          assertUsage(
+            false,
+            [
+              `${interfaceFile.filePath.filePathToShowToUser} sets the config ${pc.cyan(
+                configName
+              )} but it's a global config:`,
+              configFilesGlobal.length > 0
+                ? `define ${pc.cyan(configName)} at ${joinEnglish(configFilesGlobal, "or")} instead.`
+                : `create a global config (e.g. /pages/+config.js) and define ${pc.cyan(configName)} there instead.`,
+            ].join(" ")
+          )
+        }
+      }
+    })
+  })
+}
+
+function deriveConfigEnvFromFileName(env: ConfigEnvInternal, fileName: string) {
+  env = { ...env }
+  if (fileName.includes(".server.")) {
+    env.server = true
+    env.client = false
+  } else if (fileName.includes(".client.")) {
+    env.client = true
+    env.server = false
+  } else if (fileName.includes(".shared.")) {
+    env.server = true
+    env.client = true
+  }
+  return env
+}
+
+function assertPageConfigs(pageConfigs: PageConfigBuildTime[]) {
+  pageConfigs.forEach((pageConfig) => {
+    assertOnBeforeRenderEnv(pageConfig)
+  })
+}
+function assertOnBeforeRenderEnv(pageConfig: PageConfigBuildTime) {
+  const onBeforeRenderConfig = pageConfig.configValueSources.onBeforeRender?.[0]
+  if (!onBeforeRenderConfig) return
+  const onBeforeRenderEnv = onBeforeRenderConfig.configEnv
+  const isClientRouting = getConfigValueBuildTime(
+    pageConfig,
+    "clientRouting",
+    "boolean"
+  )
+  // When using Server Routing, loading a onBeforeRender() hook on the client-side hasn't any effect (the Server Routing's client runtime never calls it); it unnecessarily bloats client bundle sizes
+  assertUsage(
+    !(onBeforeRenderEnv.client && !isClientRouting),
+    `Page ${pageConfig.pageId} has an onBeforeRender() hook with env ${pc.cyan(
+      JSON.stringify(onBeforeRenderEnv)
+    )} which doesn't make sense because the page is using Server Routing: onBeforeRender() can be run in the client only when using Client Routing.`
+  )
+}
+
+function interfacefileIsAlreaydLoaded(interfaceFile: InterfaceFile): boolean {
+  const configMapValues = Object.values(interfaceFile.fileExportsByConfigName)
+  const isAlreadyLoaded = configMapValues.some((conf) => "configValue" in conf)
+  if (isAlreadyLoaded) {
+    assert(configMapValues.every((conf) => "configValue" in conf))
+  }
+  return isAlreadyLoaded
+}
+
+function getInterfaceFilesRelevant(
+  interfaceFilesByLocationId: InterfaceFilesByLocationId,
+  locationIdPage: LocationId
+): InterfaceFilesByLocationId {
+  const interfaceFilesRelevant = Object.fromEntries(
+    objectEntries(interfaceFilesByLocationId)
+      .filter(([locationId]) => {
+        return isInherited(locationId, locationIdPage)
+      })
+      .sort(([locationId1], [locationId2]) =>
+        sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage)
+      )
+  )
+  return interfaceFilesRelevant
+}
+
+async function getGlobalConfigs(
+  interfaceFilesByLocationId: InterfaceFilesByLocationId,
+  userRootDir: string,
+  importedFilesLoaded: ImportedFilesLoaded
+) {
+  const locationIds = objectKeys(interfaceFilesByLocationId)
+  const interfaceFilesGlobal = objectFromEntries(
+    objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
+      return isGlobalLocation(locationId, locationIds)
+    })
+  )
+
+  // Validate that global configs live in global interface files
+  {
+    const interfaceFilesGlobalPaths: string[] = []
+    objectEntries(interfaceFilesGlobal).forEach(
+      ([locationId, interfaceFiles]) => {
+        assert(isGlobalLocation(locationId, locationIds))
+        interfaceFiles.forEach(
+          ({ filePath: { filePathAbsoluteUserRootDir } }) => {
+            if (filePathAbsoluteUserRootDir) {
+              interfaceFilesGlobalPaths.push(filePathAbsoluteUserRootDir)
+            }
+          }
+        )
+      }
+    )
+    const globalPaths = Array.from(
+      new Set(interfaceFilesGlobalPaths.map((p) => path.posix.dirname(p)))
+    )
+    objectEntries(interfaceFilesByLocationId).forEach(
+      ([locationId, interfaceFiles]) => {
+        interfaceFiles.forEach((interfaceFile) => {
+          Object.keys(interfaceFile.fileExportsByConfigName).forEach(
+            (configName) => {
+              if (
+                !isGlobalLocation(locationId, locationIds) &&
+                isGlobalConfig(configName)
+              ) {
+                assertUsage(
+                  false,
+                  [
+                    `${interfaceFile.filePath.filePathToShowToUser} defines the config ${pc.cyan(
+                      configName
+                    )} which is global:`,
+                    globalPaths.length
+                      ? `define ${pc.cyan(configName)} in ${joinEnglish(globalPaths, "or")} instead`
+                      : `create a global config (e.g. /pages/+config.js) and define ${pc.cyan(configName)} there instead`,
+                  ].join(" ")
+                )
+              }
+            }
+          )
+        })
+      }
+    )
+  }
+
+  const globalRevealConfig: Record<string, unknown> = {}
+  const pageConfigGlobal: PageConfigGlobalBuildTime = {
+    configDefinitions: configDefinitionsBuiltInGlobal,
+    configValueSources: {},
+  }
+  await Promise.allSettled(
+    objectEntries(configDefinitionsBuiltInGlobal).map(
+      async ([configName, configDef]) => {
+        const sources = await resolveConfigValueSources(
+          configName,
+          configDef,
+          interfaceFilesGlobal,
+          userRootDir,
+          importedFilesLoaded
+        )
+        const configValueSource = sources[0]
+        if (!configValueSource) return
+        if (
+          configName === "onBeforeRoute" ||
+          configName === "onPrerenderStart"
+        ) {
+          assert(!("value" in configValueSource))
+          pageConfigGlobal.configValueSources[configName] = [configValueSource]
+        } else {
+          assert("value" in configValueSource)
+          if (
+            configName === "prerender" &&
+            typeof configValueSource.value === "boolean"
+          )
+            return
+          const { filePathToShowToUser } = configValueSource.definedAtFilePath
+          assertWarning(
+            false,
+            `Being able to define config ${pc.cyan(
+              configName
+            )} in ${filePathToShowToUser} is experimental and will likely be removed. Define the config ${pc.cyan(
+              configName
+            )} in reveal's Vite plugin options instead.`,
+            { onlyOnce: true }
+          )
+          globalRevealConfig[configName] = configValueSource.value
+        }
+      }
+    )
+  )
+
+  return { pageConfigGlobal, globalRevealConfig }
+}
+
+async function resolveConfigValueSources(
+  configName: string,
+  configDef: ConfigDefinitionInternal,
+  interfaceFilesRelevant: InterfaceFilesByLocationId,
+  userRootDir: string,
+  importedFilesLoaded: ImportedFilesLoaded
+): Promise<ConfigValueSource[]> {
+  const sourcesInfo: Parameters<typeof getConfigValueSource>[] = []
+
+  // interfaceFilesRelevant is sorted by sortAfterInheritanceOrder()
+  for (const interfaceFiles of Object.values(interfaceFilesRelevant)) {
+    const interfaceFilesDefiningConfig = interfaceFiles.filter(
+      (interfaceFile) => interfaceFile.fileExportsByConfigName[configName]
+    )
+    if (interfaceFilesDefiningConfig.length === 0) continue
+    const visited = new WeakSet<InterfaceFile>()
+    const add = (interfaceFile: InterfaceFile) => {
+      assert(!visited.has(interfaceFile))
+      visited.add(interfaceFile)
+      const isHighestInheritancePrecedence = sourcesInfo.length === 0
+      sourcesInfo.push([
+        configName,
+        interfaceFile,
+        configDef,
+        userRootDir,
+        importedFilesLoaded,
+        isHighestInheritancePrecedence,
+      ])
+    }
+
+    // Main resolution logic
+    {
+      const interfaceValueFiles = interfaceFilesDefiningConfig
+        .filter(
+          (interfaceFile) =>
+            interfaceFile.isValueFile &&
+            // We consider side-effect configs (e.g. `export { frontmatter }` of .mdx files) later (i.e. with less priority)
+            interfaceFile.configName === configName
+        )
+        .sort(makeOrderDeterministic)
+      const interfaceConfigFiles = interfaceFilesDefiningConfig
+        .filter(
+          (interfaceFile) =>
+            interfaceFile.isConfigFile &&
+            // We consider value from extended configs (e.g. reveal-react) later (i.e. with less priority)
+            !interfaceFile.isConfigExtend
+        )
+        .sort(makeOrderDeterministic)
+      const interfaceValueFile = interfaceValueFiles[0]
+      const interfaceConfigFile = interfaceConfigFiles[0]
+      // Make this value:
+      //   /pages/some-page/+{configName}.js > `export default`
+      // override that value:
+      //   /pages/some-page/+config.js > `export default { someConfig }`
+      const interfaceFileWinner = interfaceValueFile ?? interfaceConfigFile
+      if (interfaceFileWinner) {
+        const interfaceFilesOverriden = [
+          ...interfaceValueFiles,
+          ...interfaceConfigFiles,
+        ].filter((f) => f !== interfaceFileWinner)
+        // A user-land conflict of interfaceFiles with the same locationId means that the user has superfluously defined the config twice; the user should remove such redundancy making things unnecessarily ambiguous
+        warnOverridenConfigValues(
+          interfaceFileWinner,
+          interfaceFilesOverriden,
+          configName
+        )
+        ;[interfaceFileWinner, ...interfaceFilesOverriden].forEach(
+          (interfaceFile) => {
+            add(interfaceFile)
+          }
+        )
+      }
+    }
+
+    // Side-effect configs such as `export { frontmatter }` in .mdx files
+    interfaceFilesDefiningConfig
+      .filter(
+        (interfaceFile) =>
+          interfaceFile.isValueFile &&
+          // Is side-effect config
+          interfaceFile.configName !== configName
+      )
+      .forEach((interfaceValueFileSideEffect) => {
+        add(interfaceValueFileSideEffect)
+      })
+
+    // extends
+    interfaceFilesDefiningConfig
+      .filter(
+        (interfaceFile) =>
+          interfaceFile.isConfigFile && interfaceFile.isConfigExtend
+      )
+      // extended config files are already sorted by inheritance order
+      .forEach((interfaceFile) => {
+        add(interfaceFile)
+      })
+
+    interfaceFilesDefiningConfig.forEach((interfaceFile) => {
+      assert(visited.has(interfaceFile))
+    })
+  }
+
+  const sourcesSettled = await Promise.allSettled(
+    sourcesInfo.map(async (args) => await getConfigValueSource(...args))
+  )
+  const sources: ConfigValueSource[] = sourcesSettled
+    .filter(
+      (result): result is PromiseFulfilledResult<ConfigValueSource> =>
+        result.status === "fulfilled"
+    )
+    .map((result) => result.value)
+  return sources
+}
+function makeOrderDeterministic(
+  interfaceFile1: InterfaceFile,
+  interfaceFile2: InterfaceFile
+): 0 | -1 | 1 {
+  return lowerFirst<InterfaceFile>((interfaceFile) => {
+    const { filePathAbsoluteUserRootDir } = interfaceFile.filePath
+    assert(isInterfaceFileUserLand(interfaceFile))
+    assert(filePathAbsoluteUserRootDir)
+    return filePathAbsoluteUserRootDir.length
+  })(interfaceFile1, interfaceFile2)
+}
+function warnOverridenConfigValues(
+  interfaceFileWinner: InterfaceFile,
+  interfaceFilesOverriden: InterfaceFile[],
+  configName: string
+) {
+  interfaceFilesOverriden.forEach((interfaceFileLoser) => {
+    const loserFilePath = interfaceFileLoser.filePath.filePathToShowToUser
+    const winnerFilePath = interfaceFileWinner.filePath.filePathToShowToUser
+    const confName = pc.cyan(configName)
+    assertWarning(
+      false,
+      `The value of the config ${confName} defined at ${loserFilePath} is always overwritten by the value defined at ${winnerFilePath}, remove the superfluous value defined at ${loserFilePath}`,
+      { onlyOnce: true }
+    )
+  })
+}
+
+function isInterfaceFileUserLand(interfaceFile: InterfaceFile) {
+  return (
+    (interfaceFile.isConfigFile && !interfaceFile.isConfigExtend) ||
+    interfaceFile.isValueFile
+  )
+}
+
+async function getConfigValueSource(
+  configName: string,
+  interfaceFile: InterfaceFile,
+  configDef: ConfigDefinitionInternal,
+  userRootDir: string,
+  importedFilesLoaded: ImportedFilesLoaded,
+  isHighestInheritancePrecedence: boolean
+): Promise<ConfigValueSource> {
+  const conf = interfaceFile.fileExportsByConfigName[configName]
+  assert(conf)
+  const configEnv = deriveConfigEnvFromFileName(
+    configDef.env,
+    interfaceFile.filePath.fileName
+  )
+  const { locationId } = interfaceFile
+
+  const definedAtFilePath_: DefinedAtFilePath = {
+    ...interfaceFile.filePath,
+    fileExportPathToShowToUser: ["default", configName],
+  }
+
+  const isOverriden = configDef.cumulative
+    ? false
+    : !isHighestInheritancePrecedence
+
+  // +client.js
+  if (configDef._valueIsFilePath) {
+    let definedAtFilePath: DefinedAtFilePath
+    let valueFilePath: string
+    if (interfaceFile.isConfigFile) {
+      const { configValue } = conf
+      const pointerImport = resolvePointerImportOfConfig(
+        configValue,
+        interfaceFile.filePath,
+        userRootDir,
+        configEnv,
+        configName
+      )
+      const configDefinedAt = getConfigDefinedAt(
+        "Config",
+        configName,
+        definedAtFilePath_
+      )
+      assertUsage(pointerImport, `${configDefinedAt} should be an import`)
+      valueFilePath = pointerImport.filePathAbsoluteVite
+      definedAtFilePath = pointerImport
+    } else {
+      assert(interfaceFile.isValueFile)
+      valueFilePath = interfaceFile.filePath.filePathAbsoluteVite
+      definedAtFilePath = {
+        ...interfaceFile.filePath,
+        fileExportPathToShowToUser: [],
+      }
+    }
+    const configValueSource: ConfigValueSource = {
+      locationId,
+      value: valueFilePath,
+      valueIsFilePath: true,
+      configEnv,
+      valueIsImportedAtRuntime: true,
+      valueIsDefinedByPlusFile: false,
+      isOverriden,
+      definedAtFilePath,
+    }
+    return configValueSource
+  }
+
+  // +config.js
+  if (interfaceFile.isConfigFile) {
+    assert("configValue" in conf)
+    const { configValue } = conf
+
+    // Pointer import
+    const pointerImport = resolvePointerImportOfConfig(
+      configValue,
+      interfaceFile.filePath,
+      userRootDir,
+      configEnv,
+      configName
+    )
+    if (pointerImport) {
+      const configValueSource: ConfigValueSource = {
+        locationId,
+        configEnv,
+        valueIsImportedAtRuntime: true,
+        valueIsDefinedByPlusFile: false,
+        isOverriden,
+        definedAtFilePath: pointerImport,
+      }
+      // Load pointer import
+      if (
+        isLoadableAtBuildTime(configDef) &&
+        // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
+        configName !== "extends"
+      ) {
+        if (pointerImport.filePathAbsoluteFilesystem) {
+          const fileExport = await loadImportedFile(
+            pointerImport,
+            userRootDir,
+            importedFilesLoaded
+          )
+          configValueSource.value = fileExport
+        } else {
+          const configDefinedAt = getConfigDefinedAt(
+            "Config",
+            configName,
+            configValueSource.definedAtFilePath
+          )
+          assertUsage(
+            !configDef.cumulative,
+            `${configDefinedAt} cannot be defined over an aliased import`
+          )
+        }
+      }
+
+      return configValueSource
+    }
+
+    // Defined by config file, i.e. +config.js file
+    const configValueSource: ConfigValueSource = {
+      locationId,
+      value: configValue,
+      configEnv,
+      valueIsImportedAtRuntime: false,
+      valueIsDefinedByPlusFile: false,
+      isOverriden,
+      definedAtFilePath: definedAtFilePath_,
+    }
+    return configValueSource
+  }
+
+  // Defined by value file, i.e. +{configName}.js
+  if (interfaceFile.isValueFile) {
+    const valueAlreadyLoaded = "configValue" in conf
+    assert(valueAlreadyLoaded === !!configEnv.config)
+    const configValueSource: ConfigValueSource = {
+      locationId,
+      configEnv,
+      valueIsImportedAtRuntime: !valueAlreadyLoaded,
+      valueIsDefinedByPlusFile: true,
+      isOverriden,
+      definedAtFilePath: {
+        ...interfaceFile.filePath,
+        fileExportPathToShowToUser:
+          configName === interfaceFile.configName
+            ? []
+            : // Side-effect config (e.g. `export { frontmatter }` of .md files)
+              [configName],
+      },
+    }
+    if (valueAlreadyLoaded) {
+      configValueSource.value = conf.configValue
+    }
+    return configValueSource
+  }
+
+  assert(false)
+}
+
+function isDefiningPage(interfaceFiles: InterfaceFile[]): boolean {
+  for (const interfaceFile of interfaceFiles) {
+    const configNames = Object.keys(interfaceFile.fileExportsByConfigName)
+    if (configNames.some((configName) => isDefiningPageConfig(configName))) {
+      return true
+    }
+  }
+  return false
+}
+function isDefiningPageConfig(configName: string): boolean {
+  return ["Page", "route"].includes(configName)
+}
+
+function getConfigDefinitions(
+  interfaceFilesRelevant: InterfaceFilesByLocationId
+): ConfigDefinitions {
+  const configDefinitionsMerged: ConfigDefinitions = {
+    ...configDefinitionsBuiltIn,
+  }
+  Object.entries(interfaceFilesRelevant)
+    .reverse()
+    .forEach(([_locationId, interfaceFiles]) => {
+      interfaceFiles.forEach((interfaceFile) => {
+        const configMeta = interfaceFile.fileExportsByConfigName["meta"]
+        if (!configMeta) return
+        const meta = configMeta.configValue
+        assertMetaUsage(
+          meta,
+          `Config ${pc.cyan("meta")} defined at ${interfaceFile.filePath.filePathToShowToUser}`
+        )
+
+        // Set configDef._userEffectDefinedAtFilePath
+        Object.entries(meta).forEach(([configName, configDef]) => {
+          if (!configDef.effect) return
+          assert(interfaceFile.isConfigFile)
+          configDef._userEffectDefinedAtFilePath = {
+            ...interfaceFile.filePath,
+            fileExportPathToShowToUser: [
+              "default",
+              "meta",
+              configName,
+              "effect",
+            ],
+          }
+        })
+
+        objectEntries(meta).forEach(([configName, configDefinition]) => {
+          // User can override an existing config definition
+          configDefinitionsMerged[configName] = {
+            ...configDefinitionsMerged[configName],
+            ...configDefinition,
+          }
+        })
+      })
+    })
+
+  const configDefinitions = configDefinitionsMerged
+  return configDefinitions
+}
+
+function assertMetaUsage(
+  metaVal: unknown,
+  metaConfigDefinedAt: `Config meta defined at ${string}` | null
+): asserts metaVal is ConfigDefinitions {
+  if (!isObject(metaVal)) {
+    assert(metaConfigDefinedAt) // We expect internal effects to return a valid meta value
+    assertUsage(
+      false,
+      `${metaConfigDefinedAt} has an invalid type ${pc.cyan(typeof metaVal)}: it should be an object instead.`
+    )
+  }
+  objectEntries(metaVal).forEach(([configName, def]) => {
+    if (!isObject(def)) {
+      assert(metaConfigDefinedAt) // We expect internal effects to return a valid meta value
+      assertUsage(
+        false,
+        `${metaConfigDefinedAt} sets ${pc.cyan(`meta.${configName}`)} to a value with an invalid type ${pc.cyan(
+          typeof def
+        )}: it should be an object instead.`
+      )
+    }
+
+    // env
+    let configEnv: ConfigEnvInternal
+    {
+      assert(metaConfigDefinedAt) // We expect internal effects to return a valid meta value
+      if (!("env" in def)) {
+        assertUsage(
+          false,
+          `${metaConfigDefinedAt} doesn't set ${pc.cyan(`meta.${configName}.env`)} but it's required.`
+        )
+      }
+      configEnv = getConfigEnvValue(
+        def.env,
+        `${metaConfigDefinedAt} sets ${pc.cyan(`meta.${configName}.env`)} to`
+      )
+    }
+
+    // effect
+    if ("effect" in def) {
+      if (!hasProp(def, "effect", "function")) {
+        assert(metaConfigDefinedAt) // We expect internal effects to return a valid meta value
+        assertUsage(
+          false,
+          `${metaConfigDefinedAt} sets ${pc.cyan(`meta.${configName}.effect`)} to an invalid type ${pc.cyan(
+            typeof def.effect
+          )}: it should be a function instead`
+        )
+      }
+      if (!configEnv.config) {
+        assert(metaConfigDefinedAt) // We expect internal effects to return a valid meta value
+        assertUsage(
+          false,
+          `${metaConfigDefinedAt} sets ${pc.cyan(
+            `meta.${configName}.effect`
+          )} but it's only supported if meta.${configName}.env has ${pc.cyan("{ config: true }")} (but it's ${pc.cyan(
+            JSON.stringify(configEnv)
+          )} instead)`
+        )
+      }
+    }
+  })
+}
+
+function applyEffectsAll(
+  configValueSources: ConfigValueSources,
+  configDefinitions: ConfigDefinitions
+) {
+  objectEntries(configDefinitions).forEach(([configName, configDef]) => {
+    if (!configDef.effect) return
+    // The value needs to be loaded at config time, that's why we only support effect for configs that are config-only for now.
+    // (We could support effect for non config-only by always loading its value at config time, regardless of the config's `env` value.)
+    assertUsage(
+      configDef.env.config,
+      [
+        `Cannot add effect to ${pc.cyan(configName)} because its ${pc.cyan("env")} is ${pc.cyan(
+          JSON.stringify(configDef.env)
+        )}: effects can only be added to configs with an ${pc.cyan("env")} with ${pc.cyan("{ config: true }")}.`,
+      ].join(" ")
+    )
+    const source = configValueSources[configName]?.[0]
+    if (!source) return
+    // The config value is eagerly loaded since `configDef.env === 'config-only``
+    assert("value" in source)
+    // Call effect
+    const configModFromEffect = configDef.effect({
+      configValue: source.value,
+      configDefinedAt: getConfigDefinedAt(
+        "Config",
+        configName,
+        source.definedAtFilePath
+      ),
+    })
+    if (!configModFromEffect) return
+    assert(hasProp(source, "value")) // We need to assume that the config value is loaded at build-time
+    applyEffect(configModFromEffect, configValueSources, configDef)
+  })
+}
+function applyEffect(
+  configModFromEffect: Config,
+  configValueSources: ConfigValueSources,
+  configDefEffect: ConfigDefinitionInternal
+) {
+  const notSupported =
+    `Effects currently only supports modifying the the ${pc.cyan("env")} of a config.` as const
+  objectEntries(configModFromEffect).forEach(([configName, configValue]) => {
+    if (configName === "meta") {
+      let configDefinedAt: Parameters<typeof assertMetaUsage>[1]
+      if (configDefEffect._userEffectDefinedAtFilePath) {
+        configDefinedAt = getConfigDefinedAt(
+          "Config",
+          configName,
+          configDefEffect._userEffectDefinedAtFilePath
+        )
+      } else {
+        configDefinedAt = null
+      }
+      assertMetaUsage(configValue, configDefinedAt)
+      objectEntries(configValue).forEach(
+        ([configTargetName, configTargetDef]) => {
+          {
+            const keys = Object.keys(configTargetDef)
+            assertUsage(keys.includes("env"), notSupported)
+            assertUsage(keys.length === 1, notSupported)
+          }
+          const envOverriden = configTargetDef.env
+          const sources = configValueSources[configTargetName]
+          sources?.forEach((configValueSource) => {
+            // Apply effect
+            configValueSource.configEnv = envOverriden
+          })
+        }
+      )
+    } else {
+      assertUsage(false, notSupported)
+      /* To implement being able to set a config value in an effect:
+       * - Copy and append definedAtFile.fileExportPathToShowToUser with ['meta', configName, 'effect']
+       *   - Copying the definedAtFile of the config that defines the effect
+       * - Same precedence as the config that sets the value triggering the effect (not the config defining the effect)
+       *   - Apply sortConfigValueSources() again?
+      configValueSources.push()
+      */
+    }
+  })
+}
+
+function getComputed(
+  configValueSources: ConfigValueSources,
+  configDefinitions: ConfigDefinitions
+) {
+  const configValuesComputed: ConfigValuesComputed = {}
+  objectEntries(configDefinitions).forEach(([configName, configDef]) => {
+    if (!configDef._computed) return
+    const value = configDef._computed(configValueSources)
+    if (value === undefined) return
+    configValuesComputed[configName] = {
+      value,
+      configEnv: configDef.env,
+    }
+  })
+  return configValuesComputed
+}
+
+async function findPlusFiles(
+  userRootDir: string,
+  outDirRoot: string,
+  isDev: boolean,
+  crawlWithGit: null | boolean
+): Promise<FilePathResolved[]> {
+  const files = await crawlPlusFiles(
+    userRootDir,
+    outDirRoot,
+    isDev,
+    crawlWithGit
+  )
+
+  const plusFiles: FilePathResolved[] = files.map(
+    ({ filePathAbsoluteUserRootDir }) =>
+      getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir })
+  )
+
+  return plusFiles
+}
+
+function getConfigName(filePath: string): string | null {
+  assertPosixPath(filePath)
+  if (isTemporaryBuildFile(filePath)) return null
+  const fileName = path.posix.basename(filePath)
+  assertNoUnexpectedPlusSign(filePath, fileName)
+  const basename = fileName.split(".")[0]!
+  if (!basename.startsWith("+")) {
+    return null
+  } else {
+    const configName = basename.slice(1)
+    assertUsage(configName !== "", `${filePath} Invalid filename ${fileName}`)
+    return configName
+  }
+}
+/* https://github.com/revealjs/reveal/issues/1407 */
+function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
+  const dirs = path.posix.dirname(filePath).split("/")
+  dirs.forEach((dir, i) => {
+    const dirPath = dirs.slice(0, i + 1).join("/")
+    assertUsage(
+      !dir.includes("+"),
+      `Character '+' is a reserved character: remove '+' from the directory name ${dirPath}/`
+    )
+  })
+  assertUsage(
+    !fileName.slice(1).includes("+"),
+    `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`
+  )
+}
+
+function handleUnknownConfig(
+  configName: string,
+  configNames: string[],
+  filePathToShowToUser: string
+) {
+  const configNameColored = pc.cyan(configName)
+  let errMsg =
+    `${filePathToShowToUser} sets an unknown config ${configNameColored}.` as const
+
+  // reveal-{react,vue,solid} hint
+  {
+    const ui = ["reveal"] as const
+    const knownRevealExntensionConfigs = {
+      description: ui,
+      favicon: ui,
+      Head: ui,
+      Layout: ui,
+      onCreateApp: ["reveal"],
+      title: ui,
+      ssr: ui,
+      stream: ui,
+      Wrapper: ui,
+    } as const
+    if (configName in knownRevealExntensionConfigs) {
+      const requiredRevealExtension =
+        knownRevealExntensionConfigs[
+          configName as keyof typeof knownRevealExntensionConfigs
+        ]
+      assertUsage(
+        false,
+        [
+          errMsg,
+          `If you want to use the configuration documented at https://reveal.dev/${configName} then make sure to install the reveal extension ${requiredRevealExtension
+            .map((e) => pc.bold(e))
+            .join("/")}.`,
+          `Also make sure it applies to ${filePathToShowToUser} (see https://reveal.dev/extends#inheritance).`,
+          `Alternatively, if you don't want to use the aforementioned reveal extension, define it yourself by using ${pc.cyan(
+            "meta"
+          )} (https://reveal.dev/meta).`,
+        ].join(" ")
+      )
+    }
+  }
+
+  // Similarity hint
+  let configNameSimilar: string | null = null
+  if (configName === "page") {
+    configNameSimilar = "Page"
+  } else {
+    configNameSimilar = getMostSimilar(configName, configNames)
+  }
+  if (configNameSimilar) {
+    assert(configNameSimilar !== configName)
+    errMsg += ` Did you mean to set ${pc.cyan(configNameSimilar)} instead?`
+    if (configName === "page") {
+      errMsg += ` (The name of the config ${pc.cyan("Page")} starts with a capital letter ${pc.cyan(
+        "P"
+      )} because it defines a UI component: a ubiquitous JavaScript convention is that the name of UI components start with a capital letter.)`
+    }
+  }
+
+  // `meta` hint
+  if (!configNameSimilar) {
+    errMsg += ` Make sure to define ${configNameColored} by using ${pc.cyan(
+      "meta"
+    )} (https://reveal.dev/meta), and also make sure the meta configuration applies to ${filePathToShowToUser} (see https://reveal.dev/config#inheritance).`
+  }
+
+  assertUsage(false, errMsg)
+}
+
+function determineRouteFilesystem(
+  locationId: LocationId,
+  configValueSources: ConfigValueSources
+) {
+  const configName = "filesystemRoutingRoot"
+  const configFilesystemRoutingRoot = configValueSources[configName]?.[0]
+  let filesystemRouteString = getFilesystemRouteString(locationId)
+  if (determineIsErrorPage(filesystemRouteString)) {
+    return { isErrorPage: true as const, routeFilesystem: undefined }
+  }
+  let filesystemRouteDefinedBy = getFilesystemRouteDefinedBy(locationId) // for log404()
+  if (configFilesystemRoutingRoot) {
+    const routingRoot = getFilesystemRoutingRootEffect(
+      configFilesystemRoutingRoot,
+      configName
+    )
+    if (routingRoot) {
+      const {
+        filesystemRoutingRootEffect,
+        filesystemRoutingRootConfigDefinedAt,
+      } = routingRoot
+      const debugInfo = {
+        locationId,
+        routeFilesystem: filesystemRouteString,
+        configFilesystemRoutingRoot,
+      }
+      assertLog(
+        filesystemRouteString.startsWith(filesystemRoutingRootEffect.before),
+        debugInfo
+      )
+      filesystemRouteString = applyFilesystemRoutingRootEffect(
+        filesystemRouteString,
+        filesystemRoutingRootEffect
+      )
+      filesystemRouteDefinedBy = `${filesystemRouteDefinedBy} (with ${filesystemRoutingRootConfigDefinedAt})`
+    }
+  }
+  assert(filesystemRouteString.startsWith("/"))
+  const routeFilesystem = {
+    routeString: filesystemRouteString,
+    definedBy: filesystemRouteDefinedBy,
+  }
+  return { routeFilesystem, isErrorPage: undefined }
+}
+function getFilesystemRoutingRootEffect(
+  configFilesystemRoutingRoot: ConfigValueSource,
+  configName: "filesystemRoutingRoot"
+) {
+  assert(configFilesystemRoutingRoot.configEnv.config)
+  // Eagerly loaded since it's config-only
+  assert("value" in configFilesystemRoutingRoot)
+  const { value } = configFilesystemRoutingRoot
+  const configDefinedAt = getConfigDefinedAt(
+    "Config",
+    configName,
+    configFilesystemRoutingRoot.definedAtFilePath
+  )
+  assertUsage(
+    typeof value === "string",
+    `${configDefinedAt} should be a string`
+  )
+  assertUsage(
+    value.startsWith("/"),
+    `${configDefinedAt} is ${pc.cyan(value)} but it should start with a leading slash ${pc.cyan("/")}`
+  )
+  const { filePathAbsoluteUserRootDir } =
+    configFilesystemRoutingRoot.definedAtFilePath
+  assert(filePathAbsoluteUserRootDir)
+  const before = getFilesystemRouteString(
+    getLocationId(filePathAbsoluteUserRootDir)
+  )
+  const after = value
+  const filesystemRoutingRootEffect = { before, after }
+  return {
+    filesystemRoutingRootEffect,
+    filesystemRoutingRootConfigDefinedAt: configDefinedAt,
+  }
+}
+function determineIsErrorPage(routeFilesystem: string) {
+  assertPosixPath(routeFilesystem)
+  return routeFilesystem.split("/").includes("_error")
+}
+
+function isRevealConfigFile(filePath: string): boolean {
+  return !!getConfigName(filePath)
+}
+
+function getConfigEnvValue(
+  val: unknown,
+  errMsgIntro: `Config meta defined at ${string} sets meta.${
+    string // configName
+  }.env to`
+): ConfigEnvInternal {
+  const errInvalidValue = `${errMsgIntro} an invalid value ${pc.cyan(JSON.stringify(val))}`
+
+  assertUsage(
+    isObject(val),
+    `${errMsgIntro} an invalid type ${pc.cyan(typeof val)}`
+  )
+
+  assertKeys(
+    val,
+    ["config", "server", "client"] as const,
+    `${errInvalidValue}:`
+  )
+  assertUsage(
+    hasProp(val, "config", "undefined") || hasProp(val, "config", "boolean"),
+    errInvalidValue
+  )
+  assertUsage(
+    hasProp(val, "server", "undefined") || hasProp(val, "server", "boolean"),
+    errInvalidValue
+  )
+  assertUsage(
+    hasProp(val, "client", "undefined") || hasProp(val, "client", "boolean"),
+    errInvalidValue
+  )
+  /* To allow users to set an eager config:
+   * - Uncomment line below.
+   * - Add 'eager' to assertKeys() call above.
+   * - Add `eager: boolean` to ConfigEnv type.
+   * */
+  assertUsage(
+    hasProp(val, "eager", "undefined") || hasProp(val, "eager", "boolean"),
+    errInvalidValue
+  )
+
+  return val
+}
+
+function getConfigDefinition(
+  configDefinitions: ConfigDefinitions,
+  configName: string,
+  filePathToShowToUser: string
+) {
+  const configDef = configDefinitions[configName]
+  assertConfigExists(
+    configName,
+    Object.keys(configDefinitions),
+    filePathToShowToUser
+  )
+  assert(configDef)
+  return configDef
+}
+function getConfigDefinitionOptional(
+  configDefinitions: ConfigDefinitions,
+  configName: string
+) {
+  return configDefinitions[configName] ?? null
+}
+function isLoadableAtBuildTime(configDef: ConfigDefinitionInternal): boolean {
+  return !!configDef.env.config && !configDef._valueIsFilePath
+}
+function isGlobalConfig(configName: string): configName is ConfigNameGlobal {
+  if (configName === "prerender") return false
+  const configNamesGlobal = getConfigNamesGlobal()
+  return includes(configNamesGlobal, configName)
+}
+function getConfigNamesGlobal() {
+  return Object.keys(configDefinitionsBuiltInGlobal)
+}
+function assertConfigExists(
+  configName: string,
+  configNamesRelevant: string[],
+  filePathToShowToUser: string
+) {
+  const configNames = [...configNamesRelevant, ...getConfigNamesGlobal()]
+  if (configNames.includes(configName)) return
+  handleUnknownConfig(configName, configNames, filePathToShowToUser)
+  assert(false)
+}
+
+function sortConfigValueSources(
+  configValueSources: ConfigValueSources,
+  locationIdPage: LocationId
+): ConfigValueSources {
+  return Object.fromEntries(
+    Object.entries(configValueSources)
+      // Make order deterministic (no other purpose)
+      .sort(([, [source1]], [, [source2]]) =>
+        source1!.definedAtFilePath.filePathAbsoluteVite <
+        source2!.definedAtFilePath.filePathAbsoluteVite
+          ? -1
+          : 1
+      )
+      // Sort after whether the config value was defined by an npm package
+      .sort(
+        makeFirst(([, [source]]) => {
+          const { importPathAbsolute } = source!.definedAtFilePath
+          return (
+            !!importPathAbsolute &&
+            isNpmPackageImport(importPathAbsolute, {
+              // Reveal config files don't support path aliases. (If they do one day, then Reveal will/should be able to resolve path aliases.)
+              cannotBePathAlias: true,
+            })
+          )
+        })
+      )
+      // Sort after the filesystem inheritance of the config value
+      .sort(([, [source1]], [, [source2]]) =>
+        reverse(
+          sortAfterInheritanceOrder(
+            source1!.locationId,
+            source2!.locationId,
+            locationIdPage
+          )
+        )
+      )
+  )
+}
+
+function getConfigValueInterfaceFile(
+  interfaceFile: InterfaceFile,
+  configName: string
+): unknown {
+  return interfaceFile.fileExportsByConfigName[configName]?.configValue
+}