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

package/dist/cjs/generator.cjs

@@ -1,13 +1,18 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const path = require("node:path");
-const fs = require("node:fs");
 const fsp = require("node:fs/promises");
-const utils = require("./utils.cjs");
+const node_fs = require("node:fs");
+const crypto = require("node:crypto");
+const routerCore = require("@tanstack/router-core");
+const logger = require("./logger.cjs");
 const getRouteNodes$1 = require("./filesystem/physical/getRouteNodes.cjs");
 const getRouteNodes = require("./filesystem/virtual/getRouteNodes.cjs");
 const rootPathId = require("./filesystem/physical/rootPathId.cjs");
+const utils = require("./utils.cjs");
 const template = require("./template.cjs");
+const transform = require("./transform/transform.cjs");
+const defaultGeneratorPlugin = require("./plugin/default-generator-plugin.cjs");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
@@ -24,106 +29,791 @@ function _interopNamespaceDefault(e) {
   n.default = e;
   return Object.freeze(n);
 }
-const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
 const fsp__namespace = /* @__PURE__ */ _interopNamespaceDefault(fsp);
-const rootRouteId = "__root__";
-let latestTask = 0;
-const routeGroupPatternRegex = /\(.+\)/g;
-const possiblyNestedRouteGroupPatternRegex = /\([^/]+\)\/?/g;
-let isFirst = false;
-let skipMessage = false;
-async function generator(config, root) {
-  const ROUTE_TEMPLATE = template.getTargetTemplate(config.target);
-  const logger = utils.logging({ disabled: config.disableLogging });
-  logger.log("");
-  if (!isFirst) {
-    logger.log("♻️  Generating routes...");
-    isFirst = true;
-  } else if (skipMessage) {
-    skipMessage = false;
-  } else {
-    logger.log("♻️  Regenerating routes...");
+const DefaultFileSystem = {
+  stat: (filePath) => fsp__namespace.stat(filePath, { bigint: true }),
+  mkdtempSync: node_fs.mkdtempSync,
+  rename: (oldPath, newPath) => fsp__namespace.rename(oldPath, newPath),
+  writeFile: (filePath, content) => fsp__namespace.writeFile(filePath, content),
+  readFile: async (filePath) => {
+    try {
+      const fileHandle = await fsp__namespace.open(filePath, "r");
+      const stat = await fileHandle.stat({ bigint: true });
+      const fileContent = (await fileHandle.readFile()).toString();
+      await fileHandle.close();
+      return { stat, fileContent };
+    } catch (e) {
+      if ("code" in e) {
+        if (e.code === "ENOENT") {
+          return "file-not-existing";
+        }
+      }
+      throw e;
+    }
   }
-  const taskId = latestTask + 1;
-  latestTask = taskId;
-  const checkLatest = () => {
-    if (latestTask !== taskId) {
-      skipMessage = true;
-      return false;
-    }
-    return true;
-  };
-  const start = Date.now();
-  const TYPES_DISABLED = config.disableTypes;
-  let getRouteNodesResult;
-  if (config.virtualRouteConfig) {
-    getRouteNodesResult = await getRouteNodes.getRouteNodes(config, root);
-  } else {
-    getRouteNodesResult = await getRouteNodes$1.getRouteNodes(config, root);
+};
+function rerun(opts) {
+  const { event, ...rest } = opts;
+  return { rerun: true, event: event ?? { type: "rerun" }, ...rest };
+}
+function isRerun(result) {
+  return typeof result === "object" && result !== null && "rerun" in result && result.rerun === true;
+}
+class Generator {
+  constructor(opts) {
+    this.routeNodeCache = /* @__PURE__ */ new Map();
+    this.routeNodeShadowCache = /* @__PURE__ */ new Map();
+    this.fileEventQueue = [];
+    this.plugins = [defaultGeneratorPlugin.defaultGeneratorPlugin()];
+    this.pluginsWithTransform = [];
+    this.transformPlugins = [];
+    this.routeGroupPatternRegex = /\(.+\)/g;
+    this.config = opts.config;
+    this.logger = 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 = template.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 { rootRouteNode, routeNodes: beforeRouteNodes } = getRouteNodesResult;
-  if (rootRouteNode === void 0) {
-    let errorMessage = `rootRouteNode must not be undefined. Make sure you've added your root route into the route-tree.`;
-    if (!config.virtualRouteConfig) {
-      errorMessage += `
-Make sure that you add a "${rootPathId.rootPathId}.${config.disableTypes ? "js" : "tsx"}" file to your routes directory.
-Add the file in: "${config.routesDirectory}/${rootPathId.rootPathId}.${config.disableTypes ? "js" : "tsx"}"`;
-    }
-    throw new Error(errorMessage);
+  getRoutesDirectoryPath() {
+    return path.isAbsolute(this.config.routesDirectory) ? this.config.routesDirectory : path.resolve(this.root, this.config.routesDirectory);
   }
-  const preRouteNodes = utils.multiSortBy(beforeRouteNodes, [
-    (d) => d.routePath === "/" ? -1 : 1,
-    (d) => {
-      var _a;
-      return (_a = d.routePath) == null ? void 0 : _a.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) => {
+  async run(event) {
+    if (event && event.type !== "rerun") {
+      if (!(event.path === this.generatedRouteTreePath || event.path.startsWith(this.routesDirectoryPath))) {
+        return;
+      }
+    }
+    this.fileEventQueue.push(event ?? { type: "rerun" });
+    if (this.runPromise) {
+      return this.runPromise;
+    }
+    this.runPromise = (async () => {
+      do {
+        const tempQueue = this.fileEventQueue;
+        this.fileEventQueue = [];
+        const remainingEvents = (await Promise.all(
+          tempQueue.map(async (e) => {
+            if (e.type === "update") {
+              let cacheEntry;
+              if (e.path === this.generatedRouteTreePath) {
+                cacheEntry = this.routeTreeFileCache;
+              } else {
+                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;
+        }
+        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 = void 0;
+            throw new Error(
+              unrecoverableErrors.map((e) => e.message).join()
+            );
+          }
+        }
+      } while (this.fileEventQueue.length);
+      this.runPromise = void 0;
+    })();
+    return this.runPromise;
+  }
+  async generatorInternal() {
+    let writeRouteTreeFile = false;
+    let getRouteNodesResult;
+    if (this.config.virtualRouteConfig) {
+      getRouteNodesResult = await getRouteNodes.getRouteNodes(this.config, this.root);
+    } else {
+      getRouteNodesResult = await getRouteNodes$1.getRouteNodes(this.config, this.root);
+    }
+    const { rootRouteNode, routeNodes: beforeRouteNodes } = getRouteNodesResult;
+    if (rootRouteNode === void 0) {
+      let errorMessage = `rootRouteNode must not be undefined. Make sure you've added your root route into the route-tree.`;
+      if (!this.config.virtualRouteConfig) {
+        errorMessage += `
+Make sure that you add a "${rootPathId.rootPathId}.${this.config.disableTypes ? "js" : "tsx"}" file to your routes directory.
+Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this.config.disableTypes ? "js" : "tsx"}"`;
+      }
+      throw new Error(errorMessage);
+    }
+    writeRouteTreeFile = await this.handleRootNode(rootRouteNode);
+    const preRouteNodes = utils.multiSortBy(beforeRouteNodes, [
+      (d) => d.routePath === "/" ? -1 : 1,
+      (d) => {
+        var _a;
+        return (_a = d.routePath) == null ? void 0 : _a.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) => {
+        var _a;
+        return ((_a = d.routePath) == null ? void 0 : _a.endsWith("/")) ? -1 : 1;
+      },
+      (d) => d.routePath
+    ]).filter((d) => ![`/${rootPathId.rootPathId}`].includes(d.routePath || ""));
+    const routeFileAllResult = await Promise.allSettled(
+      preRouteNodes.filter((n) => !n.isVirtualParentRoute && !n.isVirtual).map((n) => this.processRouteNodeFile(n))
+    );
+    const rejections = routeFileAllResult.filter(
+      (result) => result.status === "rejected"
+    );
+    if (rejections.length > 0) {
+      throw rejections.map((e) => e.reason);
+    }
+    const routeFileResult = routeFileAllResult.flatMap((result) => {
+      if (result.status === "fulfilled" && result.value !== null) {
+        return result.value;
+      }
+      return [];
+    });
+    routeFileResult.forEach((result) => {
       var _a;
-      return ((_a = d.routePath) == null ? void 0 : _a.endsWith("/")) ? -1 : 1;
-    },
-    (d) => d.routePath
-  ]).filter((d) => ![`/${rootPathId.rootPathId}`].includes(d.routePath || ""));
-  const routeTree = [];
-  const routePiecesByPath = {};
-  const routeNodes = [];
-  const handleRootNode = async (node) => {
-    if (!node) {
+      if (!((_a = result.node.exports) == null ? void 0 : _a.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;
+    }
+    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 (!writeRouteTreeFile) {
       return;
     }
-    const routeCode = fs__namespace.readFileSync(node.fullPath, "utf-8");
-    if (!routeCode) {
-      const _rootTemplate = ROUTE_TEMPLATE.rootRoute;
-      const replaced = await template.fillTemplate(config, _rootTemplate.template(), {
-        tsrImports: _rootTemplate.imports.tsrImports(),
-        tsrPath: rootPathId.rootPathId,
-        tsrExportStart: _rootTemplate.imports.tsrExportStart(),
-        tsrExportEnd: _rootTemplate.imports.tsrExportEnd()
-      });
-      await utils.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 utils.format(routeTreeContent, this.config) : routeTreeContent;
+    let newMtimeMs;
+    if (this.routeTreeFileCache) {
+      if (this.routeTreeFileCache.fileContent === routeTreeContent) ;
+      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 !== void 0) {
+      this.routeTreeFileCache = {
+        fileContent: routeTreeContent,
+        mtimeMs: newMtimeMs
+      };
+    }
+    this.routeNodeCache = this.routeNodeShadowCache;
+    this.routeNodeShadowCache = /* @__PURE__ */ new Map();
+  }
+  buildRouteTreeFileContent(rootRouteNode, preRouteNodes, routeFileResult) {
+    const getImportForRouteNode = (node, exportName) => {
+      var _a;
+      if ((_a = node.exports) == null ? void 0 : _a.includes(exportName)) {
+        return {
+          source: `./${this.getImportPath(node)}`,
+          specifiers: [
+            {
+              imported: exportName,
+              local: `${node.variableName}${exportName}Import`
+            }
+          ]
+        };
+      }
+      return void 0;
+    };
+    const buildRouteTreeForExport = (plugin) => {
+      var _a, _b, _c;
+      const exportName = plugin.transformPlugin.exportName;
+      const acc = {
+        routeTree: [],
+        routeNodes: [],
+        routePiecesByPath: {}
+      };
+      for (const node of preRouteNodes) {
+        if ((_a = node.exports) == null ? void 0 : _a.includes(plugin.transformPlugin.exportName)) {
+          this.handleNode(node, acc);
         }
+      }
+      const sortedRouteNodes = utils.multiSortBy(acc.routeNodes, [
+        (d) => {
+          var _a2;
+          return ((_a2 = d.routePath) == null ? void 0 : _a2.includes(`/${rootPathId.rootPathId}`)) ? -1 : 1;
+        },
+        (d) => {
+          var _a2;
+          return (_a2 = d.routePath) == null ? void 0 : _a2.split("/").length;
+        },
+        (d) => {
+          var _a2;
+          return ((_a2 = d.routePath) == null ? void 0 : _a2.endsWith(this.config.indexToken)) ? -1 : 1;
+        },
+        (d) => d
+      ]);
+      const pluginConfig = plugin.config({
+        generator: this,
+        rootRouteNode,
+        sortedRouteNodes
+      });
+      const routeImports2 = sortedRouteNodes.filter((d) => !d.isVirtual).flatMap((node) => getImportForRouteNode(node, exportName) ?? []);
+      const hasMatchingRouteFiles = acc.routeNodes.length > 0 || ((_b = rootRouteNode.exports) == null ? void 0 : _b.includes(exportName));
+      const virtualRouteNodes = sortedRouteNodes.filter((d) => d.isVirtual).map((node) => {
+        return `const ${node.variableName}${exportName}Import = ${plugin.createVirtualRouteCode({ node })}`;
+      });
+      if (!((_c = rootRouteNode.exports) == null ? void 0 : _c.includes(exportName)) && pluginConfig.virtualRootRoute) {
+        virtualRouteNodes.unshift(
+          `const ${rootRouteNode.variableName}${exportName}Import = ${plugin.createRootRouteCode()}`
+        );
+      }
+      const imports = plugin.imports({
+        sortedRouteNodes,
+        acc,
+        generator: this,
+        rootRouteNode
+      });
+      const routeTreeConfig = utils.buildRouteTreeConfig(
+        acc.routeTree,
+        exportName,
+        this.config.disableTypes
       );
+      const createUpdateRoutes = sortedRouteNodes.map((node) => {
+        var _a2, _b2, _c2, _d, _e;
+        const loaderNode = (_a2 = acc.routePiecesByPath[node.routePath]) == null ? void 0 : _a2.loader;
+        const componentNode = (_b2 = acc.routePiecesByPath[node.routePath]) == null ? void 0 : _b2.component;
+        const errorComponentNode = (_c2 = acc.routePiecesByPath[node.routePath]) == null ? void 0 : _c2.errorComponent;
+        const pendingComponentNode = (_d = acc.routePiecesByPath[node.routePath]) == null ? void 0 : _d.pendingComponent;
+        const lazyComponentNode = (_e = acc.routePiecesByPath[node.routePath]) == null ? void 0 : _e.lazy;
+        return [
+          [
+            `const ${node.variableName}${exportName} = ${node.variableName}${exportName}Import.update({
+            ${[
+              `id: '${node.path}'`,
+              !node.isNonPath ? `path: '${node.cleanedPath}'` : void 0,
+              `getParentRoute: () => ${utils.findParent(node, exportName)}`
+            ].filter(Boolean).join(",")}
+          }${this.config.disableTypes ? "" : "as any"})`,
+            loaderNode ? `.updateLoader({ loader: lazyFn(() => import('./${utils.replaceBackslash(
+              utils.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]
+            ].filter((d) => d[1]).map((d) => {
+              return `${d[0]}: lazyRouteComponent(() => import('./${utils.replaceBackslash(
+                utils.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('./${utils.replaceBackslash(
+              utils.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 {
+${[...utils.createRouteNodesByFullPath(acc.routeNodes).entries()].map(
+            ([fullPath, routeNode]) => {
+              return `'${fullPath}': typeof ${utils.getResolvedRouteNodeVariableName(routeNode, exportName)}`;
+            }
+          )}
+}`,
+          `export interface File${exportName}sByTo {
+${[...utils.createRouteNodesByTo(acc.routeNodes).entries()].map(([to, routeNode]) => {
+            return `'${to}': typeof ${utils.getResolvedRouteNodeVariableName(routeNode, exportName)}`;
+          })}
+}`,
+          `export interface File${exportName}sById {
+'${routerCore.rootRouteId}': typeof root${exportName}Import,
+${[...utils.createRouteNodesById(acc.routeNodes).entries()].map(([id, routeNode]) => {
+            return `'${id}': typeof ${utils.getResolvedRouteNodeVariableName(routeNode, exportName)}`;
+          })}
+}`,
+          `export interface File${exportName}Types {
+file${exportName}sByFullPath: File${exportName}sByFullPath
+fullPaths: ${acc.routeNodes.length > 0 ? [...utils.createRouteNodesByFullPath(acc.routeNodes).keys()].map((fullPath) => `'${fullPath}'`).join("|") : "never"}
+file${exportName}sByTo: File${exportName}sByTo
+to: ${acc.routeNodes.length > 0 ? [...utils.createRouteNodesByTo(acc.routeNodes).keys()].map((to) => `'${to}'`).join("|") : "never"}
+id: ${[`'${routerCore.rootRouteId}'`, ...[...utils.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 ${utils.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}: ${utils.getResolvedRouteNodeVariableName(child, exportName)}`
+          ).join(",")}
+}`,
+          `export const ${utils.lowerCaseFirstChar(exportName)}Tree = root${exportName}Import._addFileChildren(root${exportName}Children)${this.config.disableTypes ? "" : `._addFileTypes<File${exportName}Types>()`}`
+        ].join("\n");
+      }
+      return {
+        routeImports: routeImports2,
+        sortedRouteNodes,
+        acc,
+        virtualRouteNodes,
+        routeTreeConfig,
+        routeTree,
+        imports,
+        createUpdateRoutes,
+        fileRoutesByFullPathPerPlugin,
+        fileRoutesByPathInterfacePerPlugin
+      };
+    };
+    const routeTrees = this.pluginsWithTransform.map((plugin) => ({
+      exportName: plugin.transformPlugin.exportName,
+      ...buildRouteTreeForExport(plugin)
+    }));
+    this.plugins.map((plugin) => {
+      var _a;
+      return (_a = plugin.onRouteTreesChanged) == null ? void 0 : _a.call(plugin, {
+        routeTrees,
+        rootRouteNode,
+        generator: this
+      });
+    });
+    let mergedImports = utils.mergeImportDeclarations(
+      routeTrees.flatMap((d) => d.imports)
+    );
+    if (this.config.disableTypes) {
+      mergedImports = mergedImports.filter((d) => d.importKind !== "type");
+    }
+    const importStatements = mergedImports.map(utils.buildImportString);
+    let moduleAugmentation = "";
+    if (this.config.verboseFileRoutes === false && !this.config.disableTypes) {
+      moduleAugmentation = routeFileResult.map(({ node }) => {
+        const getModuleDeclaration = (routeNode) => {
+          if (!utils.isRouteNodeValidForAugmentation(routeNode)) {
+            return "";
+          }
+          const moduleAugmentation2 = this.pluginsWithTransform.map((plugin) => {
+            return plugin.routeModuleAugmentation({
+              routeNode
+            });
+          }).filter(Boolean).join("\n");
+          return `declare module './${this.getImportPath(routeNode)}' {
+                      ${moduleAugmentation2}
+                    }`;
+        };
+        return getModuleDeclaration(node);
+      }).join("\n");
+    }
+    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);
     }
-  };
-  await handleRootNode(rootRouteNode);
-  const handleNode = async (node) => {
+    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"),
+      utils.mergeImportDeclarations(routeImports).map(utils.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;
+  }
+  getImportPath(node) {
+    return utils.replaceBackslash(
+      utils.removeExt(
+        path.relative(
+          path.dirname(this.config.generatedRouteTree),
+          path.resolve(this.config.routesDirectory, node.filePath)
+        ),
+        this.config.addExtensions
+      )
+    );
+  }
+  async processRouteNodeFile(node) {
     var _a, _b, _c, _d, _e;
-    utils.resetRegex(routeGroupPatternRegex);
-    let parentRoute = hasParentRoute(routeNodes, node, node.routePath);
+    const result = await this.isRouteFileCacheFresh(node);
+    if (result.status === "fresh") {
+      node.exports = result.cacheEntry.exports;
+      return {
+        node,
+        shouldWriteTree: result.exportsChanged,
+        cacheEntry: result.cacheEntry
+      };
+    }
+    const existingRouteFile = await this.fs.readFile(node.fullPath);
+    if (existingRouteFile === "file-not-existing") {
+      throw new Error(`⚠️ File ${node.fullPath} does not exist`);
+    }
+    const updatedCacheEntry = {
+      fileContent: existingRouteFile.fileContent,
+      mtimeMs: existingRouteFile.stat.mtimeMs,
+      exports: []
+    };
+    const escapedRoutePath = ((_a = node.routePath) == null ? void 0 : _a.replaceAll("$", "$$")) ?? "";
+    let shouldWriteRouteFile = false;
+    if (!existingRouteFile.fileContent) {
+      shouldWriteRouteFile = true;
+      if (node._fsRouteType === "lazy") {
+        const tLazyRouteTemplate = this.targetTemplate.lazyRoute;
+        updatedCacheEntry.fileContent = await template.fillTemplate(
+          this.config,
+          (((_b = this.config.customScaffolding) == null ? void 0 : _b.lazyRouteTemplate) || ((_c = this.config.customScaffolding) == null ? void 0 : _c.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"].some(
+          (d) => d === node._fsRouteType
+        ) || [
+          "component",
+          "pendingComponent",
+          "errorComponent",
+          "loader"
+        ].every((d) => d !== node._fsRouteType)
+      ) {
+        const tRouteTemplate = this.targetTemplate.route;
+        updatedCacheEntry.fileContent = await template.fillTemplate(
+          this.config,
+          ((_d = this.config.customScaffolding) == null ? void 0 : _d.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 {
+      const transformResult = await transform.transform({
+        source: updatedCacheEntry.fileContent,
+        ctx: {
+          target: this.config.target,
+          routeId: escapedRoutePath,
+          lazy: node._fsRouteType === "lazy",
+          verboseFileRoutes: !(this.config.verboseFileRoutes === false)
+        },
+        plugins: this.transformPlugins
+      });
+      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;
+      }
+    }
+    if (shouldWriteRouteFile) {
+      const stats = await this.safeFileWrite({
+        filePath: node.fullPath,
+        newContent: updatedCacheEntry.fileContent,
+        strategy: {
+          type: "mtime",
+          expectedMtimeMs: updatedCacheEntry.mtimeMs
+        }
+      });
+      updatedCacheEntry.mtimeMs = stats.mtimeMs;
+    }
+    this.routeNodeShadowCache.set(node.fullPath, updatedCacheEntry);
+    node.exports = updatedCacheEntry.exports;
+    const shouldWriteTree = !routerCore.deepEqual(
+      (_e = result.cacheEntry) == null ? void 0 : _e.exports,
+      updatedCacheEntry.exports
+    );
+    return {
+      node,
+      shouldWriteTree,
+      cacheEntry: updatedCacheEntry
+    };
+  }
+  async didRouteFileChangeComparedToCache(file, cache) {
+    const cacheEntry = this[cache].get(file.path);
+    return this.didFileChangeComparedToCache(file, cacheEntry);
+  }
+  async didFileChangeComparedToCache(file, cacheEntry) {
+    if (!cacheEntry) {
+      return { result: "file-not-in-cache" };
+    }
+    let mtimeMs = file.mtimeMs;
+    if (mtimeMs === void 0) {
+      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 };
+  }
+  async safeFileWrite(opts) {
+    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 utils.checkFileExists(opts.filePath)) {
+        throw rerun({
+          msg: `File ${opts.filePath} already exists. Cannot overwrite.`,
+          event: { type: "update", path: opts.filePath }
+        });
+      }
+    }
+    const stat = await this.fs.stat(tmpPath);
+    await this.fs.rename(tmpPath, opts.filePath);
+    return stat;
+  }
+  getTempFileName(filePath) {
+    const absPath = path.resolve(filePath);
+    const hash = crypto.createHash("md5").update(absPath).digest("hex");
+    return path.join(this.tmpDir, hash);
+  }
+  async isRouteFileCacheFresh(node) {
+    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 : void 0;
+    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) {
+      if (fileChangedCache.result === true) {
+        if (routerCore.deepEqual(
+          fileChangedCache.cacheEntry.exports,
+          shadowCacheFileChange.cacheEntry.exports
+        )) {
+          return {
+            status: "fresh",
+            exportsChanged: false,
+            cacheEntry: shadowCacheFileChange.cacheEntry
+          };
+        }
+        return {
+          status: "fresh",
+          exportsChanged: true,
+          cacheEntry: shadowCacheFileChange.cacheEntry
+        };
+      }
+    }
+    if (fileChangedCache.result === "file-not-in-cache") {
+      return {
+        status: "stale"
+      };
+    }
+    return { status: "stale", cacheEntry: fileChangedCache.cacheEntry };
+  }
+  async handleRootNode(node) {
+    var _a;
+    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}`);
+    }
+    const updatedCacheEntry = {
+      fileContent: rootNodeFile.fileContent,
+      mtimeMs: rootNodeFile.stat.mtimeMs,
+      exports: []
+    };
+    if (!rootNodeFile.fileContent) {
+      const rootTemplate = this.targetTemplate.rootRoute;
+      const rootRouteContent = await template.fillTemplate(
+        this.config,
+        rootTemplate.template(),
+        {
+          tsrImports: rootTemplate.imports.tsrImports(),
+          tsrPath: rootPathId.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 = [];
+    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 = !routerCore.deepEqual(
+      (_a = result.cacheEntry) == null ? void 0 : _a.exports,
+      rootRouteExports
+    );
+    return shouldWriteTree;
+  }
+  handleNode(node, acc) {
+    var _a;
+    utils.resetRegex(this.routeGroupPatternRegex);
+    let parentRoute = utils.hasParentRoute(acc.routeNodes, node, node.routePath);
     if ((parentRoute == null ? void 0 : parentRoute.isVirtualParentRoute) && ((_a = parentRoute.children) == null ? void 0 : _a.length)) {
-      const possibleParentRoute = hasParentRoute(
+      const possibleParentRoute = utils.hasParentRoute(
         parentRoute.children,
         node,
         node.routePath
@@ -133,135 +823,14 @@ Add the file in: "${config.routesDirectory}/${rootPathId.rootPathId}.${config.di
       }
     }
     if (parentRoute) node.parent = parentRoute;
-    node.path = determineNodePath(node);
+    node.path = utils.determineNodePath(node);
     const trimmedPath = utils.trimPathLeft(node.path ?? "");
     const split = trimmedPath.split("/");
     const lastRouteSegment = split[split.length - 1] ?? trimmedPath;
-    node.isNonPath = lastRouteSegment.startsWith("_") || routeGroupPatternRegex.test(lastRouteSegment);
-    node.cleanedPath = removeGroups(
-      utils.removeUnderscores(removeLayoutSegments(node.path)) ?? ""
+    node.isNonPath = lastRouteSegment.startsWith("_") || this.routeGroupPatternRegex.test(lastRouteSegment);
+    node.cleanedPath = utils.removeGroups(
+      utils.removeUnderscores(utils.removeLayoutSegments(node.path)) ?? ""
     );
-    if (!node.isVirtualParentRoute && !node.isVirtual) {
-      const routeCode = fs__namespace.readFileSync(node.fullPath, "utf-8");
-      const escapedRoutePath = ((_b = node.routePath) == null ? void 0 : _b.replaceAll("$", "$$")) ?? "";
-      let replaced = routeCode;
-      const tRouteTemplate = ROUTE_TEMPLATE.route;
-      const tLazyRouteTemplate = ROUTE_TEMPLATE.lazyRoute;
-      if (!routeCode) {
-        if (node._fsRouteType === "lazy") {
-          replaced = await template.fillTemplate(
-            config,
-            (((_c = config.customScaffolding) == null ? void 0 : _c.lazyRouteTemplate) || ((_d = config.customScaffolding) == null ? void 0 : _d.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"].some(
-            (d) => d === node._fsRouteType
-          ) || [
-            "component",
-            "pendingComponent",
-            "errorComponent",
-            "loader"
-          ].every((d) => d !== node._fsRouteType)
-        ) {
-          replaced = await template.fillTemplate(
-            config,
-            ((_e = config.customScaffolding) == null ? void 0 : _e.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) {
-        if (!routeCode.split("\n").some((line) => line.trim().startsWith("export const Route"))) {
-          return;
-        }
-        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);
-              }
-              return trimmed;
-            };
-            const afterCreateFileRoute = () => {
-              if (!p5) return "";
-              let trimmed = p5.trim();
-              if (trimmed.startsWith(",")) {
-                trimmed = trimmed.slice(1);
-              }
-              return trimmed;
-            };
-            const newImport = () => {
-              const before = beforeCreateFileRoute();
-              const after = afterCreateFileRoute();
-              if (!before) return after;
-              if (!after) return before;
-              return `${before},${after}`;
-            };
-            const middle = newImport();
-            if (middle === "") return "";
-            return `${p1} ${newImport()} ${p6}`;
-          }
-        ).replace(
-          /create(Lazy)?FileRoute(\(\s*['"])([^\s]*)(['"],?\s*\))/g,
-          (_, __, p2, ___, p4) => `${node._fsRouteType === "lazy" ? "createLazyFileRoute" : "createFileRoute"}`
-        );
-      } else {
-        if (!routeCode.split("\n").some((line) => line.trim().startsWith("export const Route"))) {
-          return;
-        }
-        replaced = routeCode.replace(
-          /(FileRoute\(\s*['"])([^\s]*)(['"],?\s*\))/g,
-          (_, p1, __, p3) => `${p1}${escapedRoutePath}${p3}`
-        ).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}`
-        );
-        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");
-        }
-      }
-      await utils.writeIfDifferent(node.fullPath, routeCode, replaced, {
-        beforeWrite: () => {
-          logger.log(`🟡 Updating ${node.fullPath}`);
-        }
-      });
-    }
     if (!node.isVirtual && [
       "lazy",
       "loader",
@@ -269,15 +838,20 @@ Add the file in: "${config.routesDirectory}/${rootPathId.rootPathId}.${config.di
       "pendingComponent",
       "errorComponent"
     ].some((d) => d === node._fsRouteType)) {
-      routePiecesByPath[node.routePath] = routePiecesByPath[node.routePath] || {};
-      routePiecesByPath[node.routePath][node._fsRouteType === "lazy" ? "lazy" : node._fsRouteType === "loader" ? "loader" : node._fsRouteType === "errorComponent" ? "errorComponent" : node._fsRouteType === "pendingComponent" ? "pendingComponent" : "component"] = node;
-      const anchorRoute = routeNodes.find((d) => d.routePath === node.routePath);
+      acc.routePiecesByPath[node.routePath] = acc.routePiecesByPath[node.routePath] || {};
+      acc.routePiecesByPath[node.routePath][node._fsRouteType === "lazy" ? "lazy" : node._fsRouteType === "loader" ? "loader" : node._fsRouteType === "errorComponent" ? "errorComponent" : node._fsRouteType === "pendingComponent" ? "pendingComponent" : "component"] = node;
+      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;
     }
@@ -285,17 +859,17 @@ Add the file in: "${config.routesDirectory}/${rootPathId.rootPathId}.${config.di
     const nonPathRoute = node._fsRouteType === "pathless_layout" && node.isNonPath;
     node.isVirtualParentRequired = node._fsRouteType === "pathless_layout" || nonPathRoute ? !cleanedPathIsEmpty : false;
     if (!node.isVirtual && node.isVirtualParentRequired) {
-      const parentRoutePath = removeLastSegmentFromPath(node.routePath) || "/";
+      const parentRoutePath = utils.removeLastSegmentFromPath(node.routePath) || "/";
       const parentVariableName = utils.routePathToVariable(parentRoutePath);
-      const anchorRoute = routeNodes.find(
+      const anchorRoute = acc.routeNodes.find(
         (d) => d.routePath === parentRoutePath
       );
       if (!anchorRoute) {
         const parentNode = {
           ...node,
-          path: removeLastSegmentFromPath(node.path) || "/",
-          filePath: removeLastSegmentFromPath(node.filePath) || "/",
-          fullPath: removeLastSegmentFromPath(node.fullPath) || "/",
+          path: utils.removeLastSegmentFromPath(node.path) || "/",
+          filePath: utils.removeLastSegmentFromPath(node.filePath) || "/",
+          fullPath: utils.removeLastSegmentFromPath(node.fullPath) || "/",
           routePath: parentRoutePath,
           variableName: parentVariableName,
           isVirtual: true,
@@ -308,9 +882,9 @@ Add the file in: "${config.routesDirectory}/${rootPathId.rootPathId}.${config.di
         parentNode.children.push(node);
         node.parent = parentNode;
         if (node._fsRouteType === "pathless_layout") {
-          node.path = determineNodePath(node);
+          node.path = utils.determineNodePath(node);
         }
-        await handleNode(parentNode);
+        this.handleNode(parentNode, acc);
       } else {
         anchorRoute.children = anchorRoute.children ?? [];
         anchorRoute.children.push(node);
@@ -323,446 +897,35 @@ Add the file in: "${config.routesDirectory}/${rootPathId.rootPathId}.${config.di
         node.parent.children.push(node);
       }
     } else {
-      routeTree.push(node);
+      acc.routeTree.push(node);
     }
-    routeNodes.push(node);
-  };
-  for (const node of preRouteNodes) {
-    await handleNode(node);
-  }
-  checkRouteFullPathUniqueness(
-    preRouteNodes.filter(
-      (d) => d.children === void 0 && "lazy" !== d._fsRouteType
-    ),
-    config
-  );
-  function buildRouteTreeConfig(nodes, depth = 1) {
-    const children = nodes.map((node) => {
-      var _a, _b;
-      if (node._fsRouteType === "__root") {
-        return;
-      }
-      if (node._fsRouteType === "pathless_layout" && !((_a = node.children) == null ? void 0 : _a.length)) {
-        return;
-      }
-      const route = `${node.variableName}Route`;
-      if ((_b = node.children) == null ? void 0 : _b.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 children2 = `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,
-          children2,
-          routeWithChildren
-        ].join("\n\n");
-      }
-      return void 0;
-    });
-    return children.filter(Boolean).join("\n\n");
+    acc.routeNodes.push(node);
   }
-  const routeConfigChildrenText = buildRouteTreeConfig(routeTree);
-  const sortedRouteNodes = utils.multiSortBy(routeNodes, [
-    (d) => {
-      var _a;
-      return ((_a = d.routePath) == null ? void 0 : _a.includes(`/${rootPathId.rootPathId}`)) ? -1 : 1;
-    },
-    (d) => {
-      var _a;
-      return (_a = d.routePath) == null ? void 0 : _a.split("/").length;
-    },
-    (d) => {
-      var _a;
-      return ((_a = d.routePath) == null ? void 0 : _a.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) => {
-        var _a;
-        return ((_a = routePiecesByPath[node.routePath]) == null ? void 0 : _a.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) => {
-        var _a;
-        return (_a = routePiecesByPath[node.routePath]) == null ? void 0 : _a.loader;
-      }
-    ),
-    lazyRouteComponent: sortedRouteNodes.some(
-      (node) => {
-        var _a, _b, _c;
-        return ((_a = routePiecesByPath[node.routePath]) == null ? void 0 : _a.component) || ((_b = routePiecesByPath[node.routePath]) == null ? void 0 : _b.errorComponent) || ((_c = routePiecesByPath[node.routePath]) == null ? void 0 : _c.pendingComponent);
-      }
-    )
-  }).filter((d) => d[1]).map((d) => d[0]);
-  const virtualRouteNodes = sortedRouteNodes.filter((d) => d.isVirtual);
-  function getImportPath(node) {
-    return utils.replaceBackslash(
-      utils.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) => {
-      var _a, _b, _c, _d, _e, _f;
-      const loaderNode = (_a = routePiecesByPath[node.routePath]) == null ? void 0 : _a.loader;
-      const componentNode = (_b = routePiecesByPath[node.routePath]) == null ? void 0 : _b.component;
-      const errorComponentNode = (_c = routePiecesByPath[node.routePath]) == null ? void 0 : _c.errorComponent;
-      const pendingComponentNode = (_d = routePiecesByPath[node.routePath]) == null ? void 0 : _d.pendingComponent;
-      const lazyComponentNode = (_e = routePiecesByPath[node.routePath]) == null ? void 0 : _e.lazy;
-      return [
-        [
-          `const ${node.variableName}Route = ${node.variableName}RouteImport.update({
-          ${[
-            `id: '${node.path}'`,
-            !node.isNonPath ? `path: '${node.cleanedPath}'` : void 0,
-            `getParentRoute: () => ${((_f = node.parent) == null ? void 0 : _f.variableName) ?? "root"}Route`
-          ].filter(Boolean).join(",")}
-        }${TYPES_DISABLED ? "" : "as any"})`,
-          loaderNode ? `.updateLoader({ loader: lazyFn(() => import('./${utils.replaceBackslash(
-            utils.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]
-          ].filter((d) => d[1]).map((d) => {
-            return `${d[0]}: lazyRouteComponent(() => import('./${utils.replaceBackslash(
-              utils.removeExt(
-                path.relative(
-                  path.dirname(config.generatedRouteTree),
-                  path.resolve(config.routesDirectory, d[1].filePath)
-                ),
-                config.addExtensions
-              )
-            )}'), '${d[0]}')`;
-          }).join("\n,")}
-            })` : "",
-          lazyComponentNode ? `.lazy(() => import('./${utils.replaceBackslash(
-            utils.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.map((routeNode) => {
-        var _a, _b;
-        const filePathId = routeNode.routePath;
-        return `'${filePathId}': {
-          id: '${filePathId}'
-          path: '${inferPath(routeNode)}'
-          fullPath: '${inferFullPath(routeNode)}'
-          preLoaderRoute: typeof ${routeNode.variableName}RouteImport
-          parentRoute: typeof ${routeNode.isVirtualParentRequired ? `${(_a = routeNode.parent) == null ? void 0 : _a.variableName}Route` : ((_b = routeNode.parent) == null ? void 0 : _b.variableName) ? `${routeNode.parent.variableName}RouteImport` : "rootRoute"}
-        }`;
-      }).join("\n")}
-  }
-}`
-    ],
-    ...TYPES_DISABLED ? [] : config.verboseFileRoutes !== false ? [] : [
-      `// Add type-safety to the createFileRoute function across the route tree`,
-      routeNodes.map((routeNode) => {
-        var _a;
-        function getModuleDeclaration(routeNode2) {
-          if (!isRouteNodeValidForAugmentation(routeNode2)) {
-            return "";
-          }
-          return `declare module './${getImportPath(routeNode2)}' {
-                  const ${routeNode2._fsRouteType === "lazy" ? "createLazyFileRoute" : "createFileRoute"}: ${routeNode2._fsRouteType === "lazy" ? `CreateLazyFileRoute<FileRoutesByPath['${routeNode2.routePath}']['preLoaderRoute']>}` : `CreateFileRoute<
-                  '${routeNode2.routePath}',
-                  FileRoutesByPath['${routeNode2.routePath}']['parentRoute'],
-                  FileRoutesByPath['${routeNode2.routePath}']['id'],
-                  FileRoutesByPath['${routeNode2.routePath}']['path'],
-                  FileRoutesByPath['${routeNode2.routePath}']['fullPath']
-                  >
-                  }`}`;
-        }
-        return getModuleDeclaration(routeNode) + getModuleDeclaration(
-          (_a = routePiecesByPath[routeNode.routePath]) == null ? void 0 : _a.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) => {
-          var _a, _b;
-          const filePathId = d.routePath;
-          return [
-            filePathId,
-            {
-              filePath: d.filePath,
-              parent: ((_a = d.parent) == null ? void 0 : _a.routePath) ? d.parent.routePath : void 0,
-              children: (_b = d.children) == null ? void 0 : _b.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__namespace.readFile(path.resolve(config.generatedRouteTree), "utf-8").catch((err) => {
-    if (err.code === "ENOENT") {
-      return "";
-    }
-    throw err;
-  });
-  if (!checkLatest()) return;
-  await fsp__namespace.mkdir(path.dirname(path.resolve(config.generatedRouteTree)), {
-    recursive: true
-  });
-  if (!checkLatest()) return;
-  const routeTreeWriteResult = await utils.writeIfDifferent(
-    path.resolve(config.generatedRouteTree),
-    config.enableRouteTreeFormatting ? await utils.format(existingRouteTreeContent, config) : existingRouteTreeContent,
-    config.enableRouteTreeFormatting ? await utils.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 removeGroups(s) {
-  return s.replace(possiblyNestedRouteGroupPatternRegex, "");
-}
-function isRouteNodeValidForAugmentation(routeNode) {
-  if (!routeNode || routeNode.isVirtual) {
-    return false;
-  }
-  return true;
-}
-function determineNodePath(node) {
-  var _a;
-  return node.path = node.parent ? ((_a = node.routePath) == null ? void 0 : _a.replace(node.parent.routePath ?? "", "")) || "/" : node.routePath;
-}
-function removeLastSegmentFromPath(routePath = "/") {
-  const segments = routePath.split("/");
-  segments.pop();
-  return segments.join("/");
-}
-function removeLayoutSegments(routePath = "/") {
-  const segments = routePath.split("/");
-  const newSegments = segments.filter((segment) => !segment.startsWith("_"));
-  return newSegments.join("/");
-}
-function hasParentRoute(routes, node, routePathToCheck) {
-  if (!routePathToCheck || routePathToCheck === "/") {
-    return null;
-  }
-  const sortedNodes = utils.multiSortBy(routes, [
-    (d) => d.routePath.length * -1,
-    (d) => d.variableName
-  ]).filter((d) => d.routePath !== `/${rootPathId.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();
-  const parentRoutePath = segments.join("/");
-  return hasParentRoute(routes, node, parentRoutePath);
-}
-const getResolvedRouteNodeVariableName = (routeNode) => {
-  var _a;
-  return ((_a = routeNode.children) == null ? void 0 : _a.length) ? `${routeNode.variableName}RouteWithChildren` : `${routeNode.variableName}Route`;
-};
-const createRouteNodesByFullPath = (routeNodes) => {
-  return new Map(
-    routeNodes.map((routeNode) => [inferFullPath(routeNode), routeNode])
-  );
-};
-const createRouteNodesByTo = (routeNodes) => {
-  return new Map(
-    dedupeBranchesAndIndexRoutes(routeNodes).map((routeNode) => [
-      inferTo(routeNode),
-      routeNode
-    ])
-  );
-};
-const createRouteNodesById = (routeNodes) => {
-  return new Map(
-    routeNodes.map((routeNode) => {
-      const id = routeNode.routePath ?? "";
-      return [id, routeNode];
-    })
-  );
-};
-const inferFullPath = (routeNode) => {
-  const fullPath = removeGroups(
-    utils.removeUnderscores(removeLayoutSegments(routeNode.routePath)) ?? ""
-  );
-  return routeNode.cleanedPath === "/" ? fullPath : fullPath.replace(/\/$/, "");
-};
-const inferPath = (routeNode) => {
-  var _a;
-  return routeNode.cleanedPath === "/" ? routeNode.cleanedPath : ((_a = routeNode.cleanedPath) == null ? void 0 : _a.replace(/\/$/, "")) ?? "";
-};
-const inferTo = (routeNode) => {
-  const fullPath = inferFullPath(routeNode);
-  if (fullPath === "/") return fullPath;
-  return fullPath.replace(/\/$/, "");
-};
-const dedupeBranchesAndIndexRoutes = (routes) => {
-  return routes.filter((route) => {
+function buildFileRoutesByPathInterface(opts) {
+  return `declare module '${opts.module}' {
+  interface ${opts.interfaceName} {
+    ${opts.routeNodes.map((routeNode) => {
     var _a;
-    if ((_a = route.children) == null ? void 0 : _a.find((child) => child.cleanedPath === "/")) return false;
-    return true;
-  });
-};
-function checkUnique(routes, key) {
-  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 void 0;
-}
-function checkRouteFullPathUniqueness(_routes, config) {
-  const routes = _routes.map((d) => {
-    const inferredFullPath = inferFullPath(d);
-    return { ...d, inferredFullPath };
-  });
-  const conflictingFiles = checkUnique(routes, "inferredFullPath");
-  if (conflictingFiles !== void 0) {
-    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: 
- ${conflictingFiles.map((d) => path.resolve(config.routesDirectory, d.filePath)).join("\n ")}
-`;
-    throw new Error(errorMessage);
+    const filePathId = routeNode.routePath;
+    let preloaderRoute = "";
+    if ((_a = routeNode.exports) == null ? void 0 : _a.includes(opts.exportName)) {
+      preloaderRoute = `typeof ${routeNode.variableName}${opts.exportName}Import`;
+    } else {
+      preloaderRoute = "unknown";
+    }
+    const parent = utils.findParent(routeNode, opts.exportName);
+    return `'${filePathId}': {
+          id: '${filePathId}'
+          path: '${utils.inferPath(routeNode)}'
+          fullPath: '${utils.inferFullPath(routeNode)}'
+          preLoaderRoute: ${preloaderRoute}
+          parentRoute: typeof ${parent}
+        }`;
+  }).join("\n")}
   }
+}`;
 }
-exports.generator = generator;
+exports.Generator = Generator;
+exports.buildFileRoutesByPathInterface = buildFileRoutesByPathInterface;
 //# sourceMappingURL=generator.cjs.map