@tanstack/router-generator 1.121.0-alpha.5 → 1.121.0

package/src/generator.ts

@@ -1,370 +1,1154 @@
 import path from 'node:path'
-import * as fs from 'node:fs'
 import * as fsp from 'node:fs/promises'
+import { mkdtempSync } from 'node:fs'
+import crypto from 'node:crypto'
+import { deepEqual, rootRouteId } from '@tanstack/router-core'
+import { logging } from './logger'
+import { getRouteNodes as physicalGetRouteNodes } from './filesystem/physical/getRouteNodes'
+import { getRouteNodes as virtualGetRouteNodes } from './filesystem/virtual/getRouteNodes'
+import { rootPathId } from './filesystem/physical/rootPathId'
 import {
+  buildImportString,
+  buildRouteTreeConfig,
+  checkFileExists,
+  createRouteNodesByFullPath,
+  createRouteNodesById,
+  createRouteNodesByTo,
+  determineNodePath,
+  findParent,
   format,
-  logging,
+  getResolvedRouteNodeVariableName,
+  hasParentRoute,
+  inferFullPath,
+  inferPath,
+  isRouteNodeValidForAugmentation,
+  lowerCaseFirstChar,
+  mergeImportDeclarations,
   multiSortBy,
   removeExt,
+  removeGroups,
+  removeLastSegmentFromPath,
+  removeLayoutSegments,
   removeUnderscores,
   replaceBackslash,
   resetRegex,
   routePathToVariable,
   trimPathLeft,
-  writeIfDifferent,
 } from './utils'
-import { getRouteNodes as physicalGetRouteNodes } from './filesystem/physical/getRouteNodes'
-import { getRouteNodes as virtualGetRouteNodes } from './filesystem/virtual/getRouteNodes'
-import { rootPathId } from './filesystem/physical/rootPathId'
 import { fillTemplate, getTargetTemplate } from './template'
-import type { FsRouteType, GetRouteNodesResult, RouteNode } from './types'
+import { transform } from './transform/transform'
+import { defaultGeneratorPlugin } from './plugin/default-generator-plugin'
+import type {
+  GeneratorPlugin,
+  GeneratorPluginWithTransform,
+} from './plugin/types'
+import type { TargetTemplate } from './template'
+import type {
+  FsRouteType,
+  GetRouteNodesResult,
+  HandleNodeAccumulator,
+  ImportDeclaration,
+  RouteNode,
+} from './types'
 import type { Config } from './config'
+import type { Logger } from './logger'
+import type { TransformPlugin } from './transform/types'
+
+interface fs {
+  stat: (filePath: string) => Promise<{ mtimeMs: bigint }>
+  mkdtempSync: (prefix: string) => string
+  rename: (oldPath: string, newPath: string) => Promise<void>
+  writeFile: (filePath: string, content: string) => Promise<void>
+  readFile: (
+    filePath: string,
+  ) => Promise<
+    { stat: { mtimeMs: bigint }; fileContent: string } | 'file-not-existing'
+  >
+}
+
+const DefaultFileSystem: fs = {
+  stat: (filePath) => fsp.stat(filePath, { bigint: true }),
+  mkdtempSync: mkdtempSync,
+  rename: (oldPath, newPath) => fsp.rename(oldPath, newPath),
+  writeFile: (filePath, content) => fsp.writeFile(filePath, content),
+  readFile: async (filePath: string) => {
+    try {
+      const fileHandle = await fsp.open(filePath, 'r')
+      const stat = await fileHandle.stat({ bigint: true })
+      const fileContent = (await fileHandle.readFile()).toString()
+      await fileHandle.close()
+      return { stat, fileContent }
+    } catch (e: any) {
+      if ('code' in e) {
+        if (e.code === 'ENOENT') {
+          return 'file-not-existing'
+        }
+      }
+      throw e
+    }
+  },
+}
+
+interface Rerun {
+  rerun: true
+  msg?: string
+  event: GeneratorEvent
+}
+function rerun(opts: { msg?: string; event?: GeneratorEvent }): Rerun {
+  const { event, ...rest } = opts
+  return { rerun: true, event: event ?? { type: 'rerun' }, ...rest }
+}
+
+function isRerun(result: unknown): result is Rerun {
+  return (
+    typeof result === 'object' &&
+    result !== null &&
+    'rerun' in result &&
+    result.rerun === true
+  )
+}
 
-// Maybe import this from `@tanstack/router-core` in the future???
-const rootRouteId = '__root__'
+export type FileEventType = 'create' | 'update' | 'delete'
+export type FileEvent = {
+  type: FileEventType
+  path: string
+}
+export type GeneratorEvent = FileEvent | { type: 'rerun' }
 
-let latestTask = 0
-const routeGroupPatternRegex = /\(.+\)/g
-const possiblyNestedRouteGroupPatternRegex = /\([^/]+\)\/?/g
+type FileCacheChange<TCacheEntry extends GeneratorCacheEntry> =
+  | {
+      result: false
+      cacheEntry: TCacheEntry
+    }
+  | { result: true; mtimeMs: bigint; cacheEntry: TCacheEntry }
+  | {
+      result: 'file-not-in-cache'
+    }
+  | {
+      result: 'cannot-stat-file'
+    }
 
-let isFirst = false
-let skipMessage = false
+interface GeneratorCacheEntry {
+  mtimeMs: bigint
+  fileContent: string
+}
 
-type RouteSubNode = {
-  component?: RouteNode
-  errorComponent?: RouteNode
-  pendingComponent?: RouteNode
-  loader?: RouteNode
-  lazy?: RouteNode
+interface RouteNodeCacheEntry extends GeneratorCacheEntry {
+  exports: Array<string>
 }
 
-export async function generator(config: Config, root: string) {
-  const ROUTE_TEMPLATE = getTargetTemplate(config.target)
-  const logger = logging({ disabled: config.disableLogging })
-  logger.log('')
-
-  if (!isFirst) {
-    logger.log('♻️  Generating routes...')
-    isFirst = true
-  } else if (skipMessage) {
-    skipMessage = false
-  } else {
-    logger.log('♻️  Regenerating routes...')
+type GeneratorRouteNodeCache = Map</** filePath **/ string, RouteNodeCacheEntry>
+
+export class Generator {
+  /**
+   * why do we have two caches for the route files?
+   * During processing, we READ from the cache and WRITE to the shadow cache.
+   *
+   * After a route file is processed, we write to the shadow cache.
+   * If during processing we bail out and re-run, we don't lose this modification
+   * but still can track whether the file contributed changes and thus the route tree file needs to be regenerated.
+   * After all files are processed, we swap the shadow cache with the main cache and initialize a new shadow cache.
+   * That way we also ensure deleted/renamed files don't stay in the cache forever.
+   */
+  private routeNodeCache: GeneratorRouteNodeCache = new Map()
+  private routeNodeShadowCache: GeneratorRouteNodeCache = new Map()
+
+  private routeTreeFileCache: GeneratorCacheEntry | undefined
+
+  public config: Config
+  public targetTemplate: TargetTemplate
+
+  private root: string
+  private routesDirectoryPath: string
+  private tmpDir: string
+  private fs: fs
+  private logger: Logger
+  private generatedRouteTreePath: string
+  private runPromise: Promise<void> | undefined
+  private fileEventQueue: Array<GeneratorEvent> = []
+  private plugins: Array<GeneratorPlugin> = [defaultGeneratorPlugin()]
+  private pluginsWithTransform: Array<GeneratorPluginWithTransform> = []
+  // this is just a cache for the transform plugins since we need them for each route file that is to be processed
+  private transformPlugins: Array<TransformPlugin> = []
+  private routeGroupPatternRegex = /\(.+\)/g
+
+  constructor(opts: { config: Config; root: string; fs?: fs }) {
+    this.config = opts.config
+    this.logger = logging({ disabled: this.config.disableLogging })
+    this.root = opts.root
+    this.fs = opts.fs || DefaultFileSystem
+    this.tmpDir = this.fs.mkdtempSync(
+      path.join(this.config.tmpDir, 'router-generator-'),
+    )
+    this.generatedRouteTreePath = path.resolve(this.config.generatedRouteTree)
+    this.targetTemplate = getTargetTemplate(this.config)
+
+    this.routesDirectoryPath = this.getRoutesDirectoryPath()
+    this.plugins.push(...(opts.config.plugins || []))
+    this.plugins.forEach((plugin) => {
+      if ('transformPlugin' in plugin) {
+        if (this.pluginsWithTransform.find((p) => p.name === plugin.name)) {
+          throw new Error(
+            `Plugin with name "${plugin.name}" is already registered for export ${plugin.transformPlugin.exportName}!`,
+          )
+        }
+        this.pluginsWithTransform.push(plugin)
+        this.transformPlugins.push(plugin.transformPlugin)
+      }
+    })
   }
 
-  const taskId = latestTask + 1
-  latestTask = taskId
+  private getRoutesDirectoryPath() {
+    return path.isAbsolute(this.config.routesDirectory)
+      ? this.config.routesDirectory
+      : path.resolve(this.root, this.config.routesDirectory)
+  }
 
-  const checkLatest = () => {
-    if (latestTask !== taskId) {
-      skipMessage = true
-      return false
+  public async run(event?: GeneratorEvent): Promise<void> {
+    // we are only interested in FileEvents that affect either the generated route tree or files inside the routes folder
+    if (event && event.type !== 'rerun') {
+      if (
+        !(
+          event.path === this.generatedRouteTreePath ||
+          event.path.startsWith(this.routesDirectoryPath)
+        )
+      ) {
+        return
+      }
     }
+    this.fileEventQueue.push(event ?? { type: 'rerun' })
+    // only allow a single run at a time
+    if (this.runPromise) {
+      return this.runPromise
+    }
+
+    this.runPromise = (async () => {
+      do {
+        // synchronously copy and clear the queue since we are going to iterate asynchronously over it
+        // and while we do so, a new event could be put into the queue
+        const tempQueue = this.fileEventQueue
+        this.fileEventQueue = []
+        // if we only have 'update' events in the queue
+        // and we already have the affected files' latest state in our cache, we can exit early
+        const remainingEvents = (
+          await Promise.all(
+            tempQueue.map(async (e) => {
+              if (e.type === 'update') {
+                let cacheEntry
+                if (e.path === this.generatedRouteTreePath) {
+                  cacheEntry = this.routeTreeFileCache
+                } else {
+                  // we only check the routeNodeCache here
+                  // if the file's state is only up-to-date in the shadow cache we need to re-run
+                  cacheEntry = this.routeNodeCache.get(e.path)
+                }
+                const change = await this.didFileChangeComparedToCache(
+                  { path: e.path },
+                  cacheEntry,
+                )
+                if (change.result === false) {
+                  return null
+                }
+              }
+              return e
+            }),
+          )
+        ).filter((e) => e !== null)
+
+        if (remainingEvents.length === 0) {
+          break
+        }
 
-    return true
+        try {
+          const start = performance.now()
+          await this.generatorInternal()
+          const end = performance.now()
+          this.logger.info(
+            `Generated route tree in ${Math.round(end - start)}ms`,
+          )
+        } catch (err) {
+          const errArray = !Array.isArray(err) ? [err] : err
+
+          const recoverableErrors = errArray.filter((e) => isRerun(e))
+          if (recoverableErrors.length === errArray.length) {
+            this.fileEventQueue.push(...recoverableErrors.map((e) => e.event))
+            recoverableErrors.forEach((e) => {
+              if (e.msg) {
+                this.logger.info(e.msg)
+              }
+            })
+          } else {
+            const unrecoverableErrors = errArray.filter((e) => !isRerun(e))
+            this.runPromise = undefined
+            throw new Error(
+              unrecoverableErrors.map((e) => (e as Error).message).join(),
+            )
+          }
+        }
+      } while (this.fileEventQueue.length)
+      this.runPromise = undefined
+    })()
+    return this.runPromise
   }
 
-  const start = Date.now()
+  private async generatorInternal() {
+    let writeRouteTreeFile = false as boolean
 
-  const TYPES_DISABLED = config.disableTypes
+    let getRouteNodesResult: GetRouteNodesResult
 
-  let getRouteNodesResult: GetRouteNodesResult
+    if (this.config.virtualRouteConfig) {
+      getRouteNodesResult = await virtualGetRouteNodes(this.config, this.root)
+    } else {
+      getRouteNodesResult = await physicalGetRouteNodes(this.config, this.root)
+    }
 
-  if (config.virtualRouteConfig) {
-    getRouteNodesResult = await virtualGetRouteNodes(config, root)
-  } else {
-    getRouteNodesResult = await physicalGetRouteNodes(config, root)
-  }
+    const { rootRouteNode, routeNodes: beforeRouteNodes } = getRouteNodesResult
+    if (rootRouteNode === undefined) {
+      let errorMessage = `rootRouteNode must not be undefined. Make sure you've added your root route into the route-tree.`
+      if (!this.config.virtualRouteConfig) {
+        errorMessage += `\nMake sure that you add a "${rootPathId}.${this.config.disableTypes ? 'js' : 'tsx'}" file to your routes directory.\nAdd the file in: "${this.config.routesDirectory}/${rootPathId}.${this.config.disableTypes ? 'js' : 'tsx'}"`
+      }
+      throw new Error(errorMessage)
+    }
+
+    writeRouteTreeFile = await this.handleRootNode(rootRouteNode)
+
+    const preRouteNodes = multiSortBy(beforeRouteNodes, [
+      (d) => (d.routePath === '/' ? -1 : 1),
+      (d) => d.routePath?.split('/').length,
+      (d) =>
+        d.filePath.match(new RegExp(`[./]${this.config.indexToken}[.]`))
+          ? 1
+          : -1,
+      (d) =>
+        d.filePath.match(
+          /[./](component|errorComponent|pendingComponent|loader|lazy)[.]/,
+        )
+          ? 1
+          : -1,
+      (d) =>
+        d.filePath.match(new RegExp(`[./]${this.config.routeToken}[.]`))
+          ? -1
+          : 1,
+      (d) => (d.routePath?.endsWith('/') ? -1 : 1),
+      (d) => d.routePath,
+    ]).filter((d) => ![`/${rootPathId}`].includes(d.routePath || ''))
+
+    const routeFileAllResult = await Promise.allSettled(
+      preRouteNodes
+        // only process routes that are backed by an actual file
+        .filter((n) => !n.isVirtualParentRoute && !n.isVirtual)
+        .map((n) => this.processRouteNodeFile(n)),
+    )
 
-  const { rootRouteNode, routeNodes: beforeRouteNodes } = getRouteNodesResult
-  if (rootRouteNode === undefined) {
-    let errorMessage = `rootRouteNode must not be undefined. Make sure you've added your root route into the route-tree.`
-    if (!config.virtualRouteConfig) {
-      errorMessage += `\nMake sure that you add a "${rootPathId}.${config.disableTypes ? 'js' : 'tsx'}" file to your routes directory.\nAdd the file in: "${config.routesDirectory}/${rootPathId}.${config.disableTypes ? 'js' : 'tsx'}"`
+    const rejections = routeFileAllResult.filter(
+      (result) => result.status === 'rejected',
+    )
+    if (rejections.length > 0) {
+      throw rejections.map((e) => e.reason)
     }
-    throw new Error(errorMessage)
-  }
 
-  const preRouteNodes = multiSortBy(beforeRouteNodes, [
-    (d) => (d.routePath === '/' ? -1 : 1),
-    (d) => d.routePath?.split('/').length,
-    (d) =>
-      d.filePath.match(new RegExp(`[./]${config.indexToken}[.]`)) ? 1 : -1,
-    (d) =>
-      d.filePath.match(
-        /[./](component|errorComponent|pendingComponent|loader|lazy)[.]/,
-      )
-        ? 1
-        : -1,
-    (d) =>
-      d.filePath.match(new RegExp(`[./]${config.routeToken}[.]`)) ? -1 : 1,
-    (d) => (d.routePath?.endsWith('/') ? -1 : 1),
-    (d) => d.routePath,
-  ]).filter((d) => ![`/${rootPathId}`].includes(d.routePath || ''))
-
-  const routeTree: Array<RouteNode> = []
-  const routePiecesByPath: Record<string, RouteSubNode> = {}
-
-  // Loop over the flat list of routeNodes and
-  // build up a tree based on the routeNodes' routePath
-  const routeNodes: Array<RouteNode> = []
-
-  // the handleRootNode function is not being collapsed into the handleNode function
-  // because it requires only a subset of the logic that the handleNode function requires
-  // and it's easier to read and maintain this way
-  const handleRootNode = async (node?: RouteNode) => {
-    if (!node) {
-      // currently this is not being handled, but it could be in the future
-      // for example to handle a virtual root route
-      return
+    const routeFileResult = routeFileAllResult.flatMap((result) => {
+      if (result.status === 'fulfilled' && result.value !== null) {
+        return result.value
+      }
+      return []
+    })
+
+    routeFileResult.forEach((result) => {
+      if (!result.node.exports?.length) {
+        this.logger.warn(
+          `Route file "${result.cacheEntry.fileContent}" does not export any route piece. This is likely a mistake.`,
+        )
+      }
+    })
+    if (routeFileResult.find((r) => r.shouldWriteTree)) {
+      writeRouteTreeFile = true
     }
 
-    // from here on, we are only handling the root node that's present in the file system
-    const routeCode = fs.readFileSync(node.fullPath, 'utf-8')
+    // this is the first time the generator runs, so read in the route tree file if it exists yet
+    if (!this.routeTreeFileCache) {
+      const routeTreeFile = await this.fs.readFile(this.generatedRouteTreePath)
+      if (routeTreeFile !== 'file-not-existing') {
+        this.routeTreeFileCache = {
+          fileContent: routeTreeFile.fileContent,
+          mtimeMs: routeTreeFile.stat.mtimeMs,
+        }
+      }
+      writeRouteTreeFile = true
+    }
 
-    if (!routeCode) {
-      const _rootTemplate = ROUTE_TEMPLATE.rootRoute
-      const replaced = await fillTemplate(config, _rootTemplate.template(), {
-        tsrImports: _rootTemplate.imports.tsrImports(),
-        tsrPath: rootPathId,
-        tsrExportStart: _rootTemplate.imports.tsrExportStart(),
-        tsrExportEnd: _rootTemplate.imports.tsrExportEnd(),
-      })
+    if (!writeRouteTreeFile) {
+      return
+    }
 
-      await writeIfDifferent(
-        node.fullPath,
-        '', // Empty string because the file doesn't exist yet
-        replaced,
-        {
-          beforeWrite: () => {
-            logger.log(`🟡 Creating ${node.fullPath}`)
+    let routeTreeContent = this.buildRouteTreeFileContent(
+      rootRouteNode,
+      preRouteNodes,
+      routeFileResult,
+    )
+    routeTreeContent = this.config.enableRouteTreeFormatting
+      ? await format(routeTreeContent, this.config)
+      : routeTreeContent
+
+    let newMtimeMs: bigint | undefined
+    if (this.routeTreeFileCache) {
+      if (this.routeTreeFileCache.fileContent === routeTreeContent) {
+        // existing route tree file is already up-to-date, don't write it
+        // we should only get here in the initial run when the route cache is not filled yet
+      } else {
+        const newRouteTreeFileStat = await this.safeFileWrite({
+          filePath: this.generatedRouteTreePath,
+          newContent: routeTreeContent,
+          strategy: {
+            type: 'mtime',
+            expectedMtimeMs: this.routeTreeFileCache.mtimeMs,
           },
+        })
+        newMtimeMs = newRouteTreeFileStat.mtimeMs
+      }
+    } else {
+      const newRouteTreeFileStat = await this.safeFileWrite({
+        filePath: this.generatedRouteTreePath,
+        newContent: routeTreeContent,
+        strategy: {
+          type: 'new-file',
         },
-      )
+      })
+      newMtimeMs = newRouteTreeFileStat.mtimeMs
+    }
+
+    if (newMtimeMs !== undefined) {
+      this.routeTreeFileCache = {
+        fileContent: routeTreeContent,
+        mtimeMs: newMtimeMs,
+      }
     }
+
+    // now that we have finished this run, we can finally swap the caches
+    this.routeNodeCache = this.routeNodeShadowCache
+    this.routeNodeShadowCache = new Map()
   }
 
-  await handleRootNode(rootRouteNode)
+  private buildRouteTreeFileContent(
+    rootRouteNode: RouteNode,
+    preRouteNodes: Array<RouteNode>,
+    routeFileResult: Array<{
+      cacheEntry: RouteNodeCacheEntry
+      node: RouteNode
+    }>,
+  ) {
+    const getImportForRouteNode = (node: RouteNode, exportName: string) => {
+      if (node.exports?.includes(exportName)) {
+        return {
+          source: `./${this.getImportPath(node)}`,
+          specifiers: [
+            {
+              imported: exportName,
+              local: `${node.variableName}${exportName}Import`,
+            },
+          ],
+        } satisfies ImportDeclaration
+      }
+      return undefined
+    }
 
-  const handleNode = async (node: RouteNode) => {
-    // Do not remove this as we need to set the lastIndex to 0 as it
-    // is necessary to reset the regex's index when using the global flag
-    // otherwise it might not match the next time it's used
-    resetRegex(routeGroupPatternRegex)
+    const buildRouteTreeForExport = (plugin: GeneratorPluginWithTransform) => {
+      const exportName = plugin.transformPlugin.exportName
+      const acc: HandleNodeAccumulator = {
+        routeTree: [],
+        routeNodes: [],
+        routePiecesByPath: {},
+      }
+      for (const node of preRouteNodes) {
+        if (node.exports?.includes(plugin.transformPlugin.exportName)) {
+          this.handleNode(node, acc)
+        }
+      }
 
-    let parentRoute = hasParentRoute(routeNodes, node, node.routePath)
+      const sortedRouteNodes = multiSortBy(acc.routeNodes, [
+        (d) => (d.routePath?.includes(`/${rootPathId}`) ? -1 : 1),
+        (d) => d.routePath?.split('/').length,
+        (d) => (d.routePath?.endsWith(this.config.indexToken) ? -1 : 1),
+        (d) => d,
+      ])
+
+      const pluginConfig = plugin.config({
+        generator: this,
+        rootRouteNode,
+        sortedRouteNodes,
+      })
 
-    // if the parent route is a virtual parent route, we need to find the real parent route
-    if (parentRoute?.isVirtualParentRoute && parentRoute.children?.length) {
-      // only if this sub-parent route returns a valid parent route, we use it, if not leave it as it
-      const possibleParentRoute = hasParentRoute(
-        parentRoute.children,
-        node,
-        node.routePath,
+      const routeImports = sortedRouteNodes
+        .filter((d) => !d.isVirtual)
+        .flatMap((node) => getImportForRouteNode(node, exportName) ?? [])
+
+      const hasMatchingRouteFiles =
+        acc.routeNodes.length > 0 || rootRouteNode.exports?.includes(exportName)
+
+      const virtualRouteNodes = sortedRouteNodes
+        .filter((d) => d.isVirtual)
+        .map((node) => {
+          return `const ${
+            node.variableName
+          }${exportName}Import = ${plugin.createVirtualRouteCode({ node })}`
+        })
+      if (
+        !rootRouteNode.exports?.includes(exportName) &&
+        pluginConfig.virtualRootRoute
+      ) {
+        virtualRouteNodes.unshift(
+          `const ${rootRouteNode.variableName}${exportName}Import = ${plugin.createRootRouteCode()}`,
+        )
+      }
+
+      const imports = plugin.imports({
+        sortedRouteNodes,
+        acc,
+        generator: this,
+        rootRouteNode,
+      })
+
+      const routeTreeConfig = buildRouteTreeConfig(
+        acc.routeTree,
+        exportName,
+        this.config.disableTypes,
       )
-      if (possibleParentRoute) {
-        parentRoute = possibleParentRoute
+
+      const createUpdateRoutes = sortedRouteNodes.map((node) => {
+        const loaderNode = acc.routePiecesByPath[node.routePath!]?.loader
+        const componentNode = acc.routePiecesByPath[node.routePath!]?.component
+        const errorComponentNode =
+          acc.routePiecesByPath[node.routePath!]?.errorComponent
+        const pendingComponentNode =
+          acc.routePiecesByPath[node.routePath!]?.pendingComponent
+        const lazyComponentNode = acc.routePiecesByPath[node.routePath!]?.lazy
+
+        return [
+          [
+            `const ${node.variableName}${exportName} = ${node.variableName}${exportName}Import.update({
+            ${[
+              `id: '${node.path}'`,
+              !node.isNonPath ? `path: '${node.cleanedPath}'` : undefined,
+              `getParentRoute: () => ${findParent(node, exportName)}`,
+            ]
+              .filter(Boolean)
+              .join(',')}
+          }${this.config.disableTypes ? '' : 'as any'})`,
+            loaderNode
+              ? `.updateLoader({ loader: lazyFn(() => import('./${replaceBackslash(
+                  removeExt(
+                    path.relative(
+                      path.dirname(this.config.generatedRouteTree),
+                      path.resolve(
+                        this.config.routesDirectory,
+                        loaderNode.filePath,
+                      ),
+                    ),
+                    this.config.addExtensions,
+                  ),
+                )}'), 'loader') })`
+              : '',
+            componentNode || errorComponentNode || pendingComponentNode
+              ? `.update({
+                ${(
+                  [
+                    ['component', componentNode],
+                    ['errorComponent', errorComponentNode],
+                    ['pendingComponent', pendingComponentNode],
+                  ] as const
+                )
+                  .filter((d) => d[1])
+                  .map((d) => {
+                    return `${
+                      d[0]
+                    }: lazyRouteComponent(() => import('./${replaceBackslash(
+                      removeExt(
+                        path.relative(
+                          path.dirname(this.config.generatedRouteTree),
+                          path.resolve(
+                            this.config.routesDirectory,
+                            d[1]!.filePath,
+                          ),
+                        ),
+                        this.config.addExtensions,
+                      ),
+                    )}'), '${d[0]}')`
+                  })
+                  .join('\n,')}
+              })`
+              : '',
+            lazyComponentNode
+              ? `.lazy(() => import('./${replaceBackslash(
+                  removeExt(
+                    path.relative(
+                      path.dirname(this.config.generatedRouteTree),
+                      path.resolve(
+                        this.config.routesDirectory,
+                        lazyComponentNode.filePath,
+                      ),
+                    ),
+                    this.config.addExtensions,
+                  ),
+                )}').then((d) => d.${exportName}))`
+              : '',
+          ].join(''),
+        ].join('\n\n')
+      })
+
+      let fileRoutesByPathInterfacePerPlugin = ''
+      let fileRoutesByFullPathPerPlugin = ''
+
+      if (!this.config.disableTypes && hasMatchingRouteFiles) {
+        fileRoutesByFullPathPerPlugin = [
+          `export interface File${exportName}sByFullPath {
+${[...createRouteNodesByFullPath(acc.routeNodes).entries()].map(
+  ([fullPath, routeNode]) => {
+    return `'${fullPath}': typeof ${getResolvedRouteNodeVariableName(routeNode, exportName)}`
+  },
+)}
+}`,
+          `export interface File${exportName}sByTo {
+${[...createRouteNodesByTo(acc.routeNodes).entries()].map(([to, routeNode]) => {
+  return `'${to}': typeof ${getResolvedRouteNodeVariableName(routeNode, exportName)}`
+})}
+}`,
+          `export interface File${exportName}sById {
+'${rootRouteId}': typeof root${exportName}Import,
+${[...createRouteNodesById(acc.routeNodes).entries()].map(([id, routeNode]) => {
+  return `'${id}': typeof ${getResolvedRouteNodeVariableName(routeNode, exportName)}`
+})}
+}`,
+          `export interface File${exportName}Types {
+file${exportName}sByFullPath: File${exportName}sByFullPath
+fullPaths: ${acc.routeNodes.length > 0 ? [...createRouteNodesByFullPath(acc.routeNodes).keys()].map((fullPath) => `'${fullPath}'`).join('|') : 'never'}
+file${exportName}sByTo: File${exportName}sByTo
+to: ${acc.routeNodes.length > 0 ? [...createRouteNodesByTo(acc.routeNodes).keys()].map((to) => `'${to}'`).join('|') : 'never'}
+id: ${[`'${rootRouteId}'`, ...[...createRouteNodesById(acc.routeNodes).keys()].map((id) => `'${id}'`)].join('|')}
+file${exportName}sById: File${exportName}sById
+}`,
+          `export interface Root${exportName}Children {
+${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${getResolvedRouteNodeVariableName(child, exportName)}`).join(',')}
+}`,
+        ].join('\n')
+
+        fileRoutesByPathInterfacePerPlugin = buildFileRoutesByPathInterface({
+          ...plugin.moduleAugmentation({ generator: this }),
+          routeNodes: preRouteNodes,
+          exportName,
+        })
+      }
+
+      let routeTree = ''
+      if (hasMatchingRouteFiles) {
+        routeTree = [
+          `const root${exportName}Children${this.config.disableTypes ? '' : `: Root${exportName}Children`} = {
+  ${acc.routeTree
+    .map(
+      (child) =>
+        `${child.variableName}${exportName}: ${getResolvedRouteNodeVariableName(child, exportName)}`,
+    )
+    .join(',')}
+}`,
+          `export const ${lowerCaseFirstChar(exportName)}Tree = root${exportName}Import._addFileChildren(root${exportName}Children)${this.config.disableTypes ? '' : `._addFileTypes<File${exportName}Types>()`}`,
+        ].join('\n')
+      }
+
+      return {
+        routeImports,
+        sortedRouteNodes,
+        acc,
+        virtualRouteNodes,
+        routeTreeConfig,
+        routeTree,
+        imports,
+        createUpdateRoutes,
+        fileRoutesByFullPathPerPlugin,
+        fileRoutesByPathInterfacePerPlugin,
       }
     }
 
-    if (parentRoute) node.parent = parentRoute
+    const routeTrees = this.pluginsWithTransform.map((plugin) => ({
+      exportName: plugin.transformPlugin.exportName,
+      ...buildRouteTreeForExport(plugin),
+    }))
 
-    node.path = determineNodePath(node)
+    this.plugins.map((plugin) => {
+      return plugin.onRouteTreesChanged?.({
+        routeTrees,
+        rootRouteNode,
+        generator: this,
+      })
+    })
 
-    const trimmedPath = trimPathLeft(node.path ?? '')
+    let mergedImports = mergeImportDeclarations(
+      routeTrees.flatMap((d) => d.imports),
+    )
+    if (this.config.disableTypes) {
+      mergedImports = mergedImports.filter((d) => d.importKind !== 'type')
+    }
 
-    const split = trimmedPath.split('/')
-    const lastRouteSegment = split[split.length - 1] ?? trimmedPath
+    const importStatements = mergedImports.map(buildImportString)
+
+    let moduleAugmentation = ''
+    if (this.config.verboseFileRoutes === false && !this.config.disableTypes) {
+      moduleAugmentation = routeFileResult
+        .map(({ node }) => {
+          const getModuleDeclaration = (routeNode?: RouteNode) => {
+            if (!isRouteNodeValidForAugmentation(routeNode)) {
+              return ''
+            }
+            const moduleAugmentation = this.pluginsWithTransform
+              .map((plugin) => {
+                return plugin.routeModuleAugmentation({
+                  routeNode,
+                })
+              })
+              .filter(Boolean)
+              .join('\n')
 
-    node.isNonPath =
-      lastRouteSegment.startsWith('_') ||
-      routeGroupPatternRegex.test(lastRouteSegment)
+            return `declare module './${this.getImportPath(routeNode)}' {
+                      ${moduleAugmentation}
+                    }`
+          }
+          return getModuleDeclaration(node)
+        })
+        .join('\n')
+    }
 
-    node.cleanedPath = removeGroups(
-      removeUnderscores(removeLayoutSegments(node.path)) ?? '',
+    const routeImports = routeTrees.flatMap((t) => t.routeImports)
+    const rootRouteImports = this.pluginsWithTransform.flatMap(
+      (p) =>
+        getImportForRouteNode(rootRouteNode, p.transformPlugin.exportName) ??
+        [],
     )
+    if (rootRouteImports.length > 0) {
+      routeImports.unshift(...rootRouteImports)
+    }
+    const routeTreeContent = [
+      ...this.config.routeTreeFileHeader,
+      `// This file was automatically generated by TanStack Router.
+// You should NOT make any changes in this file as it will be overwritten.
+// Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.`,
+      [...importStatements].join('\n'),
+      mergeImportDeclarations(routeImports).map(buildImportString).join('\n'),
+      routeTrees.flatMap((t) => t.virtualRouteNodes).join('\n'),
+      routeTrees.flatMap((t) => t.createUpdateRoutes).join('\n'),
+
+      routeTrees.map((t) => t.fileRoutesByFullPathPerPlugin).join('\n'),
+      routeTrees.map((t) => t.fileRoutesByPathInterfacePerPlugin).join('\n'),
+      moduleAugmentation,
+      routeTrees.flatMap((t) => t.routeTreeConfig).join('\n'),
+      routeTrees.map((t) => t.routeTree).join('\n'),
+      ...this.config.routeTreeFileFooter,
+    ]
+      .filter(Boolean)
+      .join('\n\n')
+    return routeTreeContent
+  }
 
-    // Ensure the boilerplate for the route exists, which can be skipped for virtual parent routes and virtual routes
-    if (!node.isVirtualParentRoute && !node.isVirtual) {
-      const routeCode = fs.readFileSync(node.fullPath, 'utf-8')
+  private getImportPath(node: RouteNode) {
+    return replaceBackslash(
+      removeExt(
+        path.relative(
+          path.dirname(this.config.generatedRouteTree),
+          path.resolve(this.config.routesDirectory, node.filePath),
+        ),
+        this.config.addExtensions,
+      ),
+    )
+  }
 
-      const escapedRoutePath = node.routePath?.replaceAll('$', '$$') ?? ''
+  private async processRouteNodeFile(node: RouteNode): Promise<{
+    shouldWriteTree: boolean
+    cacheEntry: RouteNodeCacheEntry
+    node: RouteNode
+  } | null> {
+    const result = await this.isRouteFileCacheFresh(node)
 
-      let replaced = routeCode
+    if (result.status === 'fresh') {
+      node.exports = result.cacheEntry.exports
+      return {
+        node,
+        shouldWriteTree: result.exportsChanged,
+        cacheEntry: result.cacheEntry,
+      }
+    }
 
-      const tRouteTemplate = ROUTE_TEMPLATE.route
-      const tLazyRouteTemplate = ROUTE_TEMPLATE.lazyRoute
+    const existingRouteFile = await this.fs.readFile(node.fullPath)
+    if (existingRouteFile === 'file-not-existing') {
+      throw new Error(`⚠️ File ${node.fullPath} does not exist`)
+    }
 
-      if (!routeCode) {
-        // Creating a new lazy route file
-        if (node._fsRouteType === 'lazy') {
-          // Check by default check if the user has a specific lazy route template
-          // If not, check if the user has a route template and use that instead
-          replaced = await fillTemplate(
-            config,
-            (config.customScaffolding?.lazyRouteTemplate ||
-              config.customScaffolding?.routeTemplate) ??
-              tLazyRouteTemplate.template(),
-            {
-              tsrImports: tLazyRouteTemplate.imports.tsrImports(),
-              tsrPath: escapedRoutePath.replaceAll(/\{(.+)\}/gm, '$1'),
-              tsrExportStart:
-                tLazyRouteTemplate.imports.tsrExportStart(escapedRoutePath),
-              tsrExportEnd: tLazyRouteTemplate.imports.tsrExportEnd(),
-            },
-          )
-        } else if (
-          // Creating a new normal route file
-          (['layout', 'static'] satisfies Array<FsRouteType>).some(
-            (d) => d === node._fsRouteType,
-          ) ||
-          (
-            [
-              'component',
-              'pendingComponent',
-              'errorComponent',
-              'loader',
-            ] satisfies Array<FsRouteType>
-          ).every((d) => d !== node._fsRouteType)
-        ) {
-          replaced = await fillTemplate(
-            config,
-            config.customScaffolding?.routeTemplate ??
-              tRouteTemplate.template(),
-            {
-              tsrImports: tRouteTemplate.imports.tsrImports(),
-              tsrPath: escapedRoutePath.replaceAll(/\{(.+)\}/gm, '$1'),
-              tsrExportStart:
-                tRouteTemplate.imports.tsrExportStart(escapedRoutePath),
-              tsrExportEnd: tRouteTemplate.imports.tsrExportEnd(),
-            },
-          )
-        }
-      } else if (config.verboseFileRoutes === false) {
-        // Check if the route file has a Route export
-        if (
-          !routeCode
-            .split('\n')
-            .some((line) => line.trim().startsWith('export const Route'))
-        ) {
-          return
-        }
+    const updatedCacheEntry: RouteNodeCacheEntry = {
+      fileContent: existingRouteFile.fileContent,
+      mtimeMs: existingRouteFile.stat.mtimeMs,
+      exports: [],
+    }
 
-        // Update the existing route file
-        replaced = routeCode
-          .replace(
-            /(FileRoute\(\s*['"])([^\s]*)(['"],?\s*\))/g,
-            (_, p1, __, p3) => `${p1}${escapedRoutePath}${p3}`,
-          )
-          .replace(
-            new RegExp(
-              `(import\\s*\\{)(.*)(create(Lazy)?FileRoute)(.*)(\\}\\s*from\\s*['"]@tanstack\\/${ROUTE_TEMPLATE.subPkg}['"])`,
-              'gs',
-            ),
-            (_, p1, p2, ___, ____, p5, p6) => {
-              const beforeCreateFileRoute = () => {
-                if (!p2) return ''
-
-                let trimmed = p2.trim()
-
-                if (trimmed.endsWith(',')) {
-                  trimmed = trimmed.slice(0, -1)
-                }
+    const escapedRoutePath = node.routePath?.replaceAll('$', '$$') ?? ''
+
+    let shouldWriteRouteFile = false
+    // now we need to either scaffold the file or transform it
+    if (!existingRouteFile.fileContent) {
+      shouldWriteRouteFile = true
+      // Creating a new lazy route file
+      if (node._fsRouteType === 'lazy') {
+        const tLazyRouteTemplate = this.targetTemplate.lazyRoute
+        // Check by default check if the user has a specific lazy route template
+        // If not, check if the user has a route template and use that instead
+        updatedCacheEntry.fileContent = await fillTemplate(
+          this.config,
+          (this.config.customScaffolding?.lazyRouteTemplate ||
+            this.config.customScaffolding?.routeTemplate) ??
+            tLazyRouteTemplate.template(),
+          {
+            tsrImports: tLazyRouteTemplate.imports.tsrImports(),
+            tsrPath: escapedRoutePath.replaceAll(/\{(.+)\}/gm, '$1'),
+            tsrExportStart:
+              tLazyRouteTemplate.imports.tsrExportStart(escapedRoutePath),
+            tsrExportEnd: tLazyRouteTemplate.imports.tsrExportEnd(),
+          },
+        )
+        updatedCacheEntry.exports = ['Route']
+      } else if (
+        // Creating a new normal route file
+        (['layout', 'static'] satisfies Array<FsRouteType>).some(
+          (d) => d === node._fsRouteType,
+        ) ||
+        (
+          [
+            'component',
+            'pendingComponent',
+            'errorComponent',
+            'loader',
+          ] satisfies Array<FsRouteType>
+        ).every((d) => d !== node._fsRouteType)
+      ) {
+        const tRouteTemplate = this.targetTemplate.route
+        updatedCacheEntry.fileContent = await fillTemplate(
+          this.config,
+          this.config.customScaffolding?.routeTemplate ??
+            tRouteTemplate.template(),
+          {
+            tsrImports: tRouteTemplate.imports.tsrImports(),
+            tsrPath: escapedRoutePath.replaceAll(/\{(.+)\}/gm, '$1'),
+            tsrExportStart:
+              tRouteTemplate.imports.tsrExportStart(escapedRoutePath),
+            tsrExportEnd: tRouteTemplate.imports.tsrExportEnd(),
+          },
+        )
+        updatedCacheEntry.exports = ['Route']
+      } else {
+        return null
+      }
+    } else {
+      // transform the file
+      const transformResult = await transform({
+        source: updatedCacheEntry.fileContent,
+        ctx: {
+          target: this.config.target,
+          routeId: escapedRoutePath,
+          lazy: node._fsRouteType === 'lazy',
+          verboseFileRoutes: !(this.config.verboseFileRoutes === false),
+        },
+        plugins: this.transformPlugins,
+      })
 
-                return trimmed
-              }
+      if (transformResult.result === 'error') {
+        throw new Error(
+          `Error transforming route file ${node.fullPath}: ${transformResult.error}`,
+        )
+      }
+      updatedCacheEntry.exports = transformResult.exports
+      if (transformResult.result === 'modified') {
+        updatedCacheEntry.fileContent = transformResult.output
+        shouldWriteRouteFile = true
+      }
+    }
 
-              const afterCreateFileRoute = () => {
-                if (!p5) return ''
+    // file was changed
+    if (shouldWriteRouteFile) {
+      const stats = await this.safeFileWrite({
+        filePath: node.fullPath,
+        newContent: updatedCacheEntry.fileContent,
+        strategy: {
+          type: 'mtime',
+          expectedMtimeMs: updatedCacheEntry.mtimeMs,
+        },
+      })
+      updatedCacheEntry.mtimeMs = stats.mtimeMs
+    }
 
-                let trimmed = p5.trim()
+    this.routeNodeShadowCache.set(node.fullPath, updatedCacheEntry)
+    node.exports = updatedCacheEntry.exports
+    const shouldWriteTree = !deepEqual(
+      result.cacheEntry?.exports,
+      updatedCacheEntry.exports,
+    )
+    return {
+      node,
+      shouldWriteTree,
+      cacheEntry: updatedCacheEntry,
+    }
+  }
 
-                if (trimmed.startsWith(',')) {
-                  trimmed = trimmed.slice(1)
-                }
+  private async didRouteFileChangeComparedToCache(
+    file: {
+      path: string
+      mtimeMs?: bigint
+    },
+    cache: 'routeNodeCache' | 'routeNodeShadowCache',
+  ): Promise<FileCacheChange<RouteNodeCacheEntry>> {
+    const cacheEntry = this[cache].get(file.path)
+    return this.didFileChangeComparedToCache(file, cacheEntry)
+  }
 
-                return trimmed
-              }
+  private async didFileChangeComparedToCache<
+    TCacheEntry extends GeneratorCacheEntry,
+  >(
+    file: {
+      path: string
+      mtimeMs?: bigint
+    },
+    cacheEntry: TCacheEntry | undefined,
+  ): Promise<FileCacheChange<TCacheEntry>> {
+    // for now we rely on the modification time of the file
+    // to determine if the file has changed
+    // we could also compare the file content but this would be slower as we would have to read the file
+
+    if (!cacheEntry) {
+      return { result: 'file-not-in-cache' }
+    }
+    let mtimeMs = file.mtimeMs
+
+    if (mtimeMs === undefined) {
+      try {
+        const currentStat = await this.fs.stat(file.path)
+        mtimeMs = currentStat.mtimeMs
+      } catch {
+        return { result: 'cannot-stat-file' }
+      }
+    }
+    return { result: mtimeMs !== cacheEntry.mtimeMs, mtimeMs, cacheEntry }
+  }
 
-              const newImport = () => {
-                const before = beforeCreateFileRoute()
-                const after = afterCreateFileRoute()
+  private async safeFileWrite(opts: {
+    filePath: string
+    newContent: string
+    strategy:
+      | {
+          type: 'mtime'
+          expectedMtimeMs: bigint
+        }
+      | {
+          type: 'new-file'
+        }
+  }) {
+    const tmpPath = this.getTempFileName(opts.filePath)
+    await this.fs.writeFile(tmpPath, opts.newContent)
+
+    if (opts.strategy.type === 'mtime') {
+      const beforeStat = await this.fs.stat(opts.filePath)
+      if (beforeStat.mtimeMs !== opts.strategy.expectedMtimeMs) {
+        throw rerun({
+          msg: `File ${opts.filePath} was modified by another process during processing.`,
+          event: { type: 'update', path: opts.filePath },
+        })
+      }
+    } else {
+      if (await checkFileExists(opts.filePath)) {
+        throw rerun({
+          msg: `File ${opts.filePath} already exists. Cannot overwrite.`,
+          event: { type: 'update', path: opts.filePath },
+        })
+      }
+    }
 
-                if (!before) return after
+    const stat = await this.fs.stat(tmpPath)
 
-                if (!after) return before
+    await this.fs.rename(tmpPath, opts.filePath)
 
-                return `${before},${after}`
-              }
+    return stat
+  }
 
-              const middle = newImport()
+  private getTempFileName(filePath: string) {
+    const absPath = path.resolve(filePath)
+    const hash = crypto.createHash('md5').update(absPath).digest('hex')
+    return path.join(this.tmpDir, hash)
+  }
 
-              if (middle === '') return ''
+  private async isRouteFileCacheFresh(node: RouteNode): Promise<
+    | {
+        status: 'fresh'
+        cacheEntry: RouteNodeCacheEntry
+        exportsChanged: boolean
+      }
+    | { status: 'stale'; cacheEntry?: RouteNodeCacheEntry }
+  > {
+    const fileChangedCache = await this.didRouteFileChangeComparedToCache(
+      { path: node.fullPath },
+      'routeNodeCache',
+    )
+    if (fileChangedCache.result === false) {
+      this.routeNodeShadowCache.set(node.fullPath, fileChangedCache.cacheEntry)
+      return {
+        status: 'fresh',
+        exportsChanged: false,
+        cacheEntry: fileChangedCache.cacheEntry,
+      }
+    }
+    if (fileChangedCache.result === 'cannot-stat-file') {
+      throw new Error(`⚠️ expected route file to exist at ${node.fullPath}`)
+    }
+    const mtimeMs =
+      fileChangedCache.result === true ? fileChangedCache.mtimeMs : undefined
 
-              return `${p1} ${newImport()} ${p6}`
-            },
-          )
-          .replace(
-            /create(Lazy)?FileRoute(\(\s*['"])([^\s]*)(['"],?\s*\))/g,
-            (_, __, p2, ___, p4) =>
-              `${node._fsRouteType === 'lazy' ? 'createLazyFileRoute' : 'createFileRoute'}`,
-          )
-      } else {
-        // Check if the route file has a Route export
+    const shadowCacheFileChange = await this.didRouteFileChangeComparedToCache(
+      { path: node.fullPath, mtimeMs },
+      'routeNodeShadowCache',
+    )
+
+    if (shadowCacheFileChange.result === 'cannot-stat-file') {
+      throw new Error(`⚠️ expected route file to exist at ${node.fullPath}`)
+    }
+
+    if (shadowCacheFileChange.result === false) {
+      // shadow cache has latest file state already
+      // compare shadowCache against cache to determine whether exports changed
+      // if they didn't, cache is fresh
+      if (fileChangedCache.result === true) {
         if (
-          !routeCode
-            .split('\n')
-            .some((line) => line.trim().startsWith('export const Route'))
+          deepEqual(
+            fileChangedCache.cacheEntry.exports,
+            shadowCacheFileChange.cacheEntry.exports,
+          )
         ) {
-          return
+          return {
+            status: 'fresh',
+            exportsChanged: false,
+            cacheEntry: shadowCacheFileChange.cacheEntry,
+          }
         }
-
-        // Update the existing route file
-        replaced = routeCode
-          // fix wrong ids
-          .replace(
-            /(FileRoute\(\s*['"])([^\s]*)(['"],?\s*\))/g,
-            (_, p1, __, p3) => `${p1}${escapedRoutePath}${p3}`,
-          )
-          // fix missing ids
-          .replace(
-            /((FileRoute)(\s*)(\({))/g,
-            (_, __, p2, p3, p4) => `${p2}('${escapedRoutePath}')${p3}${p4}`,
-          )
-          .replace(
-            new RegExp(
-              `(import\\s*\\{.*)(create(Lazy)?FileRoute)(.*\\}\\s*from\\s*['"]@tanstack\\/${ROUTE_TEMPLATE.subPkg}['"])`,
-              'gs',
-            ),
-            (_, p1, __, ___, p4) =>
-              `${p1}${node._fsRouteType === 'lazy' ? 'createLazyFileRoute' : 'createFileRoute'}${p4}`,
-          )
-          .replace(
-            /create(Lazy)?FileRoute(\(\s*['"])([^\s]*)(['"],?\s*\))/g,
-            (_, __, p2, ___, p4) =>
-              `${node._fsRouteType === 'lazy' ? 'createLazyFileRoute' : 'createFileRoute'}${p2}${escapedRoutePath}${p4}`,
-          )
-
-        // check whether the import statement is already present
-        const regex = new RegExp(
-          `(import\\s*\\{.*)(create(Lazy)?FileRoute)(.*\\}\\s*from\\s*['"]@tanstack\\/${ROUTE_TEMPLATE.subPkg}['"])`,
-          'gm',
-        )
-        if (!replaced.match(regex)) {
-          replaced = [
-            `import { ${node._fsRouteType === 'lazy' ? 'createLazyFileRoute' : 'createFileRoute'} } from '@tanstack/${ROUTE_TEMPLATE.subPkg}'`,
-            ...replaced.split('\n'),
-          ].join('\n')
+        return {
+          status: 'fresh',
+          exportsChanged: true,
+          cacheEntry: shadowCacheFileChange.cacheEntry,
         }
       }
+    }
+
+    if (fileChangedCache.result === 'file-not-in-cache') {
+      return {
+        status: 'stale',
+      }
+    }
+    return { status: 'stale', cacheEntry: fileChangedCache.cacheEntry }
+  }
+
+  private async handleRootNode(node: RouteNode) {
+    const result = await this.isRouteFileCacheFresh(node)
+
+    if (result.status === 'fresh') {
+      node.exports = result.cacheEntry.exports
+      this.routeNodeShadowCache.set(node.fullPath, result.cacheEntry)
+      return result.exportsChanged
+    }
+    const rootNodeFile = await this.fs.readFile(node.fullPath)
+    if (rootNodeFile === 'file-not-existing') {
+      throw new Error(`⚠️ expected root route to exist at ${node.fullPath}`)
+    }
 
-      await writeIfDifferent(node.fullPath, routeCode, replaced, {
-        beforeWrite: () => {
-          logger.log(`🟡 Updating ${node.fullPath}`)
+    const updatedCacheEntry: RouteNodeCacheEntry = {
+      fileContent: rootNodeFile.fileContent,
+      mtimeMs: rootNodeFile.stat.mtimeMs,
+      exports: [],
+    }
+
+    // scaffold the root route
+    if (!rootNodeFile.fileContent) {
+      const rootTemplate = this.targetTemplate.rootRoute
+      const rootRouteContent = await fillTemplate(
+        this.config,
+        rootTemplate.template(),
+        {
+          tsrImports: rootTemplate.imports.tsrImports(),
+          tsrPath: rootPathId,
+          tsrExportStart: rootTemplate.imports.tsrExportStart(),
+          tsrExportEnd: rootTemplate.imports.tsrExportEnd(),
+        },
+      )
+
+      this.logger.log(`🟡 Creating ${node.fullPath}`)
+      const stats = await this.safeFileWrite({
+        filePath: node.fullPath,
+        newContent: rootRouteContent,
+        strategy: {
+          type: 'mtime',
+          expectedMtimeMs: rootNodeFile.stat.mtimeMs,
         },
       })
+      updatedCacheEntry.fileContent = rootRouteContent
+      updatedCacheEntry.mtimeMs = stats.mtimeMs
+    }
+
+    const rootRouteExports: Array<string> = []
+    for (const plugin of this.pluginsWithTransform) {
+      const exportName = plugin.transformPlugin.exportName
+      if (rootNodeFile.fileContent.includes(`export const ${exportName}`)) {
+        rootRouteExports.push(exportName)
+      }
+    }
+
+    updatedCacheEntry.exports = rootRouteExports
+    node.exports = rootRouteExports
+    this.routeNodeShadowCache.set(node.fullPath, updatedCacheEntry)
+
+    const shouldWriteTree = !deepEqual(
+      result.cacheEntry?.exports,
+      rootRouteExports,
+    )
+    return shouldWriteTree
+  }
+
+  private handleNode(node: RouteNode, acc: HandleNodeAccumulator) {
+    // Do not remove this as we need to set the lastIndex to 0 as it
+    // is necessary to reset the regex's index when using the global flag
+    // otherwise it might not match the next time it's used
+    resetRegex(this.routeGroupPatternRegex)
+
+    let parentRoute = hasParentRoute(acc.routeNodes, node, node.routePath)
+
+    // if the parent route is a virtual parent route, we need to find the real parent route
+    if (parentRoute?.isVirtualParentRoute && parentRoute.children?.length) {
+      // only if this sub-parent route returns a valid parent route, we use it, if not leave it as it
+      const possibleParentRoute = hasParentRoute(
+        parentRoute.children,
+        node,
+        node.routePath,
+      )
+      if (possibleParentRoute) {
+        parentRoute = possibleParentRoute
+      }
     }
 
+    if (parentRoute) node.parent = parentRoute
+
+    node.path = determineNodePath(node)
+
+    const trimmedPath = trimPathLeft(node.path ?? '')
+
+    const split = trimmedPath.split('/')
+    const lastRouteSegment = split[split.length - 1] ?? trimmedPath
+
+    node.isNonPath =
+      lastRouteSegment.startsWith('_') ||
+      this.routeGroupPatternRegex.test(lastRouteSegment)
+
+    node.cleanedPath = removeGroups(
+      removeUnderscores(removeLayoutSegments(node.path)) ?? '',
+    )
+
     if (
       !node.isVirtual &&
       (
@@ -377,10 +1161,10 @@ export async function generator(config: Config, root: string) {
         ] satisfies Array<FsRouteType>
       ).some((d) => d === node._fsRouteType)
     ) {
-      routePiecesByPath[node.routePath!] =
-        routePiecesByPath[node.routePath!] || {}
+      acc.routePiecesByPath[node.routePath!] =
+        acc.routePiecesByPath[node.routePath!] || {}
 
-      routePiecesByPath[node.routePath!]![
+      acc.routePiecesByPath[node.routePath!]![
         node._fsRouteType === 'lazy'
           ? 'lazy'
           : node._fsRouteType === 'loader'
@@ -392,14 +1176,19 @@ export async function generator(config: Config, root: string) {
                 : 'component'
       ] = node
 
-      const anchorRoute = routeNodes.find((d) => d.routePath === node.routePath)
+      const anchorRoute = acc.routeNodes.find(
+        (d) => d.routePath === node.routePath,
+      )
 
       if (!anchorRoute) {
-        await handleNode({
-          ...node,
-          isVirtual: true,
-          _fsRouteType: 'static',
-        })
+        this.handleNode(
+          {
+            ...node,
+            isVirtual: true,
+            _fsRouteType: 'static',
+          },
+          acc,
+        )
       }
       return
     }
@@ -417,7 +1206,7 @@ export async function generator(config: Config, root: string) {
       const parentRoutePath = removeLastSegmentFromPath(node.routePath) || '/'
       const parentVariableName = routePathToVariable(parentRoutePath)
 
-      const anchorRoute = routeNodes.find(
+      const anchorRoute = acc.routeNodes.find(
         (d) => d.routePath === parentRoutePath,
       )
 
@@ -445,7 +1234,7 @@ export async function generator(config: Config, root: string) {
           node.path = determineNodePath(node)
         }
 
-        await handleNode(parentNode)
+        this.handleNode(parentNode, acc)
       } else {
         anchorRoute.children = anchorRoute.children ?? []
         anchorRoute.children.push(node)
@@ -460,658 +1249,43 @@ export async function generator(config: Config, root: string) {
         node.parent.children.push(node)
       }
     } else {
-      routeTree.push(node)
+      acc.routeTree.push(node)
     }
 
-    routeNodes.push(node)
-  }
-
-  for (const node of preRouteNodes) {
-    await handleNode(node)
+    acc.routeNodes.push(node)
   }
+}
 
-  // This is run against the `preRouteNodes` array since it
-  // has the flattened Route nodes and not the full tree
-  // Since TSR allows multiple way of defining a route,
-  // we need to ensure that a user hasn't defined the
-  // same route in multiple ways (i.e. `flat`, `nested`, `virtual`)
-  checkRouteFullPathUniqueness(
-    preRouteNodes.filter(
-      (d) => d.children === undefined && 'lazy' !== d._fsRouteType,
-    ),
-    config,
-  )
-
-  function buildRouteTreeConfig(nodes: Array<RouteNode>, depth = 1): string {
-    const children = nodes.map((node) => {
-      if (node._fsRouteType === '__root') {
-        return
-      }
-
-      if (node._fsRouteType === 'pathless_layout' && !node.children?.length) {
-        return
-      }
-
-      const route = `${node.variableName}Route`
-
-      if (node.children?.length) {
-        const childConfigs = buildRouteTreeConfig(node.children, depth + 1)
-
-        const childrenDeclaration = TYPES_DISABLED
-          ? ''
-          : `interface ${route}Children {
-  ${node.children.map((child) => `${child.variableName}Route: typeof ${getResolvedRouteNodeVariableName(child)}`).join(',')}
-}`
-
-        const children = `const ${route}Children${TYPES_DISABLED ? '' : `: ${route}Children`} = {
-  ${node.children.map((child) => `${child.variableName}Route: ${getResolvedRouteNodeVariableName(child)}`).join(',')}
-}`
-
-        const routeWithChildren = `const ${route}WithChildren = ${route}._addFileChildren(${route}Children)`
-
-        return [
-          childConfigs,
-          childrenDeclaration,
-          children,
-          routeWithChildren,
-        ].join('\n\n')
-      }
-
-      return undefined
-    })
-
-    return children.filter(Boolean).join('\n\n')
-  }
-
-  const routeConfigChildrenText = buildRouteTreeConfig(routeTree)
-
-  const sortedRouteNodes = multiSortBy(routeNodes, [
-    (d) => (d.routePath?.includes(`/${rootPathId}`) ? -1 : 1),
-    (d) => d.routePath?.split('/').length,
-    (d) => (d.routePath?.endsWith(config.indexToken) ? -1 : 1),
-    (d) => d,
-  ])
-
-  const typeImports = Object.entries({
-    // Used for augmentation of regular routes
-    CreateFileRoute:
-      config.verboseFileRoutes === false &&
-      sortedRouteNodes.some(
-        (d) => isRouteNodeValidForAugmentation(d) && d._fsRouteType !== 'lazy',
-      ),
-    // Used for augmentation of lazy (`.lazy`) routes
-    CreateLazyFileRoute:
-      config.verboseFileRoutes === false &&
-      sortedRouteNodes.some(
-        (node) =>
-          routePiecesByPath[node.routePath!]?.lazy &&
-          isRouteNodeValidForAugmentation(node),
-      ),
-    // Used in the process of augmenting the routes
-    FileRoutesByPath:
-      config.verboseFileRoutes === false &&
-      sortedRouteNodes.some((d) => isRouteNodeValidForAugmentation(d)),
-  })
-    .filter((d) => d[1])
-    .map((d) => d[0])
-    .sort((a, b) => a.localeCompare(b))
-
-  const imports = Object.entries({
-    createFileRoute: sortedRouteNodes.some((d) => d.isVirtual),
-    lazyFn: sortedRouteNodes.some(
-      (node) => routePiecesByPath[node.routePath!]?.loader,
-    ),
-    lazyRouteComponent: sortedRouteNodes.some(
-      (node) =>
-        routePiecesByPath[node.routePath!]?.component ||
-        routePiecesByPath[node.routePath!]?.errorComponent ||
-        routePiecesByPath[node.routePath!]?.pendingComponent,
-    ),
-  })
-    .filter((d) => d[1])
-    .map((d) => d[0])
-
-  const virtualRouteNodes = sortedRouteNodes.filter((d) => d.isVirtual)
-
-  function getImportPath(node: RouteNode) {
-    return replaceBackslash(
-      removeExt(
-        path.relative(
-          path.dirname(config.generatedRouteTree),
-          path.resolve(config.routesDirectory, node.filePath),
-        ),
-        config.addExtensions,
-      ),
-    )
-  }
-
-  const routeImports = [
-    ...config.routeTreeFileHeader,
-    `// This file was automatically generated by TanStack Router.
-// You should NOT make any changes in this file as it will be overwritten.
-// Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.`,
-    [
-      imports.length
-        ? `import { ${imports.join(', ')} } from '${ROUTE_TEMPLATE.fullPkg}'`
-        : '',
-      !TYPES_DISABLED && typeImports.length
-        ? `import type { ${typeImports.join(', ')} } from '${ROUTE_TEMPLATE.fullPkg}'`
-        : '',
-    ]
-      .filter(Boolean)
-      .join('\n'),
-    '// Import Routes',
-    [
-      `import { Route as rootRoute } from './${getImportPath(rootRouteNode)}'`,
-      ...sortedRouteNodes
-        .filter((d) => !d.isVirtual)
-        .map((node) => {
-          return `import { Route as ${
-            node.variableName
-          }RouteImport } from './${getImportPath(node)}'`
-        }),
-    ].join('\n'),
-    virtualRouteNodes.length ? '// Create Virtual Routes' : '',
-    virtualRouteNodes
-      .map((node) => {
-        return `const ${
-          node.variableName
-        }RouteImport = createFileRoute('${node.routePath}')()`
-      })
-      .join('\n'),
-    '// Create/Update Routes',
-    sortedRouteNodes
-      .map((node) => {
-        const loaderNode = routePiecesByPath[node.routePath!]?.loader
-        const componentNode = routePiecesByPath[node.routePath!]?.component
-        const errorComponentNode =
-          routePiecesByPath[node.routePath!]?.errorComponent
-        const pendingComponentNode =
-          routePiecesByPath[node.routePath!]?.pendingComponent
-        const lazyComponentNode = routePiecesByPath[node.routePath!]?.lazy
-
-        return [
-          [
-            `const ${node.variableName}Route = ${node.variableName}RouteImport.update({
-          ${[
-            `id: '${node.path}'`,
-            !node.isNonPath ? `path: '${node.cleanedPath}'` : undefined,
-            `getParentRoute: () => ${node.parent?.variableName ?? 'root'}Route`,
-          ]
-            .filter(Boolean)
-            .join(',')}
-        }${TYPES_DISABLED ? '' : 'as any'})`,
-            loaderNode
-              ? `.updateLoader({ loader: lazyFn(() => import('./${replaceBackslash(
-                  removeExt(
-                    path.relative(
-                      path.dirname(config.generatedRouteTree),
-                      path.resolve(config.routesDirectory, loaderNode.filePath),
-                    ),
-                    config.addExtensions,
-                  ),
-                )}'), 'loader') })`
-              : '',
-            componentNode || errorComponentNode || pendingComponentNode
-              ? `.update({
-              ${(
-                [
-                  ['component', componentNode],
-                  ['errorComponent', errorComponentNode],
-                  ['pendingComponent', pendingComponentNode],
-                ] as const
-              )
-                .filter((d) => d[1])
-                .map((d) => {
-                  return `${
-                    d[0]
-                  }: lazyRouteComponent(() => import('./${replaceBackslash(
-                    removeExt(
-                      path.relative(
-                        path.dirname(config.generatedRouteTree),
-                        path.resolve(config.routesDirectory, d[1]!.filePath),
-                      ),
-                      config.addExtensions,
-                    ),
-                  )}'), '${d[0]}')`
-                })
-                .join('\n,')}
-            })`
-              : '',
-            lazyComponentNode
-              ? `.lazy(() => import('./${replaceBackslash(
-                  removeExt(
-                    path.relative(
-                      path.dirname(config.generatedRouteTree),
-                      path.resolve(
-                        config.routesDirectory,
-                        lazyComponentNode.filePath,
-                      ),
-                    ),
-                    config.addExtensions,
-                  ),
-                )}').then((d) => d.Route))`
-              : '',
-          ].join(''),
-        ].join('\n\n')
-      })
-      .join('\n\n'),
-    ...(TYPES_DISABLED
-      ? []
-      : [
-          '// Populate the FileRoutesByPath interface',
-          `declare module '${ROUTE_TEMPLATE.fullPkg}' {
-  interface FileRoutesByPath {
-    ${routeNodes
+export function buildFileRoutesByPathInterface(opts: {
+  routeNodes: Array<RouteNode>
+  module: string
+  interfaceName: string
+  exportName: string
+}): string {
+  return `declare module '${opts.module}' {
+  interface ${opts.interfaceName} {
+    ${opts.routeNodes
       .map((routeNode) => {
         const filePathId = routeNode.routePath
+        let preloaderRoute = ''
+
+        if (routeNode.exports?.includes(opts.exportName)) {
+          preloaderRoute = `typeof ${routeNode.variableName}${opts.exportName}Import`
+        } else {
+          preloaderRoute = 'unknown'
+        }
+
+        const parent = findParent(routeNode, opts.exportName)
 
         return `'${filePathId}': {
           id: '${filePathId}'
           path: '${inferPath(routeNode)}'
           fullPath: '${inferFullPath(routeNode)}'
-          preLoaderRoute: typeof ${routeNode.variableName}RouteImport
-          parentRoute: typeof ${
-            routeNode.isVirtualParentRequired
-              ? `${routeNode.parent?.variableName}Route`
-              : routeNode.parent?.variableName
-                ? `${routeNode.parent.variableName}RouteImport`
-                : 'rootRoute'
-          }
+          preLoaderRoute: ${preloaderRoute}
+          parentRoute: typeof ${parent}
         }`
       })
       .join('\n')}
   }
-}`,
-        ]),
-    ...(TYPES_DISABLED
-      ? []
-      : config.verboseFileRoutes !== false
-        ? []
-        : [
-            `// Add type-safety to the createFileRoute function across the route tree`,
-            routeNodes
-              .map((routeNode) => {
-                function getModuleDeclaration(routeNode?: RouteNode) {
-                  if (!isRouteNodeValidForAugmentation(routeNode)) {
-                    return ''
-                  }
-                  return `declare module './${getImportPath(routeNode)}' {
-                  const ${routeNode._fsRouteType === 'lazy' ? 'createLazyFileRoute' : 'createFileRoute'}: ${
-                    routeNode._fsRouteType === 'lazy'
-                      ? `CreateLazyFileRoute<FileRoutesByPath['${routeNode.routePath}']['preLoaderRoute']>}`
-                      : `CreateFileRoute<
-                  '${routeNode.routePath}',
-                  FileRoutesByPath['${routeNode.routePath}']['parentRoute'],
-                  FileRoutesByPath['${routeNode.routePath}']['id'],
-                  FileRoutesByPath['${routeNode.routePath}']['path'],
-                  FileRoutesByPath['${routeNode.routePath}']['fullPath']
-                  >
-                  }`
-                  }`
-                }
-                return (
-                  getModuleDeclaration(routeNode) +
-                  getModuleDeclaration(
-                    routePiecesByPath[routeNode.routePath!]?.lazy,
-                  )
-                )
-              })
-              .join('\n'),
-          ]),
-    '// Create and export the route tree',
-    routeConfigChildrenText,
-    ...(TYPES_DISABLED
-      ? []
-      : [
-          `export interface FileRoutesByFullPath {
-  ${[...createRouteNodesByFullPath(routeNodes).entries()].map(
-    ([fullPath, routeNode]) => {
-      return `'${fullPath}': typeof ${getResolvedRouteNodeVariableName(routeNode)}`
-    },
-  )}
-}`,
-          `export interface FileRoutesByTo {
-  ${[...createRouteNodesByTo(routeNodes).entries()].map(([to, routeNode]) => {
-    return `'${to}': typeof ${getResolvedRouteNodeVariableName(routeNode)}`
-  })}
-}`,
-          `export interface FileRoutesById {
-  '${rootRouteId}': typeof rootRoute,
-  ${[...createRouteNodesById(routeNodes).entries()].map(([id, routeNode]) => {
-    return `'${id}': typeof ${getResolvedRouteNodeVariableName(routeNode)}`
-  })}
-}`,
-          `export interface FileRouteTypes {
-  fileRoutesByFullPath: FileRoutesByFullPath
-  fullPaths: ${routeNodes.length > 0 ? [...createRouteNodesByFullPath(routeNodes).keys()].map((fullPath) => `'${fullPath}'`).join('|') : 'never'}
-  fileRoutesByTo: FileRoutesByTo
-  to: ${routeNodes.length > 0 ? [...createRouteNodesByTo(routeNodes).keys()].map((to) => `'${to}'`).join('|') : 'never'}
-  id: ${[`'${rootRouteId}'`, ...[...createRouteNodesById(routeNodes).keys()].map((id) => `'${id}'`)].join('|')}
-  fileRoutesById: FileRoutesById
-}`,
-          `export interface RootRouteChildren {
-  ${routeTree.map((child) => `${child.variableName}Route: typeof ${getResolvedRouteNodeVariableName(child)}`).join(',')}
-}`,
-        ]),
-    `const rootRouteChildren${TYPES_DISABLED ? '' : ': RootRouteChildren'} = {
-  ${routeTree.map((child) => `${child.variableName}Route: ${getResolvedRouteNodeVariableName(child)}`).join(',')}
-}`,
-    `export const routeTree = rootRoute._addFileChildren(rootRouteChildren)${TYPES_DISABLED ? '' : '._addFileTypes<FileRouteTypes>()'}`,
-    ...config.routeTreeFileFooter,
-  ]
-    .filter(Boolean)
-    .join('\n\n')
-
-  const createRouteManifest = () => {
-    const routesManifest = {
-      [rootRouteId]: {
-        filePath: rootRouteNode.filePath,
-        children: routeTree.map((d) => d.routePath),
-      },
-      ...Object.fromEntries(
-        routeNodes.map((d) => {
-          const filePathId = d.routePath
-
-          return [
-            filePathId,
-            {
-              filePath: d.filePath,
-              parent: d.parent?.routePath ? d.parent.routePath : undefined,
-              children: d.children?.map((childRoute) => childRoute.routePath),
-            },
-          ]
-        }),
-      ),
-    }
-
-    return JSON.stringify(
-      {
-        routes: routesManifest,
-      },
-      null,
-      2,
-    )
-  }
-
-  const includeManifest = ['react', 'solid']
-  const routeConfigFileContent =
-    config.disableManifestGeneration || !includeManifest.includes(config.target)
-      ? routeImports
-      : [
-          routeImports,
-          '\n',
-          '/* ROUTE_MANIFEST_START',
-          createRouteManifest(),
-          'ROUTE_MANIFEST_END */',
-        ].join('\n')
-
-  if (!checkLatest()) return
-
-  const existingRouteTreeContent = await fsp
-    .readFile(path.resolve(config.generatedRouteTree), 'utf-8')
-    .catch((err) => {
-      if (err.code === 'ENOENT') {
-        return ''
-      }
-
-      throw err
-    })
-
-  if (!checkLatest()) return
-
-  // Ensure the directory exists
-  await fsp.mkdir(path.dirname(path.resolve(config.generatedRouteTree)), {
-    recursive: true,
-  })
-
-  if (!checkLatest()) return
-
-  // Write the route tree file, if it has changed
-  const routeTreeWriteResult = await writeIfDifferent(
-    path.resolve(config.generatedRouteTree),
-    config.enableRouteTreeFormatting
-      ? await format(existingRouteTreeContent, config)
-      : existingRouteTreeContent,
-    config.enableRouteTreeFormatting
-      ? await format(routeConfigFileContent, config)
-      : routeConfigFileContent,
-    {
-      beforeWrite: () => {
-        logger.log(`🟡 Updating ${config.generatedRouteTree}`)
-      },
-    },
-  )
-  if (routeTreeWriteResult && !checkLatest()) {
-    return
-  }
-
-  logger.log(
-    `✅ Processed ${routeNodes.length === 1 ? 'route' : 'routes'} in ${
-      Date.now() - start
-    }ms`,
-  )
-}
-
-// function removeTrailingUnderscores(s?: string) {
-//   return s?.replaceAll(/(_$)/gi, '').replaceAll(/(_\/)/gi, '/')
-// }
-
-function removeGroups(s: string) {
-  return s.replace(possiblyNestedRouteGroupPatternRegex, '')
-}
-
-/**
- * Checks if a given RouteNode is valid for augmenting it with typing based on conditions.
- * Also asserts that the RouteNode is defined.
- *
- * @param routeNode - The RouteNode to check.
- * @returns A boolean indicating whether the RouteNode is defined.
- */
-function isRouteNodeValidForAugmentation(
-  routeNode?: RouteNode,
-): routeNode is RouteNode {
-  if (!routeNode || routeNode.isVirtual) {
-    return false
-  }
-  return true
-}
-
-/**
- * The `node.path` is used as the `id` in the route definition.
- * This function checks if the given node has a parent and if so, it determines the correct path for the given node.
- * @param node - The node to determine the path for.
- * @returns The correct path for the given node.
- */
-function determineNodePath(node: RouteNode) {
-  return (node.path = node.parent
-    ? node.routePath?.replace(node.parent.routePath ?? '', '') || '/'
-    : node.routePath)
-}
-
-/**
- * Removes the last segment from a given path. Segments are considered to be separated by a '/'.
- *
- * @param {string} routePath - The path from which to remove the last segment. Defaults to '/'.
- * @returns {string} The path with the last segment removed.
- * @example
- * removeLastSegmentFromPath('/workspace/_auth/foo') // '/workspace/_auth'
- */
-function removeLastSegmentFromPath(routePath: string = '/'): string {
-  const segments = routePath.split('/')
-  segments.pop() // Remove the last segment
-  return segments.join('/')
-}
-
-/**
- * Removes all segments from a given path that start with an underscore ('_').
- *
- * @param {string} routePath - The path from which to remove segments. Defaults to '/'.
- * @returns {string} The path with all underscore-prefixed segments removed.
- * @example
- * removeLayoutSegments('/workspace/_auth/foo') // '/workspace/foo'
- */
-function removeLayoutSegments(routePath: string = '/'): string {
-  const segments = routePath.split('/')
-  const newSegments = segments.filter((segment) => !segment.startsWith('_'))
-  return newSegments.join('/')
-}
-
-function hasParentRoute(
-  routes: Array<RouteNode>,
-  node: RouteNode,
-  routePathToCheck: string | undefined,
-): RouteNode | null {
-  if (!routePathToCheck || routePathToCheck === '/') {
-    return null
-  }
-
-  const sortedNodes = multiSortBy(routes, [
-    (d) => d.routePath!.length * -1,
-    (d) => d.variableName,
-  ]).filter((d) => d.routePath !== `/${rootPathId}`)
-
-  for (const route of sortedNodes) {
-    if (route.routePath === '/') continue
-
-    if (
-      routePathToCheck.startsWith(`${route.routePath}/`) &&
-      route.routePath !== routePathToCheck
-    ) {
-      return route
-    }
-  }
-
-  const segments = routePathToCheck.split('/')
-  segments.pop() // Remove the last segment
-  const parentRoutePath = segments.join('/')
-
-  return hasParentRoute(routes, node, parentRoutePath)
-}
-
-/**
- * Gets the final variable name for a route
- */
-const getResolvedRouteNodeVariableName = (routeNode: RouteNode): string => {
-  return routeNode.children?.length
-    ? `${routeNode.variableName}RouteWithChildren`
-    : `${routeNode.variableName}Route`
-}
-
-/**
- * Creates a map from fullPath to routeNode
- */
-const createRouteNodesByFullPath = (
-  routeNodes: Array<RouteNode>,
-): Map<string, RouteNode> => {
-  return new Map(
-    routeNodes.map((routeNode) => [inferFullPath(routeNode), routeNode]),
-  )
-}
-
-/**
- * Create a map from 'to' to a routeNode
- */
-const createRouteNodesByTo = (
-  routeNodes: Array<RouteNode>,
-): Map<string, RouteNode> => {
-  return new Map(
-    dedupeBranchesAndIndexRoutes(routeNodes).map((routeNode) => [
-      inferTo(routeNode),
-      routeNode,
-    ]),
-  )
-}
-
-/**
- * Create a map from 'id' to a routeNode
- */
-const createRouteNodesById = (
-  routeNodes: Array<RouteNode>,
-): Map<string, RouteNode> => {
-  return new Map(
-    routeNodes.map((routeNode) => {
-      const id = routeNode.routePath ?? ''
-      return [id, routeNode]
-    }),
-  )
-}
-
-/**
- * Infers the full path for use by TS
- */
-const inferFullPath = (routeNode: RouteNode): string => {
-  const fullPath = removeGroups(
-    removeUnderscores(removeLayoutSegments(routeNode.routePath)) ?? '',
-  )
-
-  return routeNode.cleanedPath === '/' ? fullPath : fullPath.replace(/\/$/, '')
-}
-
-/**
- * Infers the path for use by TS
- */
-const inferPath = (routeNode: RouteNode): string => {
-  return routeNode.cleanedPath === '/'
-    ? routeNode.cleanedPath
-    : (routeNode.cleanedPath?.replace(/\/$/, '') ?? '')
-}
-
-/**
- * Infers to path
- */
-const inferTo = (routeNode: RouteNode): string => {
-  const fullPath = inferFullPath(routeNode)
-
-  if (fullPath === '/') return fullPath
-
-  return fullPath.replace(/\/$/, '')
-}
-
-/**
- * Dedupes branches and index routes
- */
-const dedupeBranchesAndIndexRoutes = (
-  routes: Array<RouteNode>,
-): Array<RouteNode> => {
-  return routes.filter((route) => {
-    if (route.children?.find((child) => child.cleanedPath === '/')) return false
-    return true
-  })
-}
-
-function checkUnique<TElement>(routes: Array<TElement>, key: keyof TElement) {
-  // Check no two routes have the same `key`
-  // if they do, throw an error with the conflicting filePaths
-  const keys = routes.map((d) => d[key])
-  const uniqueKeys = new Set(keys)
-  if (keys.length !== uniqueKeys.size) {
-    const duplicateKeys = keys.filter((d, i) => keys.indexOf(d) !== i)
-    const conflictingFiles = routes.filter((d) =>
-      duplicateKeys.includes(d[key]),
-    )
-    return conflictingFiles
-  }
-  return undefined
-}
-
-function checkRouteFullPathUniqueness(
-  _routes: Array<RouteNode>,
-  config: Config,
-) {
-  const routes = _routes.map((d) => {
-    const inferredFullPath = inferFullPath(d)
-    return { ...d, inferredFullPath }
-  })
-
-  const conflictingFiles = checkUnique(routes, 'inferredFullPath')
-
-  if (conflictingFiles !== undefined) {
-    const errorMessage = `Conflicting configuration paths were found for the following route${conflictingFiles.length > 1 ? 's' : ''}: ${conflictingFiles
-      .map((p) => `"${p.inferredFullPath}"`)
-      .join(', ')}.
-Please ensure each Route has a unique full path.
-Conflicting files: \n ${conflictingFiles.map((d) => path.resolve(config.routesDirectory, d.filePath)).join('\n ')}\n`
-    throw new Error(errorMessage)
-  }
+}`
 }