@buzola/vite-plugin 0.0.1 → 0.0.4

package/src/generator/codegen.ts

@@ -1,5 +1,5 @@
 import * as path from 'node:path'
-import type { FileRouteNode } from './tree-builder'
+import type { FileRouteNode } from './tree-builder.js'
 
 export interface CodegenOptions {
 	/** The route tree from file scanning. */
@@ -115,7 +115,7 @@ interface PageInfo {
 /**
  * Collect page info from the file route tree for codegen.
  */
-function collectPages(nodes: FileRouteNode[], parentPath = ''): PageInfo[] {
+function collectPages(nodes: FileRouteNode[]): PageInfo[] {
 	const result: PageInfo[] = []
 
 	for (const node of nodes) {
@@ -132,7 +132,7 @@ function collectPages(nodes: FileRouteNode[], parentPath = ''): PageInfo[] {
 		}
 
 		if (node.children.length > 0) {
-			result.push(...collectPages(node.children, node.fullPath))
+			result.push(...collectPages(node.children))
 		}
 	}
 
@@ -154,7 +154,7 @@ function collectImports(
 		if (node.filePath) {
 			const key = importKey(node.filePath, node.exportName)
 			if (!importsByKey.has(key)) {
-				const relativePath = path.relative(outputDir, node.filePath)
+				const relativePath = path.relative(outputDir, node.filePath).replaceAll('\\', '/')
 				const importPath = relativePath.startsWith('.') ? relativePath : `./${relativePath}`
 				// Strip extension for import
 				const cleanPath = importPath.replace(/\.(tsx?|jsx?)$/, '')
@@ -184,6 +184,11 @@ function generateTreeConfig(
 		lines.push(`${pad}{`)
 		lines.push(`${pad}  path: '${node.segment ? `/${node.segment}` : '/'}',`)
 
+		// Emit matchPath when page has a custom route pattern that differs from file-hierarchy position
+		if (node.pageExports && node.pageExports.length > 0 && node.pageExports[0].routePattern !== node.fullPath) {
+			lines.push(`${pad}  matchPath: '${node.pageExports[0].routePattern}',`)
+		}
+
 		if (imp) {
 			if (imp.isLazy) {
 				lines.push(`${pad}  component: lazy(${imp.varName}),`)
@@ -205,10 +210,3 @@ function generateTreeConfig(
 		lines.push(`${pad}},`)
 	}
 }
-
-/**
- * Generate the virtual module content for `virtual:buzola/routes`.
- */
-export function generateVirtualModule(outputPath: string): string {
-	return `export { routes, pageRegistry } from '${outputPath.replace(/\.ts$/, '')}';\n`
-}

package/src/generator/scanner.ts

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs'
 import * as path from 'node:path'
-import { isRouteFile } from '../conventions'
+import { isRouteFile } from '../conventions.js'
 
 export interface ScannedFile {
 	/** Absolute path to the file. */

package/src/generator/tree-builder.ts

@@ -1,8 +1,8 @@
 import * as path from 'node:path'
-import { parseDirName, parseFileName } from '../conventions'
-import type { ExtractedPage, ModuleLoader } from './page-extractor'
-import { extractPages } from './page-extractor'
-import type { ScannedFile } from './scanner'
+import { parseDirName, parseFileName } from '../conventions.js'
+import type { ExtractedPage, ModuleLoader } from './page-extractor.js'
+import { extractPages } from './page-extractor.js'
+import type { ScannedFile } from './scanner.js'
 
 /**
  * Page export info attached to a file route node.
@@ -19,7 +19,7 @@ export interface PageExportInfo {
 }
 
 /**
- * A node in the file-based route tree (before compilation into RouteNode).
+ * A node in the route tree (before compilation into RouteNode).
  */
 export interface FileRouteNode {
 	/** Route path segment (from file name, or derived from .route() pattern). */
@@ -44,11 +44,150 @@ export interface FileRouteNode {
 	children: FileRouteNode[]
 }
 
+// ─── Flat route entry (intermediate representation) ─────────────────────────
+
+interface RouteEntry {
+	routePattern: string
+	/** File-hierarchy-based position for tree building (may differ from routePattern when .route() is used). */
+	treePosition: string
+	filePath: string
+	exportName: string
+	kind: 'page' | 'layout' | 'notFound'
+	pageId?: string
+	params: { name: string; optional: boolean; array: boolean }[]
+	/** File-system-derived URL path (ignoring pathless groups). */
+	fileScope: string
+	/** Chain of pathless group directory paths this file is nested under. */
+	pathlessGroups: string[]
+	/** For pathless group layouts: the directory path of the group. */
+	pathlessGroupId?: string
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
 /**
  * Build a route tree from scanned files.
  * Loads each module via moduleLoader to extract createPage() metadata.
+ *
+ * Two-phase approach:
+ * 1. Extract flat route entries from all files.
+ * 2. Build the tree using route-pattern prefix matching (not file hierarchy).
  */
 export async function buildFileRouteTree(files: ScannedFile[], moduleLoader: ModuleLoader): Promise<FileRouteNode[]> {
+	const entries = await extractEntries(files, moduleLoader)
+	return buildTreeFromEntries(entries)
+}
+
+// ─── Phase 1: Extract flat route entries ────────────────────────────────────
+
+async function extractEntries(files: ScannedFile[], moduleLoader: ModuleLoader): Promise<RouteEntry[]> {
+	const entries: RouteEntry[] = []
+
+	for (const file of files) {
+		const ext = path.extname(file.relativePath)
+		const withoutExt = file.relativePath.slice(0, -ext.length)
+		const parts = withoutExt.split(path.sep)
+		const fileName = parts.pop()!
+		const dirs = parts
+		const fileInfo = parseFileName(fileName)
+
+		// Compute fileScope (URL path from directory structure, skipping pathless groups)
+		// and pathlessGroups chain
+		let fileScope = ''
+		const pathlessGroups: string[] = []
+		let groupPath = ''
+
+		for (const dir of dirs) {
+			groupPath = groupPath ? `${groupPath}/${dir}` : dir
+			const dirInfo = parseDirName(dir)
+			if (dirInfo.isPathlessGroup) {
+				pathlessGroups.push(groupPath)
+			} else {
+				fileScope = joinPath(fileScope, dirInfo.segment)
+			}
+		}
+		if (!fileScope) fileScope = '/'
+
+		if (fileInfo.isLayout) {
+			// Detect pathless group layout: immediate parent dir is a pathless group
+			const lastDir = dirs.length > 0 ? dirs[dirs.length - 1] : null
+			const isPathlessGroupLayout = lastDir != null && parseDirName(lastDir).isPathlessGroup
+
+			entries.push({
+				routePattern: fileScope,
+				treePosition: fileScope,
+				filePath: file.absolutePath,
+				exportName: 'default',
+				kind: 'layout',
+				params: [],
+				fileScope,
+				pathlessGroups,
+				pathlessGroupId: isPathlessGroupLayout ? groupPath : undefined,
+			})
+		} else if (fileInfo.isNotFound) {
+			const catchAllPattern = fileScope === '/' ? '/:__notFound+' : `${fileScope}/:__notFound+`
+			const pageId = dirs.length === 0 ? '404' : `${dirs.join('/')}/404`
+			entries.push({
+				routePattern: catchAllPattern,
+				treePosition: catchAllPattern,
+				filePath: file.absolutePath,
+				exportName: 'default',
+				kind: 'notFound',
+				pageId,
+				params: [{ name: '__notFound', optional: false, array: false }],
+				fileScope,
+				pathlessGroups,
+			})
+		} else {
+			const isIndex = fileInfo.isIndex
+			const basePath = isIndex ? fileScope : joinPath(fileScope, fileName)
+
+			const pages = await safeExtractPages(file, moduleLoader)
+
+			if (pages.length === 0) {
+				// No createPage() — plain component
+				entries.push({
+					routePattern: basePath,
+					treePosition: basePath,
+					filePath: file.absolutePath,
+					exportName: 'default',
+					kind: 'page',
+					params: [],
+					fileScope,
+					pathlessGroups,
+				})
+			} else {
+				for (const page of pages) {
+					const pageId = derivePageId(dirs, fileName, isIndex, page.exportName)
+					const defaultPattern = page.isDefault ? basePath : joinPath(basePath, page.exportName)
+					const routePattern = page.route ?? defaultPattern
+					entries.push({
+						routePattern,
+						treePosition: defaultPattern,
+						filePath: file.absolutePath,
+						exportName: page.exportName,
+						kind: 'page',
+						pageId,
+						params: page.params,
+						fileScope,
+						pathlessGroups,
+					})
+				}
+			}
+		}
+	}
+
+	return entries
+}
+
+// ─── Phase 2: Build tree from flat entries ──────────────────────────────────
+
+interface LayoutRef {
+	node: FileRouteNode
+	pathlessGroupId?: string
+}
+
+function buildTreeFromEntries(entries: RouteEntry[]): FileRouteNode[] {
 	const root: FileRouteNode = {
 		segment: '',
 		fullPath: '/',
@@ -59,10 +198,110 @@ export async function buildFileRouteTree(files: ScannedFile[], moduleLoader: Mod
 		children: [],
 	}
 
-	for (const file of files) {
-		await insertFile(root, file, moduleLoader)
+	const layouts = entries.filter(e => e.kind === 'layout')
+	const pages = entries.filter(e => e.kind !== 'layout')
+
+	// Sort layouts: shorter routePattern first, non-pathless before pathless
+	layouts.sort((a, b) => {
+		if (a.routePattern.length !== b.routePattern.length) return a.routePattern.length - b.routePattern.length
+		if (a.pathlessGroupId && !b.pathlessGroupId) return 1
+		if (!a.pathlessGroupId && b.pathlessGroupId) return -1
+		return 0
+	})
+
+	// Insert layouts into tree
+	// Track all layout nodes for page assignment
+	const layoutRefs: LayoutRef[] = [{ node: root }]
+
+	for (const layout of layouts) {
+		if (layout.pathlessGroupId) {
+			// Pathless group layout — find parent by walking layoutRefs, respecting pathless group chain
+			const parent = findParentForPathlessGroupLayout(layoutRefs, layout)
+			const node: FileRouteNode = {
+				segment: '',
+				fullPath: layout.treePosition,
+				filePath: layout.filePath,
+				isLayout: true,
+				isIndex: false,
+				isNotFound: false,
+				isPathlessGroup: true,
+				children: [],
+			}
+			parent.node.children.push(node)
+			layoutRefs.push({ node, pathlessGroupId: layout.pathlessGroupId })
+		} else if (layout.treePosition === '/' && !root.filePath) {
+			// Root layout
+			root.isLayout = true
+			root.filePath = layout.filePath
+		} else if (layout.treePosition === '/') {
+			// Additional layout at root (shouldn't happen normally, but handle)
+			root.isLayout = true
+			root.filePath = layout.filePath
+		} else {
+			// Regular layout — find parent by prefix matching
+			const parent = findDeepestLayoutParent(layoutRefs, layout.treePosition, layout.pathlessGroups)
+			const segment = computeSegmentFromParent(parent.node.fullPath, layout.treePosition)
+			const node: FileRouteNode = {
+				segment,
+				fullPath: layout.treePosition,
+				filePath: layout.filePath,
+				isLayout: true,
+				isIndex: false,
+				isNotFound: false,
+				isPathlessGroup: false,
+				children: [],
+			}
+			parent.node.children.push(node)
+			layoutRefs.push({ node })
+		}
 	}
 
+	// Insert pages into tree (using file-hierarchy position, not route pattern)
+	for (const entry of pages) {
+		const parent = findDeepestLayoutParent(layoutRefs, entry.treePosition, entry.pathlessGroups)
+		const isIndex = entry.treePosition === parent.node.fullPath
+		const segment = isIndex ? '' : computeSegmentFromParent(parent.node.fullPath, entry.treePosition)
+
+		const pageExports: PageExportInfo[] | undefined = entry.pageId
+			? [{
+				pageId: entry.pageId,
+				exportName: entry.exportName,
+				routePattern: entry.routePattern,
+				params: entry.params,
+			}]
+			: undefined
+
+		// For named exports from the same file as an existing node, check collision
+		if (!isIndex) {
+			checkCollision(parent.node.children, segment, entry.filePath, entry.exportName)
+		}
+
+		// Try to reuse an existing container node (e.g., from a directory that has no _layout.tsx)
+		const existing = !isIndex
+			? parent.node.children.find(c => c.segment === segment && !c.filePath && !c.isLayout && !c.isPathlessGroup)
+			: undefined
+
+		if (existing) {
+			existing.filePath = entry.filePath
+			existing.exportName = entry.exportName
+			existing.pageExports = pageExports
+		} else {
+			parent.node.children.push({
+				segment,
+				fullPath: entry.treePosition,
+				filePath: entry.filePath,
+				exportName: entry.exportName,
+				isLayout: false,
+				isIndex,
+				isNotFound: entry.kind === 'notFound',
+				isPathlessGroup: false,
+				pageExports,
+				children: [],
+			})
+		}
+	}
+
+	// Sort children recursively
 	sortChildren(root)
 
 	if (root.isLayout && root.filePath) {
@@ -72,170 +311,74 @@ export async function buildFileRouteTree(files: ScannedFile[], moduleLoader: Mod
 	return root.children
 }
 
-async function insertFile(root: FileRouteNode, file: ScannedFile, moduleLoader: ModuleLoader): Promise<void> {
-	const ext = path.extname(file.relativePath)
-	const withoutExt = file.relativePath.slice(0, -ext.length)
-	const parts = withoutExt.split(path.sep)
-	const fileName = parts.pop()!
-	const dirs = parts
+/**
+ * Find the parent layout for a pathless group layout.
+ * The parent is the deepest layout at the same routePattern level,
+ * considering the pathless group nesting chain.
+ */
+function findParentForPathlessGroupLayout(layoutRefs: LayoutRef[], entry: RouteEntry): LayoutRef {
+	// The parent is the layout whose pathlessGroupId is the previous entry in the chain,
+	// or the deepest non-pathless layout at the same routePattern if this is the first group.
+	const groupChain = entry.pathlessGroups
+	const thisGroupIndex = groupChain.indexOf(entry.pathlessGroupId!)
+
+	if (thisGroupIndex > 0) {
+		// Has a parent pathless group — find it
+		const parentGroupId = groupChain[thisGroupIndex - 1]
+		const parentRef = layoutRefs.find(r => r.pathlessGroupId === parentGroupId)
+		if (parentRef) return parentRef
+	}
 
-	let current = root
-	let currentPath = ''
+	// First pathless group in chain (or parent not found) — find the deepest regular layout at prefix
+	let best = layoutRefs[0] // root
+	for (const ref of layoutRefs) {
+		if (ref.pathlessGroupId) continue // skip other pathless groups
+		if (isPathPrefixOrEqual(ref.node.fullPath, entry.routePattern) && ref.node.fullPath.length >= best.node.fullPath.length) {
+			best = ref
+		}
+	}
+	return best
+}
 
-	for (const dir of dirs) {
-		const dirInfo = parseDirName(dir)
-		const segmentPath = dirInfo.isPathlessGroup
-			? currentPath
-			: joinPath(currentPath, dirInfo.segment)
+/**
+ * Find the deepest layout whose routePattern is a prefix of the given pattern.
+ * Respects pathless group membership.
+ */
+function findDeepestLayoutParent(layoutRefs: LayoutRef[], routePattern: string, pathlessGroups: string[]): LayoutRef {
+	let best = layoutRefs[0] // root
 
-		let child = current.children.find(c => c.segment === dirInfo.segment && c.isPathlessGroup === dirInfo.isPathlessGroup && c.isLayout)
+	for (const ref of layoutRefs) {
+		if (!isPathPrefixOrEqual(ref.node.fullPath, routePattern)) continue
 
-		if (!child) {
-			child = current.children.find(c => c.segment === dirInfo.segment && c.isPathlessGroup === dirInfo.isPathlessGroup && !c.filePath)
-		}
+		// For pathless groups, only match if the entry belongs to this group
+		if (ref.pathlessGroupId && !pathlessGroups.includes(ref.pathlessGroupId)) continue
 
-		if (!child) {
-			child = {
-				segment: dirInfo.segment,
-				fullPath: segmentPath || '/',
-				isLayout: false,
-				isIndex: false,
-				isNotFound: false,
-				isPathlessGroup: dirInfo.isPathlessGroup,
-				children: [],
-			}
-			current.children.push(child)
+		// Prefer deeper matches. For ties (pathless groups at same depth), prefer pathless group
+		// that the entry belongs to over non-pathless.
+		if (ref.node.fullPath.length > best.node.fullPath.length) {
+			best = ref
+		} else if (ref.node.fullPath.length === best.node.fullPath.length && ref.pathlessGroupId && pathlessGroups.includes(ref.pathlessGroupId)) {
+			best = ref
 		}
-
-		current = child
-		currentPath = segmentPath
 	}
 
-	const fileInfo = parseFileName(fileName)
-
-	if (fileInfo.isLayout) {
-		current.isLayout = true
-		current.filePath = file.absolutePath
-	} else if (fileInfo.isNotFound) {
-		const catchAllSegment = ':__notFound+'
-		const fullPath = joinPath(currentPath, catchAllSegment)
-		const pageId = dirs.length === 0 ? '404' : `${dirs.join('/')}/404`
-		const pageExports: PageExportInfo[] = [{
-			pageId,
-			exportName: 'default',
-			routePattern: fullPath,
-			params: [{ name: '__notFound', optional: false, array: false }],
-		}]
-		const notFoundNode: FileRouteNode = {
-			segment: catchAllSegment,
-			fullPath,
-			filePath: file.absolutePath,
-			isLayout: false,
-			isIndex: false,
-			isNotFound: true,
-			isPathlessGroup: false,
-			pageExports,
-			children: [],
-		}
-		current.children.push(notFoundNode)
-	} else if (fileInfo.isIndex) {
-		const fullPath = currentPath || '/'
-		const allExports = await extractPageExportsFromFile(file, dirs, '', true, currentPath, moduleLoader)
-		const defaultExports = allExports?.filter(e => e.exportName === 'default')
-		const namedExports = allExports?.filter(e => e.exportName !== 'default') ?? []
-
-		const hasDefault = defaultExports != null && defaultExports.length > 0
-		const indexNode: FileRouteNode = {
-			segment: '',
-			fullPath,
-			filePath: hasDefault ? file.absolutePath : undefined,
-			exportName: hasDefault ? 'default' : undefined,
-			isLayout: false,
-			isIndex: true,
-			isNotFound: false,
-			isPathlessGroup: false,
-			pageExports: hasDefault ? defaultExports : undefined,
-			children: [],
-		}
-		current.children.push(indexNode)
-
-		// Named exports become siblings (children of current, not of the index node)
-		for (const exp of namedExports) {
-			const namedSegment = exp.routePattern ? (computeRelativeSegment(currentPath, exp.routePattern) ?? exp.exportName) : exp.exportName
-			checkCollision(current.children, namedSegment, file.absolutePath, exp.exportName)
-			current.children.push({
-				segment: namedSegment,
-				fullPath: joinPath(currentPath, namedSegment),
-				filePath: file.absolutePath,
-				exportName: exp.exportName,
-				isLayout: false,
-				isIndex: false,
-				isNotFound: false,
-				isPathlessGroup: false,
-				pageExports: [exp],
-				children: [],
-			})
-		}
-	} else {
-		const allExports = await extractPageExportsFromFile(file, dirs, fileName, false, currentPath, moduleLoader)
-		const defaultExports = allExports?.filter(e => e.exportName === 'default')
-		const namedExports = allExports?.filter(e => e.exportName !== 'default') ?? []
-
-		const hasDefault = defaultExports != null && defaultExports.length > 0
-		const routeSegment = hasDefault ? deriveSegmentFromPageExports(defaultExports, currentPath) : undefined
-		const segment = routeSegment ?? fileInfo.segment
-		const fullPath = joinPath(currentPath, segment)
-
-		if (hasDefault) {
-			checkCollision(current.children, segment, file.absolutePath, 'default')
-		}
+	return best
+}
 
-		// Reuse existing container node (created by a previous file's named exports) if available
-		let routeNode = !hasDefault ? current.children.find(c => c.segment === segment && !c.filePath && !c.isLayout && !c.isPathlessGroup) : undefined
-		if (!routeNode) {
-			routeNode = {
-				segment,
-				fullPath,
-				filePath: hasDefault ? file.absolutePath : undefined,
-				exportName: hasDefault ? 'default' : undefined,
-				isLayout: false,
-				isIndex: false,
-				isNotFound: false,
-				isPathlessGroup: false,
-				pageExports: hasDefault ? defaultExports : undefined,
-				children: [],
-			}
-			current.children.push(routeNode)
-		}
+function isPathPrefixOrEqual(prefix: string, path: string): boolean {
+	if (prefix === '/') return true
+	return path === prefix || path.startsWith(prefix + '/')
+}
 
-		// Named exports become children (equivalent to files in a subdirectory)
-		for (const exp of namedExports) {
-			const namedSegment = exp.routePattern ? (computeRelativeSegment(fullPath, exp.routePattern) ?? exp.exportName) : exp.exportName
-			checkCollision(routeNode.children, namedSegment, file.absolutePath, exp.exportName)
-			routeNode.children.push({
-				segment: namedSegment,
-				fullPath: joinPath(fullPath, namedSegment),
-				filePath: file.absolutePath,
-				exportName: exp.exportName,
-				isLayout: false,
-				isIndex: false,
-				isNotFound: false,
-				isPathlessGroup: false,
-				pageExports: [exp],
-				children: [],
-			})
-		}
-	}
+function computeSegmentFromParent(parentFullPath: string, childFullPath: string): string {
+	if (parentFullPath === '/') return childFullPath.slice(1)
+	return childFullPath.slice(parentFullPath.length + 1)
 }
 
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
 /**
  * Derive page ID from file path and export name.
- *
- * Examples:
- * - File: project.tsx, export: detail → "project/detail"
- * - File: project.tsx, export: default → "project"
- * - File: project/detail.tsx, export: default → "project/detail"
- * - File: index.tsx, export: default → "index"
  */
 function derivePageId(dirs: string[], fileName: string, isIndex: boolean, exportName: string): string {
 	const segments = [...dirs]
@@ -254,67 +397,13 @@ function derivePageId(dirs: string[], fileName: string, isIndex: boolean, export
 	return exportName === 'default' ? base : `${base}/${exportName}`
 }
 
-/**
- * Compute the relative route segment from a page's .route() pattern and parent path.
- */
-function computeRelativeSegment(parentPath: string, routePattern: string): string | undefined {
-	const prefix = parentPath === '/' ? '/' : parentPath + '/'
-
-	if (routePattern.startsWith(prefix)) {
-		return routePattern.slice(prefix.length)
-	}
-
-	if (routePattern === parentPath) {
-		return undefined
-	}
-
-	const lastSlash = routePattern.lastIndexOf('/')
-	return lastSlash >= 0 ? routePattern.slice(lastSlash + 1) : routePattern
-}
-
-function deriveSegmentFromPageExports(
-	pageExports: PageExportInfo[] | undefined,
-	parentPath: string,
-): string | undefined {
-	if (!pageExports || pageExports.length === 0) return undefined
-	const firstRoute = pageExports[0].routePattern
-	return computeRelativeSegment(parentPath, firstRoute)
-}
-
-async function extractPageExportsFromFile(
-	file: ScannedFile,
-	dirs: string[],
-	fileName: string,
-	isIndex: boolean,
-	parentPath: string,
-	moduleLoader: ModuleLoader,
-): Promise<PageExportInfo[] | undefined> {
-	let pages: ExtractedPage[]
+async function safeExtractPages(file: ScannedFile, moduleLoader: ModuleLoader): Promise<ExtractedPage[]> {
 	try {
-		pages = await extractPages(file.absolutePath, moduleLoader)
-	} catch {
-		return undefined
-	}
-
-	if (pages.length === 0) return undefined
-
-	const result: PageExportInfo[] = []
-
-	for (const page of pages) {
-		const pageId = derivePageId(dirs, fileName, isIndex, page.exportName)
-		// If no explicit .route(), derive from file path — all params become query params
-		const basePath = isIndex ? (parentPath || '/') : joinPath(parentPath, fileName)
-		const routePattern = page.route ?? (page.isDefault ? basePath : joinPath(basePath, page.exportName))
-
-		result.push({
-			pageId,
-			exportName: page.exportName,
-			routePattern,
-			params: page.params,
-		})
+		return await extractPages(file.absolutePath, moduleLoader)
+	} catch (error) {
+		console.warn(`[buzola] Failed to extract pages from ${file.relativePath}:`, error instanceof Error ? error.message : error)
+		return []
 	}
-
-	return result.length > 0 ? result : undefined
 }
 
 function checkCollision(siblings: FileRouteNode[], segment: string, filePath: string, exportName: string): void {
@@ -335,20 +424,25 @@ function sortChildren(node: FileRouteNode): void {
 	for (const child of node.children) {
 		sortChildren(child)
 	}
-
 	node.children.sort((a, b) => sortWeight(a) - sortWeight(b))
 }
 
+const SORT_INDEX = 0
+const SORT_STATIC = 1
+const SORT_DYNAMIC = 2
+const SORT_CATCHALL = 3
+const SORT_NOT_FOUND = 4
+
 function sortWeight(node: FileRouteNode): number {
-	if (node.isIndex) return 0
-	if (node.isNotFound) return 4
-	if (node.segment.includes(':') && node.segment.includes('+')) return 3
-	if (node.segment.includes(':')) return 2
-	return 1
+	if (node.isIndex) return SORT_INDEX
+	if (node.isNotFound) return SORT_NOT_FOUND
+	if (node.segment.includes(':') && node.segment.includes('+')) return SORT_CATCHALL
+	if (node.segment.includes(':')) return SORT_DYNAMIC
+	return SORT_STATIC
 }
 
 function joinPath(parent: string, child: string): string {
 	if (!child) return parent || '/'
-	const base = parent || ''
-	return `${base}/${child}`
+	if (!parent || parent === '/') return `/${child}`
+	return `${parent}/${child}`
 }