@buzola/router 0.0.9 → 0.0.11

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,qBAAqB,CAAA;AAG5B,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAEtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AACnE,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAEzE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AACxE,YAAY,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AAEpE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAEjD,OAAO,EAAE,8BAA8B,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAA;AAC9G,YAAY,EAAE,8BAA8B,EAAE,MAAM,gCAAgC,CAAA;AAGpF,YAAY,EACX,SAAS,EACT,mBAAmB,EACnB,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,UAAU,EACV,cAAc,EACd,cAAc,EACd,WAAW,EACX,UAAU,EACV,SAAS,EACT,WAAW,EACX,cAAc,GACd,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAE,CAAC,EAAE,MAAM,oBAAoB,CAAA;AAGtC,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAC9E,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAGlG,OAAO,EACN,cAAc,EACd,aAAa,EACb,IAAI,EACJ,MAAM,EACN,YAAY,EACZ,aAAa,EACb,UAAU,EACV,aAAa,EACb,WAAW,EACX,kBAAkB,EAClB,SAAS,EACT,QAAQ,EACR,SAAS,EACT,cAAc,EACd,eAAe,GACf,MAAM,kBAAkB,CAAA;AACzB,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,SAAS,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAEtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AACnE,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAEzE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AACxE,YAAY,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AAEpE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAEjD,OAAO,EAAE,8BAA8B,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAA;AAC9G,YAAY,EAAE,8BAA8B,EAAE,MAAM,gCAAgC,CAAA;AAGpF,YAAY,EACX,SAAS,EACT,mBAAmB,EACnB,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,UAAU,EACV,cAAc,EACd,cAAc,EACd,WAAW,EACX,UAAU,EACV,SAAS,EACT,WAAW,EACX,SAAS,EACT,cAAc,GACd,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAE,CAAC,EAAE,MAAM,oBAAoB,CAAA;AAGtC,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAC9E,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAGlG,OAAO,EACN,cAAc,EACd,aAAa,EACb,IAAI,EACJ,MAAM,EACN,YAAY,EACZ,aAAa,EACb,UAAU,EACV,aAAa,EACb,WAAW,EACX,kBAAkB,EAClB,SAAS,EACT,QAAQ,EACR,SAAS,EACT,cAAc,EACd,eAAe,GACf,MAAM,kBAAkB,CAAA;AACzB,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,SAAS,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/index.js

@@ -1,5 +1,3 @@
-// ─── Polyfills ──────────────────────────────────────────────────────────────
-import 'urlpattern-polyfill';
 // ─── Engine ─────────────────────────────────────────────────────────────────
 export { LoaderCache } from './engine/loader-cache.js';
 export { NavigationAbortedError, Router } from './engine/router.js';

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,OAAO,qBAAqB,CAAA;AAE5B,+EAA+E;AAC/E,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAEtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAGnE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAGxE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAEjD,OAAO,EAAE,8BAA8B,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAA;AAsB9G,gFAAgF;AAChF,OAAO,EAAE,CAAC,EAAE,MAAM,oBAAoB,CAAA;AAEtC,+EAA+E;AAC/E,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAG9E,+EAA+E;AAC/E,OAAO,EACN,cAAc,EACd,aAAa,EACb,IAAI,EACJ,MAAM,EACN,YAAY,EACZ,aAAa,EACb,UAAU,EACV,aAAa,EACb,WAAW,EACX,kBAAkB,EAClB,SAAS,EACT,QAAQ,EACR,SAAS,EACT,cAAc,EACd,eAAe,GACf,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAEtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAGnE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAGxE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAEjD,OAAO,EAAE,8BAA8B,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAA;AAuB9G,gFAAgF;AAChF,OAAO,EAAE,CAAC,EAAE,MAAM,oBAAoB,CAAA;AAEtC,+EAA+E;AAC/E,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAG9E,+EAA+E;AAC/E,OAAO,EACN,cAAc,EACd,aAAa,EACb,IAAI,EACJ,MAAM,EACN,YAAY,EACZ,aAAa,EACb,UAAU,EACV,aAAa,EACb,WAAW,EACX,kBAAkB,EAClB,SAAS,EACT,QAAQ,EACR,SAAS,EACT,cAAc,EACd,eAAe,GACf,MAAM,kBAAkB,CAAA"}

package/dist/react/provider.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { Router } from '../engine/router.js';
-import type { RouteMatch, RouteNode } from '../engine/types.js';
+import type { RouteMatch, RouteTree } from '../engine/types.js';
 /** Props passed to the middleware component. */
 export interface MiddlewareProps {
     /** Merged params from all matched routes. */
@@ -23,7 +23,7 @@ export type BuzolaProviderProps = {
     pageRegistry?: never;
 } | {
     router?: never;
-    routes: RouteNode[];
+    routes: RouteTree;
     persistentParams?: () => Record<string, string>;
     pageRegistry?: Record<string, string>;
 });

package/dist/react/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/react/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA8E,MAAM,OAAO,CAAA;AAElG,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAI/D,gDAAgD;AAChD,MAAM,WAAW,eAAe;IAC/B,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,2CAA2C;IAC3C,OAAO,EAAE,UAAU,EAAE,CAAA;IACrB,uCAAuC;IACvC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CACzB;AAED,gEAAgE;AAChE,MAAM,MAAM,mBAAmB,GAAG,KAAK,CAAC,aAAa,CAAC,eAAe,CAAC,CAAA;AAEtE,MAAM,MAAM,mBAAmB,GAC5B;IACD,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,8FAA8F;IAC9F,UAAU,CAAC,EAAE,mBAAmB,CAAA;CAChC,GACC,CACC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,CAAC;IAAC,gBAAgB,CAAC,EAAE,KAAK,CAAC;IAAC,YAAY,CAAC,EAAE,KAAK,CAAA;CAAE,GAClF;IACD,MAAM,CAAC,EAAE,KAAK,CAAA;IACd,MAAM,EAAE,SAAS,EAAE,CAAA;IACnB,gBAAgB,CAAC,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/C,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACrC,CACD,CAAA;AAEF;;;GAGG;AACH,wBAAgB,cAAc,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,KAAK,EAAE,EAAE,mBAAmB,GAAG,KAAK,CAAC,YAAY,CA+C9H"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/react/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA8E,MAAM,OAAO,CAAA;AAElG,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAI/D,gDAAgD;AAChD,MAAM,WAAW,eAAe;IAC/B,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,2CAA2C;IAC3C,OAAO,EAAE,UAAU,EAAE,CAAA;IACrB,uCAAuC;IACvC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CACzB;AAED,gEAAgE;AAChE,MAAM,MAAM,mBAAmB,GAAG,KAAK,CAAC,aAAa,CAAC,eAAe,CAAC,CAAA;AAEtE,MAAM,MAAM,mBAAmB,GAC5B;IACD,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,8FAA8F;IAC9F,UAAU,CAAC,EAAE,mBAAmB,CAAA;CAChC,GACC,CACC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,CAAC;IAAC,gBAAgB,CAAC,EAAE,KAAK,CAAC;IAAC,YAAY,CAAC,EAAE,KAAK,CAAA;CAAE,GAClF;IACD,MAAM,CAAC,EAAE,KAAK,CAAA;IACd,MAAM,EAAE,SAAS,CAAA;IACjB,gBAAgB,CAAC,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/C,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACrC,CACD,CAAA;AAEF;;;GAGG;AACH,wBAAgB,cAAc,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,KAAK,EAAE,EAAE,mBAAmB,GAAG,KAAK,CAAC,YAAY,CA+C9H"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@buzola/router",
-	"version": "0.0.9",
+	"version": "0.0.11",
 	"type": "module",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -37,7 +37,5 @@
 		"react": "^19.0.0",
 		"typescript": "^5.7.0"
 	},
-	"dependencies": {
-		"urlpattern-polyfill": "^10.1.0"
-	}
+	"dependencies": {}
 }

package/src/__tests__/matcher.test.ts

@@ -189,6 +189,175 @@ describe('matchRoutes', () => {
 		expect(matches![0].params).toEqual({})
 	})
 
+	// ─── matchPath override tests (file tree ≠ URL tree) ────────────────────
+
+	it('matches static route over layout with dynamic matchPath children (real-world admin structure)', () => {
+		// Mirrors the actual buzola.gen.ts structure from webmaster/admin:
+		// - Layout "project/detail" with matchPath children "/app/project/:id"
+		// - Static sibling "project/create" at "/app/project/create"
+		const tree = createTestTree([
+			{
+				path: '/',
+				component: dummyComponent,
+				isLayout: true,
+				children: [
+					{
+						path: '/app',
+						component: dummyComponent,
+						isLayout: true,
+						children: [
+							{
+								path: '/project/detail',
+								component: dummyComponent,
+								isLayout: true,
+								children: [
+									{ path: '/', matchPath: '/app/project/:id', component: dummyComponent, isIndex: true },
+									{ path: '/edit', matchPath: '/app/project/:id/edit', component: dummyComponent },
+								],
+							},
+							{ path: '/project/create', component: dummyComponent },
+							{ path: '/project', component: dummyComponent },
+							{ path: '/dashboard', component: dummyComponent },
+						],
+					},
+				],
+			},
+		])
+
+		// Static /app/project/create must NOT match the dynamic /app/project/:id
+		const createMatches = matchRoutes(tree, new URL('http://localhost/app/project/create'))
+		expect(createMatches).not.toBeNull()
+		const createLeaf = createMatches![createMatches!.length - 1]
+		expect(createLeaf.node.fullPath).toBe('/app/project/create')
+		expect(createLeaf.params).toEqual({})
+
+		// Dynamic /app/project/42 must match with correct param
+		const detailMatches = matchRoutes(tree, new URL('http://localhost/app/project/42'))
+		expect(detailMatches).not.toBeNull()
+		const detailLeaf = detailMatches![detailMatches!.length - 1]
+		expect(detailLeaf.node.fullPath).toBe('/app/project/:id')
+		expect(detailLeaf.params).toEqual({ id: '42' })
+
+		// Nested /app/project/42/edit must match and include layout chain
+		const editMatches = matchRoutes(tree, new URL('http://localhost/app/project/42/edit'))
+		expect(editMatches).not.toBeNull()
+		expect(editMatches!.length).toBeGreaterThanOrEqual(3) // root layout + app layout + detail layout + edit page
+		const editLeaf = editMatches![editMatches!.length - 1]
+		expect(editLeaf.node.fullPath).toBe('/app/project/:id/edit')
+		expect(editLeaf.params).toEqual({ id: '42' })
+
+		// Layout chain must include the detail layout
+		const detailLayout = editMatches!.find(m => m.node.isLayout && m.node.fullPath === '/app/project/detail')
+		expect(detailLayout).toBeDefined()
+
+		// /app/project (index) must match
+		const listMatches = matchRoutes(tree, new URL('http://localhost/app/project'))
+		expect(listMatches).not.toBeNull()
+		const listLeaf = listMatches![listMatches!.length - 1]
+		expect(listLeaf.node.fullPath).toBe('/app/project')
+
+		// /app/dashboard must still work
+		const dashMatches = matchRoutes(tree, new URL('http://localhost/app/dashboard'))
+		expect(dashMatches).not.toBeNull()
+		expect(dashMatches![dashMatches!.length - 1].node.fullPath).toBe('/app/dashboard')
+	})
+
+	it('handles multiple resources with matchPath: create vs :id pattern', () => {
+		// Tests the pattern repeated across organization, voucher, feature-flag-set, etc.
+		const tree = createTestTree([
+			{
+				path: '/',
+				component: dummyComponent,
+				isLayout: true,
+				children: [
+					{ path: '/organization/create', component: dummyComponent },
+					{ path: '/organization/edit', matchPath: '/organization/:id', component: dummyComponent },
+					{ path: '/organization', component: dummyComponent },
+					{ path: '/voucher/create', component: dummyComponent },
+					{ path: '/voucher/edit', matchPath: '/voucher/:id', component: dummyComponent },
+					{ path: '/voucher', component: dummyComponent },
+				],
+			},
+		])
+
+		// Static create routes
+		const orgCreate = matchRoutes(tree, new URL('http://localhost/organization/create'))
+		expect(orgCreate).not.toBeNull()
+		expect(orgCreate![orgCreate!.length - 1].node.fullPath).toBe('/organization/create')
+		expect(orgCreate![orgCreate!.length - 1].params).toEqual({})
+
+		const voucherCreate = matchRoutes(tree, new URL('http://localhost/voucher/create'))
+		expect(voucherCreate).not.toBeNull()
+		expect(voucherCreate![voucherCreate!.length - 1].node.fullPath).toBe('/voucher/create')
+
+		// Dynamic :id routes
+		const orgEdit = matchRoutes(tree, new URL('http://localhost/organization/abc-123'))
+		expect(orgEdit).not.toBeNull()
+		expect(orgEdit![orgEdit!.length - 1].node.fullPath).toBe('/organization/:id')
+		expect(orgEdit![orgEdit!.length - 1].params).toEqual({ id: 'abc-123' })
+
+		const voucherEdit = matchRoutes(tree, new URL('http://localhost/voucher/xyz'))
+		expect(voucherEdit).not.toBeNull()
+		expect(voucherEdit![voucherEdit!.length - 1].node.fullPath).toBe('/voucher/:id')
+		expect(voucherEdit![voucherEdit!.length - 1].params).toEqual({ id: 'xyz' })
+
+		// Index routes
+		const orgList = matchRoutes(tree, new URL('http://localhost/organization'))
+		expect(orgList).not.toBeNull()
+		expect(orgList![orgList!.length - 1].node.fullPath).toBe('/organization')
+	})
+
+	it('handles deeply nested matchPath with multiple dynamic segments', () => {
+		// Mirrors: /app/project/:id/debug/:sessionId/llm-calls/:callId
+		const tree = createTestTree([
+			{
+				path: '/',
+				component: dummyComponent,
+				isLayout: true,
+				children: [
+					{
+						path: '/project/detail',
+						component: dummyComponent,
+						isLayout: true,
+						children: [
+							{ path: '/', matchPath: '/project/:id', component: dummyComponent, isIndex: true },
+							{
+								path: '/debug',
+								component: dummyComponent,
+								isLayout: true,
+								children: [
+									{ path: '/', matchPath: '/project/:id/debug', component: dummyComponent, isIndex: true },
+									{ path: '/llm-calls', matchPath: '/project/:id/debug/:sessionId/llm-calls', component: dummyComponent },
+									{ path: '/llm-call', matchPath: '/project/:id/debug/:sessionId/llm-calls/:callId', component: dummyComponent },
+								],
+							},
+						],
+					},
+				],
+			},
+		])
+
+		// Multi-segment dynamic match
+		const callMatches = matchRoutes(tree, new URL('http://localhost/project/p1/debug/s2/llm-calls/c3'))
+		expect(callMatches).not.toBeNull()
+		const callLeaf = callMatches![callMatches!.length - 1]
+		expect(callLeaf.node.fullPath).toBe('/project/:id/debug/:sessionId/llm-calls/:callId')
+		expect(callLeaf.params).toEqual({ id: 'p1', sessionId: 's2', callId: 'c3' })
+
+		// Shorter dynamic match at same prefix
+		const listMatches = matchRoutes(tree, new URL('http://localhost/project/p1/debug/s2/llm-calls'))
+		expect(listMatches).not.toBeNull()
+		const listLeaf = listMatches![listMatches!.length - 1]
+		expect(listLeaf.node.fullPath).toBe('/project/:id/debug/:sessionId/llm-calls')
+		expect(listLeaf.params).toEqual({ id: 'p1', sessionId: 's2' })
+
+		// Debug index
+		const debugMatches = matchRoutes(tree, new URL('http://localhost/project/p1/debug'))
+		expect(debugMatches).not.toBeNull()
+		expect(debugMatches![debugMatches!.length - 1].node.fullPath).toBe('/project/:id/debug')
+		expect(debugMatches![debugMatches!.length - 1].params).toEqual({ id: 'p1' })
+	})
+
 	it('does not match partial paths', () => {
 		const tree = createTestTree([
 			{ path: '/about', component: dummyComponent },

package/src/__tests__/router.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it, mock } from 'bun:test'
+import { matchRoutes } from '../engine/matcher.js'
 import { createMemoryNavigationAdapter } from '../engine/navigation-adapter.js'
 import { buildRouteTree } from '../engine/route-tree.js'
 import { Router } from '../engine/router.js'
@@ -120,9 +121,14 @@ describe('Router', () => {
 			},
 		])
 
-		expect(routes[0].id).toBe('route:/:layout')
-		expect(routes[0].children[0].id).toBe('route:/')
-		expect(routes[0].children[1].id).toBe('route:/about')
+		// Verify IDs through matching
+		const indexMatches = matchRoutes(routes, new URL('http://localhost/'))!
+		expect(indexMatches[0].node.id).toBe('route:/:layout')
+		expect(indexMatches[1].node.id).toBe('route:/')
+
+		const aboutMatches = matchRoutes(routes, new URL('http://localhost/about'))!
+		expect(aboutMatches[0].node.id).toBe('route:/:layout')
+		expect(aboutMatches[1].node.id).toBe('route:/about')
 	})
 })
 

package/src/engine/matcher.ts

@@ -1,111 +1,67 @@
-import type { RouteMatch, RouteNode } from './types.js'
+import type { RouteMatch, RouteTree, TrieNode } from './types.js'
 
 /**
- * Match a URL against the route tree.
+ * Match a URL against the route trie.
  * Returns an array of RouteMatch from root layout to leaf page, or null if no match.
- * When multiple routes match, selects the most specific one (fewest dynamic params).
+ *
+ * Matching priority is structural: static segments are always checked before
+ * dynamic segments, which are checked before catch-all segments.
  */
-export function matchRoutes(nodes: RouteNode[], url: URL): RouteMatch[] | null {
+export function matchRoutes(tree: RouteTree, url: URL): RouteMatch[] | null {
 	const pathname = url.pathname
-	return pickBestMatch(nodes, pathname)
+	const segments = pathname.split('/').filter(Boolean)
+	return matchTrie(tree.root, segments, 0, {}, pathname)
 }
 
-/**
- * Find the best match among sibling nodes.
- * Tries all siblings and picks the most specific match (fewest dynamic params).
- */
-function pickBestMatch(nodes: RouteNode[], pathname: string): RouteMatch[] | null {
-	let best: RouteMatch[] | null = null
-	let bestParamCount = Infinity
-
-	for (const node of nodes) {
-		const result = matchNode(node, pathname)
-		if (result) {
-			const paramCount = countParams(result)
-			if (paramCount < bestParamCount) {
-				best = result
-				bestParamCount = paramCount
-				if (paramCount === 0) break // Can't do better than zero params
-			}
+function matchTrie(
+	node: TrieNode,
+	segments: string[],
+	index: number,
+	params: Record<string, string>,
+	pathname: string,
+): RouteMatch[] | null {
+	// All segments consumed — check if this trie node has a terminal route
+	if (index === segments.length) {
+		if (node.route) {
+			return buildMatchChain(node.route.chain, params, pathname)
 		}
+		return null
 	}
 
-	return best
-}
+	const segment = segments[index]
 
-/**
- * Count total dynamic params across all matches in a chain.
- */
-function countParams(matches: RouteMatch[]): number {
-	let count = 0
-	for (const match of matches) {
-		count += Object.keys(match.params).length
+	// 1. Try static child first — O(1) Map lookup, always most specific
+	const staticChild = node.staticChildren.get(segment)
+	if (staticChild) {
+		const result = matchTrie(staticChild, segments, index + 1, params, pathname)
+		if (result) return result
 	}
-	return count
-}
 
-function matchNode(node: RouteNode, pathname: string): RouteMatch[] | null {
-	// Layout nodes: try to match children, prepend self if any child matches
-	if (node.isLayout && !node.isIndex) {
-		const childMatch = pickBestMatch(node.children, pathname)
-		if (childMatch) {
-			const layoutMatch: RouteMatch = {
-				node,
-				params: extractLayoutParams(node, pathname),
-				pathname,
-			}
-			return [layoutMatch, ...childMatch]
-		}
-		return null
+	// 2. Try dynamic child — matches any single segment
+	if (node.dynamicChild) {
+		const newParams = { ...params, [node.dynamicChild.paramName]: decodeURIComponent(segment) }
+		const result = matchTrie(node.dynamicChild.node, segments, index + 1, newParams, pathname)
+		if (result) return result
 	}
 
-	// Leaf/index nodes: try to match the URLPattern
-	if (node.pattern) {
-		const result = node.pattern.exec({ pathname })
-		if (result) {
-			const params = extractParamsFromResult(result)
-			const match: RouteMatch = { node, params, pathname }
-
-			// If this node has children (e.g., a page with nested routes), try them too
-			if (node.children.length > 0) {
-				const childMatch = pickBestMatch(node.children, pathname)
-				if (childMatch) {
-					return [match, ...childMatch]
-				}
-			}
-
-			return [match]
-		}
+	// 3. Try catch-all child — consumes all remaining segments
+	if (node.catchAllChild) {
+		const remaining = segments.slice(index).map(s => decodeURIComponent(s)).join('/')
+		const newParams = { ...params, [node.catchAllChild.paramName]: remaining }
+		return buildMatchChain(node.catchAllChild.chain, newParams, pathname)
 	}
 
 	return null
 }
 
 /**
- * Extract params from a URLPattern exec result.
- */
-function extractParamsFromResult(result: URLPatternResult): Record<string, string> {
-	const params: Record<string, string> = {}
-	const groups = result.pathname.groups
-	for (const [key, value] of Object.entries(groups)) {
-		// Skip unnamed groups (numeric keys from wildcards/optionals)
-		if (value !== undefined && !/^\d+$/.test(key)) {
-			params[key] = value
-		}
-	}
-	return params
-}
-
-/**
- * Extract params from a layout node using its prefix URLPattern.
- * Falls back to empty params if no prefix pattern is available.
+ * Build a RouteMatch[] array from a chain of RouteNodes and collected params.
+ * Each match in the chain gets all collected params (they're merged by the React layer anyway).
  */
-function extractLayoutParams(node: RouteNode, pathname: string): Record<string, string> {
-	if (node.prefixPattern) {
-		const result = node.prefixPattern.exec({ pathname })
-		if (result) {
-			return extractParamsFromResult(result)
-		}
-	}
-	return {}
+function buildMatchChain(
+	chain: import('./types.js').RouteNode[],
+	params: Record<string, string>,
+	pathname: string,
+): RouteMatch[] {
+	return chain.map(node => ({ node, params, pathname }))
 }

package/src/engine/route-tree.ts

@@ -1,23 +1,6 @@
-import type { RouteComponent, RouteConfig, RouteNode, StandardSchema } from './types.js'
+import type { RouteComponent, RouteConfig, RouteNode, RouteTree, StandardSchema, TrieNode } from './types.js'
 
-/**
- * Normalize a path segment — ensure it starts with "/" and strip trailing slashes.
- */
-function normalizePath(path: string): string {
-	if (path === '' || path === '/') return '/'
-	const p = path.startsWith('/') ? path : `/${path}`
-	return p.endsWith('/') ? p.slice(0, -1) : p
-}
-
-/**
- * Join two path segments.
- */
-function joinPaths(parent: string, child: string): string {
-	if (child === '/') return parent === '/' ? '/' : parent
-	const base = parent === '/' ? '' : parent
-	const segment = child.startsWith('/') ? child : `/${child}`
-	return base + segment
-}
+// ─── Public API ─────────────────────────────────────────────────────────────
 
 export interface CreateRouteNodeOptions {
 	path: string
@@ -25,14 +8,12 @@ export interface CreateRouteNodeOptions {
 	component?: RouteComponent
 	searchSchema?: StandardSchema
 	preload?: () => void
-	children?: RouteNode[]
-	parent?: RouteNode
 	isLayout?: boolean
 	isIndex?: boolean
 }
 
 /**
- * Create a route node with a compiled URLPattern.
+ * Create a route node (layout or page entry in a match chain).
  */
 export function createRouteNode(options: CreateRouteNodeOptions): RouteNode {
 	const {
@@ -41,59 +22,51 @@ export function createRouteNode(options: CreateRouteNodeOptions): RouteNode {
 		component,
 		searchSchema,
 		preload,
-		children = [],
-		parent,
 		isLayout = false,
 		isIndex = false,
 	} = options
 
-	// Build the pattern — layouts get a prefix pattern for param extraction,
-	// index and leaf routes get an exact pattern for matching.
-	let pattern: URLPattern | undefined
-	let prefixPattern: URLPattern | undefined
-	if (!isLayout || isIndex) {
-		const p = fullPath === '' ? '/' : fullPath
-		pattern = new URLPattern({ pathname: p === '/' ? p : `${p}{/}?` })
-	}
-	if (isLayout && !isIndex) {
-		// Layouts get a prefix pattern that matches any path starting with their fullPath.
-		// The {/.*}? suffix optionally matches a trailing slash and anything after.
-		const prefix = fullPath === '' || fullPath === '/' ? '/' : fullPath
-		prefixPattern = new URLPattern({ pathname: prefix === '/' ? '/{.*}?' : `${prefix}{/.*}?` })
-	}
-
-	const node: RouteNode = {
+	return {
 		id: `route:${fullPath || '/'}${isLayout ? ':layout' : ''}`,
 		path: normalizePath(path),
 		fullPath: normalizePath(fullPath),
-		pattern,
-		prefixPattern,
 		component,
 		searchSchema,
 		preload,
-		children,
-		parent,
 		isLayout,
 		isIndex,
 	}
+}
+
+/**
+ * Build a route tree (segment trie) from an array of RouteConfig.
+ *
+ * Two phases:
+ * 1. Flatten the nested RouteConfig tree into leaf routes, each with its layout chain.
+ * 2. Insert each leaf route into a segment trie for O(segments) matching.
+ */
+export function buildRouteTree(configs: RouteConfig[], parentPath = ''): RouteTree {
+	const entries = flattenConfigs(configs, parentPath, [])
+	const root = createTrieNode()
 
-	// Set parent reference on children
-	for (const child of node.children) {
-		child.parent = node
+	for (const entry of entries) {
+		insertIntoTrie(root, entry.pattern, entry.chain)
 	}
 
-	return node
+	return { root }
 }
 
-/**
- * Build a route tree from an array of RouteConfig.
- */
-export function buildRouteTree(configs: RouteConfig[], parentPath = ''): RouteNode[] {
-	return buildRouteNodes(configs, parentPath)
+// ─── Phase 1: Flatten RouteConfig tree ──────────────────────────────────────
+
+interface FlatEntry {
+	/** The URL pattern for matching (e.g., "/project/:id/edit"). */
+	pattern: string
+	/** Layout chain from root to leaf — each becomes a RouteMatch. */
+	chain: RouteNode[]
 }
 
-function buildRouteNodes(configs: RouteConfig[], parentPath: string): RouteNode[] {
-	const nodes: RouteNode[] = []
+function flattenConfigs(configs: RouteConfig[], parentPath: string, layoutChain: RouteNode[]): FlatEntry[] {
+	const entries: FlatEntry[] = []
 
 	for (const config of configs) {
 		const segment = config.isPathlessGroup ? '' : config.path
@@ -110,23 +83,96 @@ function buildRouteNodes(configs: RouteConfig[], parentPath: string): RouteNode[
 			fullPath = joinPaths(parentPath || '/', segment)
 		}
 
-		const children = config.children
-			? buildRouteNodes(config.children, config.isPathlessGroup ? parentPath : fullPath)
-			: []
-
 		const node = createRouteNode({
 			path: segment,
 			fullPath,
 			component: config.component,
 			searchSchema: config.searchSchema,
 			preload: config.preload,
-			children,
 			isLayout,
 			isIndex,
 		})
 
-		nodes.push(node)
+		if (isLayout) {
+			// Layout: add to chain and recurse children
+			const newChain = [...layoutChain, node]
+			if (config.children) {
+				const childParent = config.isPathlessGroup ? parentPath : fullPath
+				entries.push(...flattenConfigs(config.children, childParent, newChain))
+			}
+		} else {
+			// Leaf route: create entry with full chain
+			entries.push({
+				pattern: fullPath,
+				chain: [...layoutChain, node],
+			})
+		}
+	}
+
+	return entries
+}
+
+// ─── Phase 2: Trie construction ─────────────────────────────────────────────
+
+function createTrieNode(): TrieNode {
+	return { staticChildren: new Map() }
+}
+
+function insertIntoTrie(root: TrieNode, pattern: string, chain: RouteNode[]): void {
+	const segments = splitPathSegments(pattern)
+	let node = root
+
+	for (let i = 0; i < segments.length; i++) {
+		const segment = segments[i]
+
+		if (segment.startsWith(':') && (segment.endsWith('+') || segment.endsWith('*'))) {
+			// Catch-all segment — consumes all remaining segments
+			const paramName = segment.slice(1, -1)
+			node.catchAllChild = { paramName, chain }
+			return
+		}
+
+		if (segment.startsWith(':')) {
+			// Dynamic segment
+			const paramName = segment.slice(1)
+			if (!node.dynamicChild) {
+				node.dynamicChild = { paramName, node: createTrieNode() }
+			}
+			node = node.dynamicChild.node
+		} else {
+			// Static segment
+			let child = node.staticChildren.get(segment)
+			if (!child) {
+				child = createTrieNode()
+				node.staticChildren.set(segment, child)
+			}
+			node = child
+		}
 	}
 
-	return nodes
+	// Terminal — route matches at this trie node
+	node.route = { chain }
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+/**
+ * Split a path pattern into segments, filtering out empty strings.
+ * "/app/project/:id" → ["app", "project", ":id"]
+ */
+function splitPathSegments(pattern: string): string[] {
+	return pattern.split('/').filter(Boolean)
+}
+
+function normalizePath(path: string): string {
+	if (path === '' || path === '/') return '/'
+	const p = path.startsWith('/') ? path : `/${path}`
+	return p.endsWith('/') ? p.slice(0, -1) : p
+}
+
+function joinPaths(parent: string, child: string): string {
+	if (child === '/') return parent === '/' ? '/' : parent
+	const base = parent === '/' ? '' : parent
+	const segment = child.startsWith('/') ? child : `/${child}`
+	return base + segment
 }