@tanstack/router-generator 1.166.9 → 1.166.11

package/dist/cjs/generator.cjs

@@ -1,1141 +1,801 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const path = require("node:path");
-const fsp = require("node:fs/promises");
-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 validateRouteParams = require("./validate-route-params.cjs");
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const fsp__namespace = /* @__PURE__ */ _interopNamespaceDefault(fsp);
-const DefaultFileSystem = {
-  stat: async (filePath) => {
-    const res = await fsp__namespace.stat(filePath, { bigint: true });
-    return {
-      mtimeMs: res.mtimeMs,
-      mode: Number(res.mode),
-      uid: Number(res.uid),
-      gid: Number(res.gid)
-    };
-  },
-  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;
-    }
-  },
-  chmod: (filePath, mode) => fsp__namespace.chmod(filePath, mode),
-  chown: (filePath, uid, gid) => fsp__namespace.chown(filePath, uid, gid)
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_logger = require("./logger.cjs");
+const require_rootPathId = require("./filesystem/physical/rootPathId.cjs");
+const require_utils = require("./utils.cjs");
+const require_getRouteNodes = require("./filesystem/virtual/getRouteNodes.cjs");
+const require_getRouteNodes$1 = require("./filesystem/physical/getRouteNodes.cjs");
+const require_template = require("./template.cjs");
+const require_transform = require("./transform/transform.cjs");
+const require_validate_route_params = require("./validate-route-params.cjs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_runtime.__toESM(node_fs_promises);
+let node_crypto = require("node:crypto");
+node_crypto = require_runtime.__toESM(node_crypto);
+let _tanstack_router_core = require("@tanstack/router-core");
+//#region src/generator.ts
+var DefaultFileSystem = {
+	stat: async (filePath) => {
+		const res = await node_fs_promises.stat(filePath, { bigint: true });
+		return {
+			mtimeMs: res.mtimeMs,
+			mode: Number(res.mode),
+			uid: Number(res.uid),
+			gid: Number(res.gid)
+		};
+	},
+	rename: (oldPath, newPath) => node_fs_promises.rename(oldPath, newPath),
+	writeFile: (filePath, content) => node_fs_promises.writeFile(filePath, content),
+	readFile: async (filePath) => {
+		try {
+			const fileHandle = await node_fs_promises.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;
+		}
+	},
+	chmod: (filePath, mode) => node_fs_promises.chmod(filePath, mode),
+	chown: (filePath, uid, gid) => node_fs_promises.chown(filePath, uid, gid)
 };
 function rerun(opts) {
-  const { event, ...rest } = opts;
-  return { rerun: true, event: event ?? { type: "rerun" }, ...rest };
+	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;
+	return typeof result === "object" && result !== null && "rerun" in result && result.rerun === true;
 }
-const _Generator = class _Generator {
-  constructor(opts) {
-    this.routeNodeCache = /* @__PURE__ */ new Map();
-    this.routeNodeShadowCache = /* @__PURE__ */ new Map();
-    this.fileEventQueue = [];
-    this.plugins = [];
-    this.physicalDirectories = [];
-    this.config = opts.config;
-    this.logger = logger.logging({ disabled: this.config.disableLogging });
-    this.root = opts.root;
-    this.fs = opts.fs || DefaultFileSystem;
-    this.generatedRouteTreePath = this.getGeneratedRouteTreePath();
-    this.targetTemplate = template.getTargetTemplate(this.config);
-    this.routesDirectoryPath = this.getRoutesDirectoryPath();
-    this.plugins.push(...opts.config.plugins || []);
-    this.indexTokenFilenameRegex = utils.createTokenRegex(this.config.indexToken, {
-      type: "filename"
-    });
-    this.routeTokenFilenameRegex = utils.createTokenRegex(this.config.routeToken, {
-      type: "filename"
-    });
-    this.indexTokenSegmentRegex = utils.createTokenRegex(this.config.indexToken, {
-      type: "segment"
-    });
-    this.routeTokenSegmentRegex = utils.createTokenRegex(this.config.routeToken, {
-      type: "segment"
-    });
-    for (const plugin of this.plugins) {
-      plugin.init?.({ generator: this });
-    }
-  }
-  getGeneratedRouteTreePath() {
-    const generatedRouteTreePath = path.isAbsolute(
-      this.config.generatedRouteTree
-    ) ? this.config.generatedRouteTree : path.resolve(this.root, this.config.generatedRouteTree);
-    const generatedRouteTreeDir = path.dirname(generatedRouteTreePath);
-    if (!node_fs.existsSync(generatedRouteTreeDir)) {
-      node_fs.mkdirSync(generatedRouteTreeDir, { recursive: true });
-    }
-    return generatedRouteTreePath;
-  }
-  getRoutesDirectoryPath() {
-    return path.isAbsolute(this.config.routesDirectory) ? this.config.routesDirectory : path.resolve(this.root, this.config.routesDirectory);
-  }
-  getRoutesByFileMap() {
-    return new Map(
-      [...this.routeNodeCache.entries()].map(([filePath, cacheEntry]) => [
-        filePath,
-        { routePath: cacheEntry.routeId }
-      ])
-    );
-  }
-  async run(event) {
-    if (event && event.type !== "rerun" && !this.isFileRelevantForRouteTreeGeneration(event.path)) {
-      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 {
-          await this.generatorInternal();
-        } 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, {
-        indexTokenSegmentRegex: this.indexTokenSegmentRegex,
-        routeTokenSegmentRegex: this.routeTokenSegmentRegex
-      });
-    } else {
-      getRouteNodesResult = await getRouteNodes$1.getRouteNodes(
-        this.config,
-        this.root,
-        {
-          indexTokenSegmentRegex: this.indexTokenSegmentRegex,
-          routeTokenSegmentRegex: this.routeTokenSegmentRegex
-        }
-      );
-    }
-    const {
-      rootRouteNode,
-      routeNodes: beforeRouteNodes,
-      physicalDirectories
-    } = 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);
-    }
-    this.physicalDirectories = physicalDirectories;
-    await this.handleRootNode(rootRouteNode);
-    const preRouteNodes = utils.multiSortBy(beforeRouteNodes, [
-      (d) => d.routePath === "/" ? -1 : 1,
-      (d) => d.routePath?.split("/").length,
-      (d) => d.filePath.match(this.indexTokenFilenameRegex) ? 1 : -1,
-      (d) => d.filePath.match(_Generator.componentPieceRegex) ? 1 : -1,
-      (d) => d.filePath.match(this.routeTokenFilenameRegex) ? -1 : 1,
-      (d) => d.routePath?.endsWith("/") ? -1 : 1,
-      (d) => d.routePath
-    ]).filter((d) => {
-      if (d.routePath === `/${rootPathId.rootPathId}`) {
-        return [
-          "component",
-          "errorComponent",
-          "notFoundComponent",
-          "pendingComponent",
-          "loader",
-          "lazy"
-        ].includes(d._fsRouteType);
-      }
-      return true;
-    });
-    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) {
-        if (result.value.shouldWriteTree) {
-          writeRouteTreeFile = true;
-        }
-        return result.value.node;
-      }
-      return [];
-    });
-    routeFileResult.forEach((r) => r.children = void 0);
-    const acc = {
-      routeTree: [],
-      routeNodes: [],
-      routePiecesByPath: {},
-      routeNodesByPath: /* @__PURE__ */ new Map()
-    };
-    const prefixMap = new utils.RoutePrefixMap(routeFileResult);
-    for (const node of routeFileResult) {
-      _Generator.handleNode(node, acc, prefixMap, this.config);
-    }
-    this.crawlingResult = { rootRouteNode, routeFileResult, acc };
-    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;
-    } else {
-      const routeTreeFileChange = await this.didFileChangeComparedToCache(
-        { path: this.generatedRouteTreePath },
-        this.routeTreeFileCache
-      );
-      if (routeTreeFileChange.result !== false) {
-        writeRouteTreeFile = "force";
-        if (routeTreeFileChange.result === true) {
-          const routeTreeFile = await this.fs.readFile(
-            this.generatedRouteTreePath
-          );
-          if (routeTreeFile !== "file-not-existing") {
-            this.routeTreeFileCache = {
-              fileContent: routeTreeFile.fileContent,
-              mtimeMs: routeTreeFile.stat.mtimeMs
-            };
-          }
-        }
-      }
-    }
-    if (!writeRouteTreeFile) {
-      if (this.routeNodeCache.size !== this.routeNodeShadowCache.size) {
-        writeRouteTreeFile = true;
-      } else {
-        for (const fullPath of this.routeNodeCache.keys()) {
-          if (!this.routeNodeShadowCache.has(fullPath)) {
-            writeRouteTreeFile = true;
-            break;
-          }
-        }
-      }
-    }
-    if (!writeRouteTreeFile) {
-      this.swapCaches();
-      return;
-    }
-    const buildResult = this.buildRouteTree({
-      rootRouteNode,
-      acc,
-      routeFileResult
-    });
-    let routeTreeContent = buildResult.routeTreeContent;
-    routeTreeContent = this.config.enableRouteTreeFormatting ? await utils.format(routeTreeContent, this.config) : routeTreeContent;
-    let newMtimeMs;
-    if (this.routeTreeFileCache) {
-      if (writeRouteTreeFile !== "force" && 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.plugins.map((plugin) => {
-      return plugin.onRouteTreeChanged?.({
-        routeTree: buildResult.routeTree,
-        routeNodes: buildResult.routeNodes,
-        acc,
-        rootRouteNode
-      });
-    });
-    this.swapCaches();
-  }
-  swapCaches() {
-    this.routeNodeCache = this.routeNodeShadowCache;
-    this.routeNodeShadowCache = /* @__PURE__ */ new Map();
-  }
-  buildRouteTree(opts) {
-    const config = { ...this.config, ...opts.config || {} };
-    const { rootRouteNode, acc } = opts;
-    const indexTokenSegmentRegex = config.indexToken === this.config.indexToken ? this.indexTokenSegmentRegex : utils.createTokenRegex(config.indexToken, { type: "segment" });
-    const sortedRouteNodes = utils.multiSortBy(acc.routeNodes, [
-      (d) => d.routePath?.includes(`/${rootPathId.rootPathId}`) ? -1 : 1,
-      (d) => d.routePath?.split("/").length,
-      (d) => {
-        const segments = d.routePath?.split("/").filter(Boolean) ?? [];
-        const last = segments[segments.length - 1] ?? "";
-        return indexTokenSegmentRegex.test(last) ? -1 : 1;
-      },
-      (d) => d
-    ]);
-    const routeImports = [];
-    const virtualRouteNodes = [];
-    for (const node of sortedRouteNodes) {
-      if (node.isVirtual) {
-        virtualRouteNodes.push(
-          `const ${node.variableName}RouteImport = createFileRoute('${node.routePath}')()`
-        );
-      } else {
-        routeImports.push(
-          utils.getImportForRouteNode(
-            node,
-            config,
-            this.generatedRouteTreePath,
-            this.root
-          )
-        );
-      }
-    }
-    const imports = [];
-    if (virtualRouteNodes.length > 0) {
-      imports.push({
-        specifiers: [{ imported: "createFileRoute" }],
-        source: this.targetTemplate.fullPkg
-      });
-    }
-    let hasComponentPieces = false;
-    let hasLoaderPieces = false;
-    for (const node of sortedRouteNodes) {
-      const pieces = acc.routePiecesByPath[node.routePath];
-      if (pieces) {
-        if (pieces.component || pieces.errorComponent || pieces.notFoundComponent || pieces.pendingComponent) {
-          hasComponentPieces = true;
-        }
-        if (pieces.loader) {
-          hasLoaderPieces = true;
-        }
-        if (hasComponentPieces && hasLoaderPieces) break;
-      }
-    }
-    if (hasComponentPieces || hasLoaderPieces) {
-      const runtimeImport = {
-        specifiers: [],
-        source: this.targetTemplate.fullPkg
-      };
-      if (hasComponentPieces) {
-        runtimeImport.specifiers.push({ imported: "lazyRouteComponent" });
-      }
-      if (hasLoaderPieces) {
-        runtimeImport.specifiers.push({ imported: "lazyFn" });
-      }
-      imports.push(runtimeImport);
-    }
-    if (config.verboseFileRoutes === false) {
-      const typeImport = {
-        specifiers: [],
-        source: this.targetTemplate.fullPkg,
-        importKind: "type"
-      };
-      let needsCreateFileRoute = false;
-      let needsCreateLazyFileRoute = false;
-      for (const node of sortedRouteNodes) {
-        if (utils.isRouteNodeValidForAugmentation(node)) {
-          if (node._fsRouteType !== "lazy") {
-            needsCreateFileRoute = true;
-          }
-          if (acc.routePiecesByPath[node.routePath]?.lazy) {
-            needsCreateLazyFileRoute = true;
-          }
-        }
-        if (needsCreateFileRoute && needsCreateLazyFileRoute) break;
-      }
-      if (needsCreateFileRoute) {
-        typeImport.specifiers.push({ imported: "CreateFileRoute" });
-      }
-      if (needsCreateLazyFileRoute) {
-        typeImport.specifiers.push({ imported: "CreateLazyFileRoute" });
-      }
-      if (typeImport.specifiers.length > 0) {
-        typeImport.specifiers.push({ imported: "FileRoutesByPath" });
-        imports.push(typeImport);
-      }
-    }
-    const routeTreeConfig = utils.buildRouteTreeConfig(
-      acc.routeTree,
-      config.disableTypes
-    );
-    const createUpdateRoutes = sortedRouteNodes.map((node) => {
-      const pieces = acc.routePiecesByPath[node.routePath];
-      const loaderNode = pieces?.loader;
-      const componentNode = pieces?.component;
-      const errorComponentNode = pieces?.errorComponent;
-      const notFoundComponentNode = pieces?.notFoundComponent;
-      const pendingComponentNode = pieces?.pendingComponent;
-      const lazyComponentNode = pieces?.lazy;
-      return [
-        [
-          `const ${node.variableName}Route = ${node.variableName}RouteImport.update({
+var Generator = class Generator {
+	static {
+		this.routeGroupPatternRegex = /\(.+\)/;
+	}
+	static {
+		this.componentPieceRegex = /[./](component|errorComponent|notFoundComponent|pendingComponent|loader|lazy)[.]/;
+	}
+	constructor(opts) {
+		this.routeNodeCache = /* @__PURE__ */ new Map();
+		this.routeNodeShadowCache = /* @__PURE__ */ new Map();
+		this.fileEventQueue = [];
+		this.plugins = [];
+		this.physicalDirectories = [];
+		this.config = opts.config;
+		this.logger = require_logger.logging({ disabled: this.config.disableLogging });
+		this.root = opts.root;
+		this.fs = opts.fs || DefaultFileSystem;
+		this.generatedRouteTreePath = this.getGeneratedRouteTreePath();
+		this.targetTemplate = require_template.getTargetTemplate(this.config);
+		this.routesDirectoryPath = this.getRoutesDirectoryPath();
+		this.plugins.push(...opts.config.plugins || []);
+		this.indexTokenFilenameRegex = require_utils.createTokenRegex(this.config.indexToken, { type: "filename" });
+		this.routeTokenFilenameRegex = require_utils.createTokenRegex(this.config.routeToken, { type: "filename" });
+		this.indexTokenSegmentRegex = require_utils.createTokenRegex(this.config.indexToken, { type: "segment" });
+		this.routeTokenSegmentRegex = require_utils.createTokenRegex(this.config.routeToken, { type: "segment" });
+		for (const plugin of this.plugins) plugin.init?.({ generator: this });
+	}
+	getGeneratedRouteTreePath() {
+		const generatedRouteTreePath = node_path.default.isAbsolute(this.config.generatedRouteTree) ? this.config.generatedRouteTree : node_path.default.resolve(this.root, this.config.generatedRouteTree);
+		const generatedRouteTreeDir = node_path.default.dirname(generatedRouteTreePath);
+		if (!(0, node_fs.existsSync)(generatedRouteTreeDir)) (0, node_fs.mkdirSync)(generatedRouteTreeDir, { recursive: true });
+		return generatedRouteTreePath;
+	}
+	getRoutesDirectoryPath() {
+		return node_path.default.isAbsolute(this.config.routesDirectory) ? this.config.routesDirectory : node_path.default.resolve(this.root, this.config.routesDirectory);
+	}
+	getRoutesByFileMap() {
+		return new Map([...this.routeNodeCache.entries()].map(([filePath, cacheEntry]) => [filePath, { routePath: cacheEntry.routeId }]));
+	}
+	async run(event) {
+		if (event && event.type !== "rerun" && !this.isFileRelevantForRouteTreeGeneration(event.path)) return;
+		this.fileEventQueue.push(event ?? { type: "rerun" });
+		if (this.runPromise) return this.runPromise;
+		this.runPromise = (async () => {
+			do {
+				const tempQueue = this.fileEventQueue;
+				this.fileEventQueue = [];
+				if ((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);
+						if ((await this.didFileChangeComparedToCache({ path: e.path }, cacheEntry)).result === false) return null;
+					}
+					return e;
+				}))).filter((e) => e !== null).length === 0) break;
+				try {
+					await this.generatorInternal();
+				} 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 require_getRouteNodes.getRouteNodes(this.config, this.root, {
+			indexTokenSegmentRegex: this.indexTokenSegmentRegex,
+			routeTokenSegmentRegex: this.routeTokenSegmentRegex
+		});
+		else getRouteNodesResult = await require_getRouteNodes$1.getRouteNodes(this.config, this.root, {
+			indexTokenSegmentRegex: this.indexTokenSegmentRegex,
+			routeTokenSegmentRegex: this.routeTokenSegmentRegex
+		});
+		const { rootRouteNode, routeNodes: beforeRouteNodes, physicalDirectories } = 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 += `\nMake sure that you add a "${require_rootPathId.rootPathId}.${this.config.disableTypes ? "js" : "tsx"}" file to your routes directory.\nAdd the file in: "${this.config.routesDirectory}/${require_rootPathId.rootPathId}.${this.config.disableTypes ? "js" : "tsx"}"`;
+			throw new Error(errorMessage);
+		}
+		this.physicalDirectories = physicalDirectories;
+		await this.handleRootNode(rootRouteNode);
+		const preRouteNodes = require_utils.multiSortBy(beforeRouteNodes, [
+			(d) => d.routePath === "/" ? -1 : 1,
+			(d) => d.routePath?.split("/").length,
+			(d) => d.filePath.match(this.indexTokenFilenameRegex) ? 1 : -1,
+			(d) => d.filePath.match(Generator.componentPieceRegex) ? 1 : -1,
+			(d) => d.filePath.match(this.routeTokenFilenameRegex) ? -1 : 1,
+			(d) => d.routePath?.endsWith("/") ? -1 : 1,
+			(d) => d.routePath
+		]).filter((d) => {
+			if (d.routePath === `/__root`) return [
+				"component",
+				"errorComponent",
+				"notFoundComponent",
+				"pendingComponent",
+				"loader",
+				"lazy"
+			].includes(d._fsRouteType);
+			return true;
+		});
+		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) {
+				if (result.value.shouldWriteTree) writeRouteTreeFile = true;
+				return result.value.node;
+			}
+			return [];
+		});
+		routeFileResult.forEach((r) => r.children = void 0);
+		const acc = {
+			routeTree: [],
+			routeNodes: [],
+			routePiecesByPath: {},
+			routeNodesByPath: /* @__PURE__ */ new Map()
+		};
+		const prefixMap = new require_utils.RoutePrefixMap(routeFileResult);
+		for (const node of routeFileResult) Generator.handleNode(node, acc, prefixMap, this.config);
+		this.crawlingResult = {
+			rootRouteNode,
+			routeFileResult,
+			acc
+		};
+		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;
+		} else {
+			const routeTreeFileChange = await this.didFileChangeComparedToCache({ path: this.generatedRouteTreePath }, this.routeTreeFileCache);
+			if (routeTreeFileChange.result !== false) {
+				writeRouteTreeFile = "force";
+				if (routeTreeFileChange.result === true) {
+					const routeTreeFile = await this.fs.readFile(this.generatedRouteTreePath);
+					if (routeTreeFile !== "file-not-existing") this.routeTreeFileCache = {
+						fileContent: routeTreeFile.fileContent,
+						mtimeMs: routeTreeFile.stat.mtimeMs
+					};
+				}
+			}
+		}
+		if (!writeRouteTreeFile) {
+			if (this.routeNodeCache.size !== this.routeNodeShadowCache.size) writeRouteTreeFile = true;
+			else for (const fullPath of this.routeNodeCache.keys()) if (!this.routeNodeShadowCache.has(fullPath)) {
+				writeRouteTreeFile = true;
+				break;
+			}
+		}
+		if (!writeRouteTreeFile) {
+			this.swapCaches();
+			return;
+		}
+		const buildResult = this.buildRouteTree({
+			rootRouteNode,
+			acc,
+			routeFileResult
+		});
+		let routeTreeContent = buildResult.routeTreeContent;
+		routeTreeContent = this.config.enableRouteTreeFormatting ? await require_utils.format(routeTreeContent, this.config) : routeTreeContent;
+		let newMtimeMs;
+		if (this.routeTreeFileCache) if (writeRouteTreeFile !== "force" && this.routeTreeFileCache.fileContent === routeTreeContent) {} else newMtimeMs = (await this.safeFileWrite({
+			filePath: this.generatedRouteTreePath,
+			newContent: routeTreeContent,
+			strategy: {
+				type: "mtime",
+				expectedMtimeMs: this.routeTreeFileCache.mtimeMs
+			}
+		})).mtimeMs;
+		else newMtimeMs = (await this.safeFileWrite({
+			filePath: this.generatedRouteTreePath,
+			newContent: routeTreeContent,
+			strategy: { type: "new-file" }
+		})).mtimeMs;
+		if (newMtimeMs !== void 0) this.routeTreeFileCache = {
+			fileContent: routeTreeContent,
+			mtimeMs: newMtimeMs
+		};
+		this.plugins.map((plugin) => {
+			return plugin.onRouteTreeChanged?.({
+				routeTree: buildResult.routeTree,
+				routeNodes: buildResult.routeNodes,
+				acc,
+				rootRouteNode
+			});
+		});
+		this.swapCaches();
+	}
+	swapCaches() {
+		this.routeNodeCache = this.routeNodeShadowCache;
+		this.routeNodeShadowCache = /* @__PURE__ */ new Map();
+	}
+	buildRouteTree(opts) {
+		const config = {
+			...this.config,
+			...opts.config || {}
+		};
+		const { rootRouteNode, acc } = opts;
+		const indexTokenSegmentRegex = config.indexToken === this.config.indexToken ? this.indexTokenSegmentRegex : require_utils.createTokenRegex(config.indexToken, { type: "segment" });
+		const sortedRouteNodes = require_utils.multiSortBy(acc.routeNodes, [
+			(d) => d.routePath?.includes(`/__root`) ? -1 : 1,
+			(d) => d.routePath?.split("/").length,
+			(d) => {
+				const segments = d.routePath?.split("/").filter(Boolean) ?? [];
+				const last = segments[segments.length - 1] ?? "";
+				return indexTokenSegmentRegex.test(last) ? -1 : 1;
+			},
+			(d) => d
+		]);
+		const routeImports = [];
+		const virtualRouteNodes = [];
+		for (const node of sortedRouteNodes) if (node.isVirtual) virtualRouteNodes.push(`const ${node.variableName}RouteImport = createFileRoute('${node.routePath}')()`);
+		else routeImports.push(require_utils.getImportForRouteNode(node, config, this.generatedRouteTreePath, this.root));
+		const imports = [];
+		if (virtualRouteNodes.length > 0) imports.push({
+			specifiers: [{ imported: "createFileRoute" }],
+			source: this.targetTemplate.fullPkg
+		});
+		let hasComponentPieces = false;
+		let hasLoaderPieces = false;
+		for (const node of sortedRouteNodes) {
+			const pieces = acc.routePiecesByPath[node.routePath];
+			if (pieces) {
+				if (pieces.component || pieces.errorComponent || pieces.notFoundComponent || pieces.pendingComponent) hasComponentPieces = true;
+				if (pieces.loader) hasLoaderPieces = true;
+				if (hasComponentPieces && hasLoaderPieces) break;
+			}
+		}
+		if (hasComponentPieces || hasLoaderPieces) {
+			const runtimeImport = {
+				specifiers: [],
+				source: this.targetTemplate.fullPkg
+			};
+			if (hasComponentPieces) runtimeImport.specifiers.push({ imported: "lazyRouteComponent" });
+			if (hasLoaderPieces) runtimeImport.specifiers.push({ imported: "lazyFn" });
+			imports.push(runtimeImport);
+		}
+		if (config.verboseFileRoutes === false) {
+			const typeImport = {
+				specifiers: [],
+				source: this.targetTemplate.fullPkg,
+				importKind: "type"
+			};
+			let needsCreateFileRoute = false;
+			let needsCreateLazyFileRoute = false;
+			for (const node of sortedRouteNodes) {
+				if (require_utils.isRouteNodeValidForAugmentation(node)) {
+					if (node._fsRouteType !== "lazy") needsCreateFileRoute = true;
+					if (acc.routePiecesByPath[node.routePath]?.lazy) needsCreateLazyFileRoute = true;
+				}
+				if (needsCreateFileRoute && needsCreateLazyFileRoute) break;
+			}
+			if (needsCreateFileRoute) typeImport.specifiers.push({ imported: "CreateFileRoute" });
+			if (needsCreateLazyFileRoute) typeImport.specifiers.push({ imported: "CreateLazyFileRoute" });
+			if (typeImport.specifiers.length > 0) {
+				typeImport.specifiers.push({ imported: "FileRoutesByPath" });
+				imports.push(typeImport);
+			}
+		}
+		const routeTreeConfig = require_utils.buildRouteTreeConfig(acc.routeTree, config.disableTypes);
+		const createUpdateRoutes = sortedRouteNodes.map((node) => {
+			const pieces = acc.routePiecesByPath[node.routePath];
+			const loaderNode = pieces?.loader;
+			const componentNode = pieces?.component;
+			const errorComponentNode = pieces?.errorComponent;
+			const notFoundComponentNode = pieces?.notFoundComponent;
+			const pendingComponentNode = pieces?.pendingComponent;
+			const lazyComponentNode = pieces?.lazy;
+			return [[
+				`const ${node.variableName}Route = ${node.variableName}RouteImport.update({
             ${[
-            `id: '${node.path}'`,
-            !node.isNonPath || node._fsRouteType === "pathless_layout" && node.cleanedPath ? `path: '${node.cleanedPath}'` : void 0,
-            `getParentRoute: () => ${utils.findParent(node)}`
-          ].filter(Boolean).join(",")}
+					`id: '${node.path}'`,
+					!node.isNonPath || node._fsRouteType === "pathless_layout" && node.cleanedPath ? `path: '${node.cleanedPath}'` : void 0,
+					`getParentRoute: () => ${require_utils.findParent(node)}`
+				].filter(Boolean).join(",")}
           }${config.disableTypes ? "" : "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 || notFoundComponentNode || pendingComponentNode ? `.update({
+				loaderNode ? `.updateLoader({ loader: lazyFn(() => import('./${require_utils.replaceBackslash(require_utils.removeExt(node_path.default.relative(node_path.default.dirname(config.generatedRouteTree), node_path.default.resolve(config.routesDirectory, loaderNode.filePath)), config.addExtensions))}'), 'loader') })` : "",
+				componentNode || errorComponentNode || notFoundComponentNode || pendingComponentNode ? `.update({
                 ${[
-            ["component", componentNode],
-            ["errorComponent", errorComponentNode],
-            ["notFoundComponent", notFoundComponentNode],
-            ["pendingComponent", pendingComponentNode]
-          ].filter((d) => d[1]).map((d) => {
-            const isVueFile = d[1].filePath.endsWith(".vue");
-            const exportName = isVueFile ? "default" : d[0];
-            const importPath = utils.replaceBackslash(
-              isVueFile ? path.relative(
-                path.dirname(config.generatedRouteTree),
-                path.resolve(
-                  config.routesDirectory,
-                  d[1].filePath
-                )
-              ) : utils.removeExt(
-                path.relative(
-                  path.dirname(config.generatedRouteTree),
-                  path.resolve(
-                    config.routesDirectory,
-                    d[1].filePath
-                  )
-                ),
-                config.addExtensions
-              )
-            );
-            return `${d[0]}: lazyRouteComponent(() => import('./${importPath}'), '${exportName}')`;
-          }).join("\n,")}
+					["component", componentNode],
+					["errorComponent", errorComponentNode],
+					["notFoundComponent", notFoundComponentNode],
+					["pendingComponent", pendingComponentNode]
+				].filter((d) => d[1]).map((d) => {
+					const isVueFile = d[1].filePath.endsWith(".vue");
+					const exportName = isVueFile ? "default" : d[0];
+					const importPath = require_utils.replaceBackslash(isVueFile ? node_path.default.relative(node_path.default.dirname(config.generatedRouteTree), node_path.default.resolve(config.routesDirectory, d[1].filePath)) : require_utils.removeExt(node_path.default.relative(node_path.default.dirname(config.generatedRouteTree), node_path.default.resolve(config.routesDirectory, d[1].filePath)), config.addExtensions));
+					return `${d[0]}: lazyRouteComponent(() => import('./${importPath}'), '${exportName}')`;
+				}).join("\n,")}
               })` : "",
-          lazyComponentNode ? (() => {
-            const isVueFile = lazyComponentNode.filePath.endsWith(".vue");
-            const exportAccessor = isVueFile ? "d.default" : "d.Route";
-            const importPath = utils.replaceBackslash(
-              isVueFile ? path.relative(
-                path.dirname(config.generatedRouteTree),
-                path.resolve(
-                  config.routesDirectory,
-                  lazyComponentNode.filePath
-                )
-              ) : utils.removeExt(
-                path.relative(
-                  path.dirname(config.generatedRouteTree),
-                  path.resolve(
-                    config.routesDirectory,
-                    lazyComponentNode.filePath
-                  )
-                ),
-                config.addExtensions
-              )
-            );
-            return `.lazy(() => import('./${importPath}').then((d) => ${exportAccessor}))`;
-          })() : ""
-        ].join("")
-      ].join("\n\n");
-    });
-    const rootRoutePath = `/${rootPathId.rootPathId}`;
-    const rootPieces = acc.routePiecesByPath[rootRoutePath];
-    const rootComponentNode = rootPieces?.component;
-    const rootErrorComponentNode = rootPieces?.errorComponent;
-    const rootNotFoundComponentNode = rootPieces?.notFoundComponent;
-    const rootPendingComponentNode = rootPieces?.pendingComponent;
-    let rootRouteUpdate = "";
-    if (rootComponentNode || rootErrorComponentNode || rootNotFoundComponentNode || rootPendingComponentNode) {
-      rootRouteUpdate = `const rootRouteWithChildren = rootRouteImport${rootComponentNode || rootErrorComponentNode || rootNotFoundComponentNode || rootPendingComponentNode ? `.update({
+				lazyComponentNode ? (() => {
+					const isVueFile = lazyComponentNode.filePath.endsWith(".vue");
+					const exportAccessor = isVueFile ? "d.default" : "d.Route";
+					return `.lazy(() => import('./${require_utils.replaceBackslash(isVueFile ? node_path.default.relative(node_path.default.dirname(config.generatedRouteTree), node_path.default.resolve(config.routesDirectory, lazyComponentNode.filePath)) : require_utils.removeExt(node_path.default.relative(node_path.default.dirname(config.generatedRouteTree), node_path.default.resolve(config.routesDirectory, lazyComponentNode.filePath)), config.addExtensions))}').then((d) => ${exportAccessor}))`;
+				})() : ""
+			].join("")].join("\n\n");
+		});
+		const rootRoutePath = `/${require_rootPathId.rootPathId}`;
+		const rootPieces = acc.routePiecesByPath[rootRoutePath];
+		const rootComponentNode = rootPieces?.component;
+		const rootErrorComponentNode = rootPieces?.errorComponent;
+		const rootNotFoundComponentNode = rootPieces?.notFoundComponent;
+		const rootPendingComponentNode = rootPieces?.pendingComponent;
+		let rootRouteUpdate = "";
+		if (rootComponentNode || rootErrorComponentNode || rootNotFoundComponentNode || rootPendingComponentNode) rootRouteUpdate = `const rootRouteWithChildren = rootRouteImport${rootComponentNode || rootErrorComponentNode || rootNotFoundComponentNode || rootPendingComponentNode ? `.update({
               ${[
-        ["component", rootComponentNode],
-        ["errorComponent", rootErrorComponentNode],
-        ["notFoundComponent", rootNotFoundComponentNode],
-        ["pendingComponent", rootPendingComponentNode]
-      ].filter((d) => d[1]).map((d) => {
-        const isVueFile = d[1].filePath.endsWith(".vue");
-        const exportName = isVueFile ? "default" : d[0];
-        const importPath = utils.replaceBackslash(
-          isVueFile ? path.relative(
-            path.dirname(config.generatedRouteTree),
-            path.resolve(config.routesDirectory, d[1].filePath)
-          ) : utils.removeExt(
-            path.relative(
-              path.dirname(config.generatedRouteTree),
-              path.resolve(
-                config.routesDirectory,
-                d[1].filePath
-              )
-            ),
-            config.addExtensions
-          )
-        );
-        return `${d[0]}: lazyRouteComponent(() => import('./${importPath}'), '${exportName}')`;
-      }).join("\n,")}
+			["component", rootComponentNode],
+			["errorComponent", rootErrorComponentNode],
+			["notFoundComponent", rootNotFoundComponentNode],
+			["pendingComponent", rootPendingComponentNode]
+		].filter((d) => d[1]).map((d) => {
+			const isVueFile = d[1].filePath.endsWith(".vue");
+			const exportName = isVueFile ? "default" : d[0];
+			const importPath = require_utils.replaceBackslash(isVueFile ? node_path.default.relative(node_path.default.dirname(config.generatedRouteTree), node_path.default.resolve(config.routesDirectory, d[1].filePath)) : require_utils.removeExt(node_path.default.relative(node_path.default.dirname(config.generatedRouteTree), node_path.default.resolve(config.routesDirectory, d[1].filePath)), config.addExtensions));
+			return `${d[0]}: lazyRouteComponent(() => import('./${importPath}'), '${exportName}')`;
+		}).join("\n,")}
             })` : ""}._addFileChildren(rootRouteChildren)${config.disableTypes ? "" : `._addFileTypes<FileRouteTypes>()`}`;
-    }
-    let fileRoutesByPathInterface = "";
-    let fileRoutesByFullPath = "";
-    if (!config.disableTypes) {
-      const routeNodesByFullPath = utils.createRouteNodesByFullPath(acc.routeNodes);
-      const routeNodesByTo = utils.createRouteNodesByTo(acc.routeNodes);
-      const routeNodesById = utils.createRouteNodesById(acc.routeNodes);
-      fileRoutesByFullPath = [
-        `export interface FileRoutesByFullPath {
+		let fileRoutesByPathInterface = "";
+		let fileRoutesByFullPath = "";
+		if (!config.disableTypes) {
+			const routeNodesByFullPath = require_utils.createRouteNodesByFullPath(acc.routeNodes);
+			const routeNodesByTo = require_utils.createRouteNodesByTo(acc.routeNodes);
+			const routeNodesById = require_utils.createRouteNodesById(acc.routeNodes);
+			fileRoutesByFullPath = [
+				`export interface FileRoutesByFullPath {
 ${[...routeNodesByFullPath.entries()].filter(([fullPath]) => fullPath).map(([fullPath, routeNode]) => {
-          return `'${fullPath}': typeof ${utils.getResolvedRouteNodeVariableName(routeNode)}`;
-        })}
+					return `'${fullPath}': typeof ${require_utils.getResolvedRouteNodeVariableName(routeNode)}`;
+				})}
 }`,
-        `export interface FileRoutesByTo {
+				`export interface FileRoutesByTo {
 ${[...routeNodesByTo.entries()].filter(([to]) => to).map(([to, routeNode]) => {
-          return `'${to}': typeof ${utils.getResolvedRouteNodeVariableName(routeNode)}`;
-        })}
+					return `'${to}': typeof ${require_utils.getResolvedRouteNodeVariableName(routeNode)}`;
+				})}
 }`,
-        `export interface FileRoutesById {
-'${routerCore.rootRouteId}': typeof rootRouteImport,
+				`export interface FileRoutesById {
+'${_tanstack_router_core.rootRouteId}': typeof rootRouteImport,
 ${[...routeNodesById.entries()].map(([id, routeNode]) => {
-          return `'${id}': typeof ${utils.getResolvedRouteNodeVariableName(routeNode)}`;
-        })}
+					return `'${id}': typeof ${require_utils.getResolvedRouteNodeVariableName(routeNode)}`;
+				})}
 }`,
-        `export interface FileRouteTypes {
+				`export interface FileRouteTypes {
 fileRoutesByFullPath: FileRoutesByFullPath
 fullPaths: ${acc.routeNodes.length > 0 ? [...routeNodesByFullPath.keys()].filter((fullPath) => fullPath).map((fullPath) => `'${fullPath}'`).join("|") : "never"}
 fileRoutesByTo: FileRoutesByTo
 to: ${acc.routeNodes.length > 0 ? [...routeNodesByTo.keys()].filter((to) => to).map((to) => `'${to}'`).join("|") : "never"}
-id: ${[`'${routerCore.rootRouteId}'`, ...[...routeNodesById.keys()].map((id) => `'${id}'`)].join("|")}
+id: ${[`'${_tanstack_router_core.rootRouteId}'`, ...[...routeNodesById.keys()].map((id) => `'${id}'`)].join("|")}
 fileRoutesById: FileRoutesById
 }`,
-        `export interface RootRouteChildren {
-${acc.routeTree.map((child) => `${child.variableName}Route: typeof ${utils.getResolvedRouteNodeVariableName(child)}`).join(",")}
+				`export interface RootRouteChildren {
+${acc.routeTree.map((child) => `${child.variableName}Route: typeof ${require_utils.getResolvedRouteNodeVariableName(child)}`).join(",")}
 }`
-      ].join("\n");
-      fileRoutesByPathInterface = utils.buildFileRoutesByPathInterface({
-        module: this.targetTemplate.fullPkg,
-        interfaceName: "FileRoutesByPath",
-        routeNodes: sortedRouteNodes
-      });
-    }
-    const routeTree = [
-      `const rootRouteChildren${config.disableTypes ? "" : `: RootRouteChildren`} = {
-  ${acc.routeTree.map(
-        (child) => `${child.variableName}Route: ${utils.getResolvedRouteNodeVariableName(child)}`
-      ).join(",")}
-}`,
-      rootRouteUpdate ? rootRouteUpdate.replace(
-        "const rootRouteWithChildren = ",
-        "export const routeTree = "
-      ) : `export const routeTree = rootRouteImport._addFileChildren(rootRouteChildren)${config.disableTypes ? "" : `._addFileTypes<FileRouteTypes>()`}`
-    ].join("\n");
-    utils.checkRouteFullPathUniqueness(
-      sortedRouteNodes.filter(
-        (d) => d.children === void 0 && "lazy" !== d._fsRouteType
-      ),
-      config
-    );
-    let mergedImports = utils.mergeImportDeclarations(imports);
-    if (config.disableTypes) {
-      mergedImports = mergedImports.filter((d) => d.importKind !== "type");
-    }
-    const importStatements = mergedImports.map(utils.buildImportString);
-    let moduleAugmentation = "";
-    if (config.verboseFileRoutes === false && !config.disableTypes) {
-      moduleAugmentation = opts.routeFileResult.map((node) => {
-        const getModuleDeclaration = (routeNode) => {
-          if (!utils.isRouteNodeValidForAugmentation(routeNode)) {
-            return "";
-          }
-          let moduleAugmentation2 = "";
-          if (routeNode._fsRouteType === "lazy") {
-            moduleAugmentation2 = `const createLazyFileRoute: CreateLazyFileRoute<FileRoutesByPath['${routeNode.routePath}']['preLoaderRoute']>`;
-          } else {
-            moduleAugmentation2 = `const createFileRoute: CreateFileRoute<'${routeNode.routePath}',
+			].join("\n");
+			fileRoutesByPathInterface = require_utils.buildFileRoutesByPathInterface({
+				module: this.targetTemplate.fullPkg,
+				interfaceName: "FileRoutesByPath",
+				routeNodes: sortedRouteNodes,
+				config
+			});
+		}
+		const routeTree = [`const rootRouteChildren${config.disableTypes ? "" : `: RootRouteChildren`} = {
+  ${acc.routeTree.map((child) => `${child.variableName}Route: ${require_utils.getResolvedRouteNodeVariableName(child)}`).join(",")}
+}`, rootRouteUpdate ? rootRouteUpdate.replace("const rootRouteWithChildren = ", "export const routeTree = ") : `export const routeTree = rootRouteImport._addFileChildren(rootRouteChildren)${config.disableTypes ? "" : `._addFileTypes<FileRouteTypes>()`}`].join("\n");
+		require_utils.checkRouteFullPathUniqueness(sortedRouteNodes.filter((d) => d.children === void 0 && "lazy" !== d._fsRouteType), config);
+		let mergedImports = require_utils.mergeImportDeclarations(imports);
+		if (config.disableTypes) mergedImports = mergedImports.filter((d) => d.importKind !== "type");
+		const importStatements = mergedImports.map(require_utils.buildImportString);
+		let moduleAugmentation = "";
+		if (config.verboseFileRoutes === false && !config.disableTypes) moduleAugmentation = opts.routeFileResult.map((node) => {
+			const getModuleDeclaration = (routeNode) => {
+				if (!require_utils.isRouteNodeValidForAugmentation(routeNode)) return "";
+				let moduleAugmentation = "";
+				if (routeNode._fsRouteType === "lazy") moduleAugmentation = `const createLazyFileRoute: CreateLazyFileRoute<FileRoutesByPath['${routeNode.routePath}']['preLoaderRoute']>`;
+				else moduleAugmentation = `const createFileRoute: CreateFileRoute<'${routeNode.routePath}',
                   FileRoutesByPath['${routeNode.routePath}']['parentRoute'],
                   FileRoutesByPath['${routeNode.routePath}']['id'],
                   FileRoutesByPath['${routeNode.routePath}']['path'],
                   FileRoutesByPath['${routeNode.routePath}']['fullPath']
                 >
               `;
-          }
-          return `declare module './${utils.getImportPath(routeNode, config, this.generatedRouteTreePath)}' {
-                      ${moduleAugmentation2}
+				return `declare module './${require_utils.getImportPath(routeNode, config, this.generatedRouteTreePath)}' {
+                      ${moduleAugmentation}
                     }`;
-        };
-        return getModuleDeclaration(node);
-      }).join("\n");
-    }
-    const rootRouteImport = utils.getImportForRouteNode(
-      rootRouteNode,
-      config,
-      this.generatedRouteTreePath,
-      this.root
-    );
-    routeImports.unshift(rootRouteImport);
-    let footer = [];
-    if (config.routeTreeFileFooter) {
-      if (Array.isArray(config.routeTreeFileFooter)) {
-        footer = config.routeTreeFileFooter;
-      } else {
-        footer = config.routeTreeFileFooter();
-      }
-    }
-    const routeTreeContent = [
-      ...config.routeTreeFileHeader,
-      `// This file was automatically generated by TanStack Router.
+			};
+			return getModuleDeclaration(node);
+		}).join("\n");
+		const rootRouteImport = require_utils.getImportForRouteNode(rootRouteNode, config, this.generatedRouteTreePath, this.root);
+		routeImports.unshift(rootRouteImport);
+		let footer = [];
+		if (config.routeTreeFileFooter) if (Array.isArray(config.routeTreeFileFooter)) footer = config.routeTreeFileFooter;
+		else footer = config.routeTreeFileFooter();
+		return {
+			routeTreeContent: [
+				...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"),
-      virtualRouteNodes.join("\n"),
-      createUpdateRoutes.join("\n"),
-      fileRoutesByFullPath,
-      fileRoutesByPathInterface,
-      moduleAugmentation,
-      routeTreeConfig.join("\n"),
-      routeTree,
-      ...footer
-    ].filter(Boolean).join("\n\n");
-    return {
-      routeTreeContent,
-      routeTree: acc.routeTree,
-      routeNodes: acc.routeNodes
-    };
-  }
-  async processRouteNodeFile(node) {
-    const result = await this.isRouteFileCacheFresh(node);
-    if (result.status === "fresh") {
-      return {
-        node: result.cacheEntry.node,
-        shouldWriteTree: false,
-        cacheEntry: result.cacheEntry
-      };
-    }
-    const previousCacheEntry = result.cacheEntry;
-    const existingRouteFile = await this.fs.readFile(node.fullPath);
-    if (existingRouteFile === "file-not-existing") {
-      throw new Error(`⚠️ File ${node.fullPath} does not exist`);
-    }
-    if (node.routePath) {
-      validateRouteParams.validateRouteParams(node.routePath, node.filePath, this.logger);
-    }
-    const updatedCacheEntry = {
-      fileContent: existingRouteFile.fileContent,
-      mtimeMs: existingRouteFile.stat.mtimeMs,
-      routeId: node.routePath ?? "$$TSR_NO_ROUTE_PATH_ASSIGNED$$",
-      node
-    };
-    const escapedRoutePath = node.routePath?.replaceAll("$", "$$") ?? "";
-    let shouldWriteRouteFile = false;
-    let shouldWriteTree = false;
-    if (!existingRouteFile.fileContent) {
-      shouldWriteRouteFile = true;
-      shouldWriteTree = true;
-      if (node._fsRouteType === "lazy") {
-        const tLazyRouteTemplate = this.targetTemplate.lazyRoute;
-        updatedCacheEntry.fileContent = await template.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()
-          }
-        );
-      } else if (
-        // Creating a new normal route file
-        ["layout", "static"].some(
-          (d) => d === node._fsRouteType
-        ) || [
-          "component",
-          "pendingComponent",
-          "errorComponent",
-          "notFoundComponent",
-          "loader"
-        ].every((d) => d !== node._fsRouteType)
-      ) {
-        const tRouteTemplate = this.targetTemplate.route;
-        updatedCacheEntry.fileContent = await template.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()
-          }
-        );
-      } else {
-        return null;
-      }
-    }
-    const isVueFile = node.filePath.endsWith(".vue");
-    if (!isVueFile) {
-      const transformResult = await transform.transform({
-        source: updatedCacheEntry.fileContent,
-        ctx: {
-          target: this.config.target,
-          routeId: escapedRoutePath,
-          lazy: node._fsRouteType === "lazy",
-          verboseFileRoutes: !(this.config.verboseFileRoutes === false)
-        },
-        node
-      });
-      if (transformResult.result === "no-route-export") {
-        const fileName = path.basename(node.fullPath);
-        const dirName = path.dirname(node.fullPath);
-        const ignorePrefix = this.config.routeFileIgnorePrefix;
-        const ignorePattern = this.config.routeFileIgnorePattern;
-        const suggestedFileName = `${ignorePrefix}${fileName}`;
-        const suggestedFullPath = path.join(dirName, suggestedFileName);
-        let message = `Warning: Route file "${node.fullPath}" does not export a Route. This file will not be included in the route tree.`;
-        message += `
-
-If this file is not intended to be a route, you can exclude it using one of these options:`;
-        message += `
-  1. Rename the file to "${suggestedFullPath}" (prefix with "${ignorePrefix}")`;
-        message += `
-  2. Use 'routeFileIgnorePattern' in your config to match this file`;
-        message += `
-
-Current configuration:`;
-        message += `
-  routeFileIgnorePrefix: "${ignorePrefix}"`;
-        message += `
-  routeFileIgnorePattern: ${ignorePattern ? `"${ignorePattern}"` : "undefined"}`;
-        this.logger.warn(message);
-        return null;
-      }
-      if (transformResult.result === "error") {
-        throw new Error(
-          `Error transforming route file ${node.fullPath}: ${transformResult.error}`
-        );
-      }
-      if (transformResult.result === "modified") {
-        updatedCacheEntry.fileContent = transformResult.output;
-        shouldWriteRouteFile = true;
-      }
-    }
-    for (const plugin of this.plugins) {
-      plugin.afterTransform?.({ node, prevNode: previousCacheEntry?.node });
-    }
-    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);
-    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 }
-        });
-      }
-      const newFileState = await this.fs.stat(tmpPath);
-      if (newFileState.mode !== beforeStat.mode) {
-        await this.fs.chmod(tmpPath, beforeStat.mode);
-      }
-      if (newFileState.uid !== beforeStat.uid || newFileState.gid !== beforeStat.gid) {
-        try {
-          await this.fs.chown(tmpPath, beforeStat.uid, beforeStat.gid);
-        } catch (err) {
-          if (typeof err === "object" && err !== null && "code" in err && err.code === "EPERM") {
-            console.warn(
-              `[safeFileWrite] chown failed: ${err.message}`
-            );
-          } else {
-            throw err;
-          }
-        }
-      }
-    } 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");
-    if (!this.sessionId) {
-      node_fs.mkdirSync(this.config.tmpDir, { recursive: true });
-      this.sessionId = crypto.randomBytes(4).toString("hex");
-    }
-    return path.join(this.config.tmpDir, `${this.sessionId}-${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",
-        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) {
-        return {
-          status: "fresh",
-          cacheEntry: shadowCacheFileChange.cacheEntry
-        };
-      }
-    }
-    if (fileChangedCache.result === "file-not-in-cache") {
-      return {
-        status: "stale"
-      };
-    }
-    return { status: "stale", cacheEntry: fileChangedCache.cacheEntry };
-  }
-  async handleRootNode(node) {
-    const result = await this.isRouteFileCacheFresh(node);
-    if (result.status === "fresh") {
-      this.routeNodeShadowCache.set(node.fullPath, result.cacheEntry);
-    }
-    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,
-      routeId: node.routePath ?? "$$TSR_NO_ROOT_ROUTE_PATH_ASSIGNED$$",
-      node
-    };
-    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;
-    }
-    this.routeNodeShadowCache.set(node.fullPath, updatedCacheEntry);
-  }
-  async getCrawlingResult() {
-    await this.runPromise;
-    return this.crawlingResult;
-  }
-  static handleNode(node, acc, prefixMap, config) {
-    let parentRoute = utils.hasParentRoute(prefixMap, node, node.routePath);
-    if (node.routePath) {
-      let searchPath = node.routePath;
-      while (searchPath.length > 0) {
-        const lastSlash = searchPath.lastIndexOf("/");
-        if (lastSlash <= 0) break;
-        searchPath = searchPath.substring(0, lastSlash);
-        const candidate = acc.routeNodesByPath.get(searchPath);
-        if (candidate && candidate.routePath !== node.routePath) {
-          if (candidate !== parentRoute) {
-            if (!parentRoute || (candidate.routePath?.length ?? 0) > (parentRoute.routePath?.length ?? 0)) {
-              parentRoute = candidate;
-            }
-          }
-          break;
-        }
-      }
-    }
-    if (node._virtualParentRoutePath !== void 0) {
-      const explicitParent = acc.routeNodesByPath.get(
-        node._virtualParentRoutePath
-      );
-      if (explicitParent) {
-        parentRoute = explicitParent;
-      } else if (node._virtualParentRoutePath === `/${rootPathId.rootPathId}`) {
-        parentRoute = null;
-      }
-    }
-    if (parentRoute) node.parent = parentRoute;
-    node.path = utils.determineNodePath(node);
-    const trimmedPath = utils.trimPathLeft(node.path ?? "");
-    const trimmedOriginalPath = utils.trimPathLeft(
-      node.originalRoutePath?.replace(
-        node.parent?.originalRoutePath ?? "",
-        ""
-      ) ?? ""
-    );
-    const split = trimmedPath.split("/");
-    const originalSplit = trimmedOriginalPath.split("/");
-    const lastRouteSegment = split[split.length - 1] ?? trimmedPath;
-    const lastOriginalSegment = originalSplit[originalSplit.length - 1] ?? trimmedOriginalPath;
-    node.isNonPath = utils.isSegmentPathless(lastRouteSegment, lastOriginalSegment) || split.every((part) => this.routeGroupPatternRegex.test(part));
-    node.cleanedPath = utils.removeGroups(
-      utils.removeUnderscoresWithEscape(
-        utils.removeLayoutSegmentsWithEscape(node.path, node.originalRoutePath),
-        node.originalRoutePath
-      )
-    );
-    if (node._fsRouteType === "layout" || node._fsRouteType === "pathless_layout") {
-      node.cleanedPath = utils.removeTrailingSlash(node.cleanedPath);
-    }
-    if (!node.isVirtual && [
-      "lazy",
-      "loader",
-      "component",
-      "pendingComponent",
-      "errorComponent",
-      "notFoundComponent"
-    ].some((d) => d === node._fsRouteType)) {
-      acc.routePiecesByPath[node.routePath] = acc.routePiecesByPath[node.routePath] || {};
-      const pieceKey = node._fsRouteType === "lazy" ? "lazy" : node._fsRouteType;
-      acc.routePiecesByPath[node.routePath][pieceKey] = node;
-      const anchorRoute = acc.routeNodesByPath.get(node.routePath);
-      if (!anchorRoute && node.routePath !== `/${rootPathId.rootPathId}`) {
-        this.handleNode(
-          {
-            ...node,
-            isVirtual: true,
-            _fsRouteType: "static"
-          },
-          acc,
-          prefixMap,
-          config
-        );
-      }
-      return;
-    }
-    const isPathlessLayoutWithPath = node._fsRouteType === "pathless_layout" && node.cleanedPath && node.cleanedPath.length > 0;
-    if (!node.isVirtual && isPathlessLayoutWithPath) {
-      const immediateParentPath = utils.removeLastSegmentFromPath(node.routePath) || "/";
-      const immediateParentOriginalPath = utils.removeLastSegmentFromPath(node.originalRoutePath) || "/";
-      let searchPath = immediateParentPath;
-      while (searchPath) {
-        const candidate = acc.routeNodesByPath.get(searchPath);
-        if (candidate && !candidate.isVirtual && candidate.path !== "/") {
-          node.parent = candidate;
-          node.path = node.routePath?.replace(candidate.routePath ?? "", "") || "/";
-          const pathRelativeToParent = immediateParentPath.replace(candidate.routePath ?? "", "") || "/";
-          const originalPathRelativeToParent = immediateParentOriginalPath.replace(
-            candidate.originalRoutePath ?? "",
-            ""
-          ) || "/";
-          node.cleanedPath = utils.removeGroups(
-            utils.removeUnderscoresWithEscape(
-              utils.removeLayoutSegmentsWithEscape(
-                pathRelativeToParent,
-                originalPathRelativeToParent
-              ),
-              originalPathRelativeToParent
-            )
-          );
-          break;
-        }
-        if (searchPath === "/") break;
-        searchPath = utils.removeLastSegmentFromPath(searchPath) || "/";
-      }
-    }
-    if (node.parent) {
-      node.parent.children = node.parent.children ?? [];
-      node.parent.children.push(node);
-    } else {
-      acc.routeTree.push(node);
-    }
-    acc.routeNodes.push(node);
-    if (node.routePath) {
-      acc.routeNodesByPath.set(node.routePath, node);
-    }
-  }
-  // only process files that are relevant for the route tree generation
-  isFileRelevantForRouteTreeGeneration(filePath) {
-    if (filePath === this.generatedRouteTreePath) {
-      return true;
-    }
-    if (filePath.startsWith(this.routesDirectoryPath)) {
-      return true;
-    }
-    if (typeof this.config.virtualRouteConfig === "string" && filePath === this.config.virtualRouteConfig) {
-      return true;
-    }
-    if (this.routeNodeCache.has(filePath)) {
-      return true;
-    }
-    if (getRouteNodes$1.isVirtualConfigFile(path.basename(filePath))) {
-      return true;
-    }
-    if (this.physicalDirectories.some((dir) => filePath.startsWith(dir))) {
-      return true;
-    }
-    return false;
-  }
+				[...importStatements].join("\n"),
+				require_utils.mergeImportDeclarations(routeImports).map(require_utils.buildImportString).join("\n"),
+				virtualRouteNodes.join("\n"),
+				createUpdateRoutes.join("\n"),
+				fileRoutesByFullPath,
+				fileRoutesByPathInterface,
+				moduleAugmentation,
+				routeTreeConfig.join("\n"),
+				routeTree,
+				...footer
+			].filter(Boolean).join("\n\n"),
+			routeTree: acc.routeTree,
+			routeNodes: acc.routeNodes
+		};
+	}
+	async processRouteNodeFile(node) {
+		const result = await this.isRouteFileCacheFresh(node);
+		if (result.status === "fresh") return {
+			node: result.cacheEntry.node,
+			shouldWriteTree: false,
+			cacheEntry: result.cacheEntry
+		};
+		const previousCacheEntry = result.cacheEntry;
+		const existingRouteFile = await this.fs.readFile(node.fullPath);
+		if (existingRouteFile === "file-not-existing") throw new Error(`⚠️ File ${node.fullPath} does not exist`);
+		if (node.routePath) require_validate_route_params.validateRouteParams(node.routePath, node.filePath, this.logger);
+		const updatedCacheEntry = {
+			fileContent: existingRouteFile.fileContent,
+			mtimeMs: existingRouteFile.stat.mtimeMs,
+			routeId: node.routePath ?? "$$TSR_NO_ROUTE_PATH_ASSIGNED$$",
+			node
+		};
+		const escapedRoutePath = node.routePath?.replaceAll("$", "$$") ?? "";
+		let shouldWriteRouteFile = false;
+		let shouldWriteTree = false;
+		if (!existingRouteFile.fileContent) {
+			shouldWriteRouteFile = true;
+			shouldWriteTree = true;
+			if (node._fsRouteType === "lazy") {
+				const tLazyRouteTemplate = this.targetTemplate.lazyRoute;
+				updatedCacheEntry.fileContent = await require_template.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()
+				});
+			} else if (["layout", "static"].some((d) => d === node._fsRouteType) || [
+				"component",
+				"pendingComponent",
+				"errorComponent",
+				"notFoundComponent",
+				"loader"
+			].every((d) => d !== node._fsRouteType)) {
+				const tRouteTemplate = this.targetTemplate.route;
+				updatedCacheEntry.fileContent = await require_template.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()
+				});
+			} else return null;
+		}
+		if (!node.filePath.endsWith(".vue")) {
+			const transformResult = await require_transform.transform({
+				source: updatedCacheEntry.fileContent,
+				ctx: {
+					target: this.config.target,
+					routeId: escapedRoutePath,
+					lazy: node._fsRouteType === "lazy",
+					verboseFileRoutes: !(this.config.verboseFileRoutes === false)
+				},
+				node
+			});
+			if (transformResult.result === "no-route-export") {
+				const fileName = node_path.default.basename(node.fullPath);
+				const dirName = node_path.default.dirname(node.fullPath);
+				const ignorePrefix = this.config.routeFileIgnorePrefix;
+				const ignorePattern = this.config.routeFileIgnorePattern;
+				const suggestedFileName = `${ignorePrefix}${fileName}`;
+				const suggestedFullPath = node_path.default.join(dirName, suggestedFileName);
+				let message = `Warning: Route file "${node.fullPath}" does not export a Route. This file will not be included in the route tree.`;
+				message += `\n\nIf this file is not intended to be a route, you can exclude it using one of these options:`;
+				message += `\n  1. Rename the file to "${suggestedFullPath}" (prefix with "${ignorePrefix}")`;
+				message += `\n  2. Use 'routeFileIgnorePattern' in your config to match this file`;
+				message += `\n\nCurrent configuration:`;
+				message += `\n  routeFileIgnorePrefix: "${ignorePrefix}"`;
+				message += `\n  routeFileIgnorePattern: ${ignorePattern ? `"${ignorePattern}"` : "undefined"}`;
+				this.logger.warn(message);
+				return null;
+			}
+			if (transformResult.result === "error") throw new Error(`Error transforming route file ${node.fullPath}: ${transformResult.error}`);
+			if (transformResult.result === "modified") {
+				updatedCacheEntry.fileContent = transformResult.output;
+				shouldWriteRouteFile = true;
+			}
+		}
+		for (const plugin of this.plugins) plugin.afterTransform?.({
+			node,
+			prevNode: previousCacheEntry?.node
+		});
+		if (shouldWriteRouteFile) updatedCacheEntry.mtimeMs = (await this.safeFileWrite({
+			filePath: node.fullPath,
+			newContent: updatedCacheEntry.fileContent,
+			strategy: {
+				type: "mtime",
+				expectedMtimeMs: updatedCacheEntry.mtimeMs
+			}
+		})).mtimeMs;
+		this.routeNodeShadowCache.set(node.fullPath, updatedCacheEntry);
+		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 {
+			mtimeMs = (await this.fs.stat(file.path)).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
+				}
+			});
+			const newFileState = await this.fs.stat(tmpPath);
+			if (newFileState.mode !== beforeStat.mode) await this.fs.chmod(tmpPath, beforeStat.mode);
+			if (newFileState.uid !== beforeStat.uid || newFileState.gid !== beforeStat.gid) try {
+				await this.fs.chown(tmpPath, beforeStat.uid, beforeStat.gid);
+			} catch (err) {
+				if (typeof err === "object" && err !== null && "code" in err && err.code === "EPERM") console.warn(`[safeFileWrite] chown failed: ${err.message}`);
+				else throw err;
+			}
+		} else if (await require_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 = node_path.default.resolve(filePath);
+		const hash = node_crypto.default.createHash("md5").update(absPath).digest("hex");
+		if (!this.sessionId) {
+			(0, node_fs.mkdirSync)(this.config.tmpDir, { recursive: true });
+			this.sessionId = node_crypto.default.randomBytes(4).toString("hex");
+		}
+		return node_path.default.join(this.config.tmpDir, `${this.sessionId}-${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",
+				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) return {
+				status: "fresh",
+				cacheEntry: shadowCacheFileChange.cacheEntry
+			};
+		}
+		if (fileChangedCache.result === "file-not-in-cache") return { status: "stale" };
+		return {
+			status: "stale",
+			cacheEntry: fileChangedCache.cacheEntry
+		};
+	}
+	async handleRootNode(node) {
+		const result = await this.isRouteFileCacheFresh(node);
+		if (result.status === "fresh") this.routeNodeShadowCache.set(node.fullPath, result.cacheEntry);
+		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,
+			routeId: node.routePath ?? "$$TSR_NO_ROOT_ROUTE_PATH_ASSIGNED$$",
+			node
+		};
+		if (!rootNodeFile.fileContent) {
+			const rootTemplate = this.targetTemplate.rootRoute;
+			const rootRouteContent = await require_template.fillTemplate(this.config, rootTemplate.template(), {
+				tsrImports: rootTemplate.imports.tsrImports(),
+				tsrPath: require_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;
+		}
+		this.routeNodeShadowCache.set(node.fullPath, updatedCacheEntry);
+	}
+	async getCrawlingResult() {
+		await this.runPromise;
+		return this.crawlingResult;
+	}
+	static handleNode(node, acc, prefixMap, config) {
+		let parentRoute = require_utils.hasParentRoute(prefixMap, node, node.routePath);
+		if (node.routePath) {
+			let searchPath = node.routePath;
+			while (searchPath.length > 0) {
+				const lastSlash = searchPath.lastIndexOf("/");
+				if (lastSlash <= 0) break;
+				searchPath = searchPath.substring(0, lastSlash);
+				const candidate = acc.routeNodesByPath.get(searchPath);
+				if (candidate && candidate.routePath !== node.routePath) {
+					if (candidate !== parentRoute) {
+						if (!parentRoute || (candidate.routePath?.length ?? 0) > (parentRoute.routePath?.length ?? 0)) parentRoute = candidate;
+					}
+					break;
+				}
+			}
+		}
+		if (node._virtualParentRoutePath !== void 0) {
+			const explicitParent = acc.routeNodesByPath.get(node._virtualParentRoutePath);
+			if (explicitParent) parentRoute = explicitParent;
+			else if (node._virtualParentRoutePath === `/__root`) parentRoute = null;
+		}
+		if (parentRoute) node.parent = parentRoute;
+		node.path = require_utils.determineNodePath(node);
+		const trimmedPath = require_utils.trimPathLeft(node.path ?? "");
+		const trimmedOriginalPath = require_utils.trimPathLeft(node.originalRoutePath?.replace(node.parent?.originalRoutePath ?? "", "") ?? "");
+		const split = trimmedPath.split("/");
+		const originalSplit = trimmedOriginalPath.split("/");
+		node.isNonPath = require_utils.isSegmentPathless(split[split.length - 1] ?? trimmedPath, originalSplit[originalSplit.length - 1] ?? trimmedOriginalPath) || split.every((part) => this.routeGroupPatternRegex.test(part));
+		node.cleanedPath = require_utils.removeGroups(require_utils.removeUnderscoresWithEscape(require_utils.removeLayoutSegmentsWithEscape(node.path, node.originalRoutePath), node.originalRoutePath));
+		if (node._fsRouteType === "layout" || node._fsRouteType === "pathless_layout") node.cleanedPath = require_utils.removeTrailingSlash(node.cleanedPath);
+		if (!node.isVirtual && [
+			"lazy",
+			"loader",
+			"component",
+			"pendingComponent",
+			"errorComponent",
+			"notFoundComponent"
+		].some((d) => d === node._fsRouteType)) {
+			acc.routePiecesByPath[node.routePath] = acc.routePiecesByPath[node.routePath] || {};
+			const pieceKey = node._fsRouteType === "lazy" ? "lazy" : node._fsRouteType;
+			acc.routePiecesByPath[node.routePath][pieceKey] = node;
+			if (!acc.routeNodesByPath.get(node.routePath) && node.routePath !== `/__root`) this.handleNode({
+				...node,
+				isVirtual: true,
+				_fsRouteType: "static"
+			}, acc, prefixMap, config);
+			return;
+		}
+		const isPathlessLayoutWithPath = node._fsRouteType === "pathless_layout" && node.cleanedPath && node.cleanedPath.length > 0;
+		if (!node.isVirtual && isPathlessLayoutWithPath) {
+			const immediateParentPath = require_utils.removeLastSegmentFromPath(node.routePath) || "/";
+			const immediateParentOriginalPath = require_utils.removeLastSegmentFromPath(node.originalRoutePath) || "/";
+			let searchPath = immediateParentPath;
+			while (searchPath) {
+				const candidate = acc.routeNodesByPath.get(searchPath);
+				if (candidate && !candidate.isVirtual && candidate.path !== "/") {
+					node.parent = candidate;
+					node.path = node.routePath?.replace(candidate.routePath ?? "", "") || "/";
+					const pathRelativeToParent = immediateParentPath.replace(candidate.routePath ?? "", "") || "/";
+					const originalPathRelativeToParent = immediateParentOriginalPath.replace(candidate.originalRoutePath ?? "", "") || "/";
+					node.cleanedPath = require_utils.removeGroups(require_utils.removeUnderscoresWithEscape(require_utils.removeLayoutSegmentsWithEscape(pathRelativeToParent, originalPathRelativeToParent), originalPathRelativeToParent));
+					break;
+				}
+				if (searchPath === "/") break;
+				searchPath = require_utils.removeLastSegmentFromPath(searchPath) || "/";
+			}
+		}
+		if (node.parent) {
+			node.parent.children = node.parent.children ?? [];
+			node.parent.children.push(node);
+		} else acc.routeTree.push(node);
+		acc.routeNodes.push(node);
+		if (node.routePath) acc.routeNodesByPath.set(node.routePath, node);
+	}
+	isFileRelevantForRouteTreeGeneration(filePath) {
+		if (filePath === this.generatedRouteTreePath) return true;
+		if (filePath.startsWith(this.routesDirectoryPath)) return true;
+		if (typeof this.config.virtualRouteConfig === "string" && filePath === this.config.virtualRouteConfig) return true;
+		if (this.routeNodeCache.has(filePath)) return true;
+		if (require_getRouteNodes$1.isVirtualConfigFile(node_path.default.basename(filePath))) return true;
+		if (this.physicalDirectories.some((dir) => filePath.startsWith(dir))) return true;
+		return false;
+	}
 };
-_Generator.routeGroupPatternRegex = /\(.+\)/;
-_Generator.componentPieceRegex = /[./](component|errorComponent|notFoundComponent|pendingComponent|loader|lazy)[.]/;
-let Generator = _Generator;
+//#endregion
 exports.Generator = Generator;
-//# sourceMappingURL=generator.cjs.map
+
+//# sourceMappingURL=generator.cjs.map