@esportsplus/routing 0.7.2 → 0.7.4

package/README.md

@@ -88,26 +88,22 @@ const loggerMiddleware: Middleware<Response> = (req, next) => {
     return next(req);
 };
 
-// Apply global middleware and dispatch
-app.middleware(loggerMiddleware).dispatch;
+// Apply middleware chain — match route, log, then dispatch to route handler
+let matchMiddleware = app.middleware.match(notFound);
+
+app.middleware(matchMiddleware, loggerMiddleware, app.middleware.dispatch);
 ```
 
-### Reactive Matching
+### Fallback Route
 
 ```typescript
-// Create fallback route
+// Create fallback route for unmatched paths
 const notFound: Route<Response> = {
     name: 'not-found',
     path: null,
-    pipeline: pipeline<Request<Response>, Response>(),
+    middleware: (req) => renderNotFound(),
     subdomain: null
 };
-
-// Middleware that reactively matches routes
-const matchMiddleware = app.middleware.match(notFound);
-
-// Compose and dispatch
-app.middleware(matchMiddleware, loggerMiddleware).dispatch;
 ```
 
 ### Route Groups
@@ -138,8 +134,8 @@ const apiRoutes: RouteFactory<Response> = (r) => r
 // Required parameter
 .get({ name: 'user', path: '/users/:id', responder })
 
-// Optional parameter (prefix with ?)
-.get({ name: 'archive', path: '/posts/?:year/?:month', responder })
+// Optional parameter (prefix with ?:, no preceding /)
+.get({ name: 'archive', path: '/posts?:year?:month', responder })
 
 // Wildcard (captures rest of path)
 .get({ name: 'files', path: '/files/*:path', responder })
@@ -187,7 +183,7 @@ type Request<T> = {
 type Route<T> = {
     name: string | null;
     path: string | null;
-    pipeline: Pipeline<Request<T>, T>;
+    middleware: Middleware<T>[] | Next<T>;
     subdomain: string | null;
 };
 ```

package/build/client/index.d.ts

@@ -10,7 +10,6 @@ declare const router: <const Factories extends readonly RouteFactory<any>[]>(...
         match(fallback: Route<InferOutput<Factories[number]>>): (request: Request<InferOutput<Factories[number]>>, next: Next<InferOutput<Factories[number]>>) => InferOutput<Factories[number]>;
     };
     redirect: <RouteName extends keyof AccumulateRoutes<Factories>>(name: RouteName, ...values: ExtractRequiredParams<RoutePath<AccumulateRoutes<Factories>, RouteName>> extends never ? ExtractOptionalParams<RoutePath<AccumulateRoutes<Factories>, RouteName>> extends never ? [] : [params?: PathParamsObject<RoutePath<AccumulateRoutes<Factories>, RouteName>>] : [params: PathParamsObject<RoutePath<AccumulateRoutes<Factories>, RouteName>>]) => void;
-    routes: Record<string, Route<InferOutput<Factories[number]>>>;
     uri: <RouteName extends keyof AccumulateRoutes<Factories>>(name: RouteName, ...values: ExtractRequiredParams<RoutePath<AccumulateRoutes<Factories>, RouteName>> extends never ? ExtractOptionalParams<RoutePath<AccumulateRoutes<Factories>, RouteName>> extends never ? [] : [params?: PathParamsObject<RoutePath<AccumulateRoutes<Factories>, RouteName>>] : [params: PathParamsObject<RoutePath<AccumulateRoutes<Factories>, RouteName>>]) => string;
 };
 export { router };

package/build/client/index.js

@@ -1,26 +1,26 @@
-import * as reactivity_ffa278ace0bb4e959ff55da8933387190 from '@esportsplus/reactivity';
+import * as reactivity_b6d4b87c525e4841a152a715c8109b3e0 from '@esportsplus/reactivity';
 import { effect, root } from '@esportsplus/reactivity';
 import { Router } from './router/index.js';
 import { PACKAGE_NAME } from './constants.js';
-class ReactiveObject_ffa278ace0bb4e959ff55da8933387191 extends reactivity_ffa278ace0bb4e959ff55da8933387190.ReactiveObject {
+class ReactiveObject_b6d4b87c525e4841a152a715c8109b3e1 extends reactivity_b6d4b87c525e4841a152a715c8109b3e0.ReactiveObject {
     #parameters;
     #route;
     constructor(_p0, _p1) {
         super(null);
-        this.#parameters = this[reactivity_ffa278ace0bb4e959ff55da8933387190.SIGNAL](_p0);
-        this.#route = this[reactivity_ffa278ace0bb4e959ff55da8933387190.SIGNAL](_p1);
+        this.#parameters = this[reactivity_b6d4b87c525e4841a152a715c8109b3e0.SIGNAL](_p0);
+        this.#route = this[reactivity_b6d4b87c525e4841a152a715c8109b3e0.SIGNAL](_p1);
     }
     get parameters() {
-        return reactivity_ffa278ace0bb4e959ff55da8933387190.read(this.#parameters);
+        return reactivity_b6d4b87c525e4841a152a715c8109b3e0.read(this.#parameters);
     }
     set parameters(_v0) {
-        reactivity_ffa278ace0bb4e959ff55da8933387190.write(this.#parameters, _v0);
+        reactivity_b6d4b87c525e4841a152a715c8109b3e0.write(this.#parameters, _v0);
     }
     get route() {
-        return reactivity_ffa278ace0bb4e959ff55da8933387190.read(this.#route);
+        return reactivity_b6d4b87c525e4841a152a715c8109b3e0.read(this.#route);
     }
     set route(_v1) {
-        reactivity_ffa278ace0bb4e959ff55da8933387190.write(this.#route, _v1);
+        reactivity_b6d4b87c525e4841a152a715c8109b3e0.write(this.#route, _v1);
     }
 }
 let cache = [], location = window.location;
@@ -90,7 +90,7 @@ function middleware(request, router) {
         return route.middleware(request);
     };
     host.match = (fallback) => {
-        let state = new ReactiveObject_ffa278ace0bb4e959ff55da8933387191(undefined, undefined);
+        let state = new ReactiveObject_b6d4b87c525e4841a152a715c8109b3e1(undefined, undefined);
         if (fallback === undefined) {
             throw new Error(`${PACKAGE_NAME}: fallback route does not exist`);
         }
@@ -130,7 +130,7 @@ function onpopstate() {
     }
 }
 const router = (...factories) => {
-    let instance = factories.reduce((r, factory) => factory(r), new Router()), request = reactivity_ffa278ace0bb4e959ff55da8933387190.reactive(Object.assign(href(), { data: {} }));
+    let instance = factories.reduce((r, factory) => factory(r), new Router()), request = reactivity_b6d4b87c525e4841a152a715c8109b3e0.reactive(Object.assign(href(), { data: {} }));
     if (cache.push(request) === 1) {
         window.addEventListener('hashchange', onpopstate);
     }
@@ -144,7 +144,6 @@ const router = (...factories) => {
             }
             window.location.hash = normalize(instance.uri(name, values));
         },
-        routes: instance.routes,
         uri: (name, ...values) => {
             return normalize(instance.uri(name, values));
         }

package/build/client/router/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/client/router/index.test.js

@@ -0,0 +1,245 @@
+import { describe, expect, it } from 'vitest';
+import { Router } from './index.js';
+function responder(label) {
+    return () => label;
+}
+function mw(label) {
+    return (_input, next) => label + ':' + next(_input);
+}
+describe('Router', () => {
+    describe('match()', () => {
+        it('matches static GET path', () => {
+            let router = new Router();
+            router.get({ path: '/home', responder: responder('home') });
+            let result = router.match('GET', '/home');
+            expect(result.route).toBeDefined();
+            expect(result.route.path).toBe('/home');
+        });
+        it('matches dynamic path with parameters', () => {
+            let router = new Router();
+            router.get({ path: '/users/:id', responder: responder('user') });
+            let result = router.match('GET', '/users/42');
+            expect(result.route).toBeDefined();
+            expect(result.parameters).toEqual({ id: '42' });
+        });
+        it('returns empty for unregistered method', () => {
+            let router = new Router();
+            router.get({ path: '/home', responder: responder('home') });
+            let result = router.match('POST', '/home');
+            expect(result.route).toBeUndefined();
+        });
+        it('returns empty for unregistered path', () => {
+            let router = new Router();
+            router.get({ path: '/home', responder: responder('home') });
+            let result = router.match('GET', '/missing');
+            expect(result.route).toBeUndefined();
+        });
+        it('normalizes path (adds leading /, strips trailing /)', () => {
+            let router = new Router();
+            router.get({ path: '/users', responder: responder('users') });
+            let noLeading = router.match('GET', 'users'), trailing = router.match('GET', '/users/');
+            expect(noLeading.route).toBeDefined();
+            expect(noLeading.route.path).toBe('/users');
+            expect(trailing.route).toBeDefined();
+            expect(trailing.route.path).toBe('/users');
+        });
+        it('matches with subdomain bucketing', () => {
+            let router = new Router();
+            router.get({ path: '/api', responder: responder('api'), subdomain: 'api' });
+            let withSubdomain = router.match('GET', '/api', 'api'), withoutSubdomain = router.match('GET', '/api');
+            expect(withSubdomain.route).toBeDefined();
+            expect(withoutSubdomain.route).toBeUndefined();
+        });
+        it('static match takes priority over tree match', () => {
+            let router = new Router(), dynamicResponder = responder('dynamic'), staticResponder = responder('static');
+            router.get({ path: '/users/:id', responder: dynamicResponder });
+            router.get({ path: '/users/all', responder: staticResponder });
+            let result = router.match('GET', '/users/all');
+            expect(result.route).toBeDefined();
+            expect(result.route.path).toBe('/users/all');
+            expect(result.route.middleware).toContain(staticResponder);
+        });
+    });
+    describe('on()', () => {
+        it('registers route for single method', () => {
+            let router = new Router();
+            router.on(['GET'], { path: '/test', responder: responder('test') });
+            let result = router.match('GET', '/test');
+            expect(result.route).toBeDefined();
+        });
+        it('registers route for multiple methods', () => {
+            let router = new Router();
+            router.on(['GET', 'POST'], { path: '/test', responder: responder('test') });
+            let getResult = router.match('GET', '/test'), postResult = router.match('POST', '/test');
+            expect(getResult.route).toBeDefined();
+            expect(postResult.route).toBeDefined();
+        });
+        it('throws on duplicate route name', () => {
+            let router = new Router();
+            router.on(['GET'], { name: 'home', path: '/home', responder: responder('home') });
+            expect(() => {
+                router.on(['GET'], { name: 'home', path: '/home2', responder: responder('home2') });
+            }).toThrow("@esportsplus/routing: 'home' is already in use");
+        });
+        it('throws on duplicate static path', () => {
+            let router = new Router();
+            router.on(['GET'], { path: '/home', responder: responder('home1') });
+            expect(() => {
+                router.on(['GET'], { path: '/home', responder: responder('home2') });
+            }).toThrow("@esportsplus/routing: static path '/home' is already in use");
+        });
+        it('expands optional parameters', () => {
+            let router = new Router();
+            router.on(['GET'], { path: '/users?:id', responder: responder('users') });
+            let base = router.match('GET', '/users'), withParam = router.match('GET', '/users/42');
+            expect(base.route).toBeDefined();
+            expect(withParam.route).toBeDefined();
+            expect(withParam.parameters).toEqual({ id: '42' });
+        });
+        it('registers subdomain (lowercased)', () => {
+            let router = new Router();
+            router.on(['GET'], { path: '/test', responder: responder('test'), subdomain: 'API' });
+            expect(router.subdomains).toContain('api');
+        });
+        it('normalizes www subdomain to empty string', () => {
+            let router = new Router();
+            router.on(['GET'], { path: '/test', responder: responder('test'), subdomain: 'www' });
+            let result = router.match('GET', '/test', '');
+            expect(result.route).toBeDefined();
+            expect(router.subdomains).toBeNull();
+        });
+        it('expands multiple optional parameters', () => {
+            let router = new Router();
+            router.on(['GET'], { path: '/items?:a?:b', responder: responder('items') });
+            let base = router.match('GET', '/items'), oneParam = router.match('GET', '/items/x'), twoParams = router.match('GET', '/items/x/y');
+            expect(base.route).toBeDefined();
+            expect(oneParam.route).toBeDefined();
+            expect(oneParam.parameters).toEqual({ a: 'x' });
+            expect(twoParams.route).toBeDefined();
+            expect(twoParams.parameters).toEqual({ a: 'x', b: 'y' });
+        });
+        it('stores named route in routes registry', () => {
+            let router = new Router();
+            router.on(['GET'], { name: 'dashboard', path: '/dashboard', responder: responder('dash') });
+            expect(router.routes['dashboard']).toBeDefined();
+            expect(router.routes['dashboard'].path).toBe('/dashboard');
+        });
+    });
+    describe('uri()', () => {
+        it('generates static URI (no params)', () => {
+            let router = new Router();
+            router.get({ name: 'home', path: '/home', responder: responder('home') });
+            let uri = router.uri('home');
+            expect(uri).toBe('/home');
+        });
+        it('generates URI with required params', () => {
+            let router = new Router();
+            router.get({ name: 'user', path: '/users/:id', responder: responder('user') });
+            let uri = router.uri('user', [42]);
+            expect(uri).toBe('/users/42');
+        });
+        it('generates URI with optional params present', () => {
+            let router = new Router();
+            router.get({ name: 'users', path: '/users/?:id', responder: responder('users') });
+            let uri = router.uri('users', [7]);
+            expect(uri).toBe('/users/7');
+        });
+        it('generates URI with optional params absent (stops at first missing)', () => {
+            let router = new Router();
+            router.get({ name: 'users', path: '/users/?:id', responder: responder('users') });
+            let uri = router.uri('users');
+            expect(uri).toBe('/users');
+        });
+        it('generates URI with wildcard params', () => {
+            let router = new Router();
+            router.get({ name: 'files', path: '/files/*:path', responder: responder('files') });
+            let uri = router.uri('files', ['docs', 'readme.txt']);
+            expect(uri).toBe('/files/docs/readme.txt');
+        });
+        it('throws for non-existent route name', () => {
+            let router = new Router();
+            expect(() => {
+                router.uri('missing');
+            }).toThrow("@esportsplus/routing: route name 'missing' does not exist or it does not provide a path");
+        });
+    });
+    describe('group()', () => {
+        it('prefixes path to child routes', () => {
+            let router = new Router();
+            router.group({ path: '/api' }).routes((r) => {
+                r.get({ path: '/users', responder: responder('users') });
+            });
+            let result = router.match('GET', '/api/users');
+            expect(result.route).toBeDefined();
+        });
+        it('cascades middleware to child routes', () => {
+            let router = new Router(), authMw = mw('auth');
+            router.group({ middleware: [authMw] }).routes((r) => {
+                r.get({ path: '/protected', responder: responder('protected') });
+            });
+            let result = router.match('GET', '/protected');
+            expect(result.route).toBeDefined();
+            expect(result.route.middleware).toContain(authMw);
+        });
+        it('applies subdomain to child routes', () => {
+            let router = new Router();
+            router.group({ subdomain: 'api' }).routes((r) => {
+                r.get({ path: '/data', responder: responder('data') });
+            });
+            let withSubdomain = router.match('GET', '/data', 'api'), withoutSubdomain = router.match('GET', '/data');
+            expect(withSubdomain.route).toBeDefined();
+            expect(withoutSubdomain.route).toBeUndefined();
+        });
+        it('cleans up group stack after callback', () => {
+            let router = new Router();
+            router.group({ path: '/api' }).routes((r) => {
+                r.get({ path: '/inner', responder: responder('inner') });
+            });
+            router.get({ path: '/outer', responder: responder('outer') });
+            let inner = router.match('GET', '/api/inner'), outer = router.match('GET', '/outer'), wrongOuter = router.match('GET', '/api/outer');
+            expect(inner.route).toBeDefined();
+            expect(outer.route).toBeDefined();
+            expect(wrongOuter.route).toBeUndefined();
+        });
+        it('handles nested groups (path accumulation)', () => {
+            let router = new Router();
+            router.group({ path: '/api' }).routes((r) => {
+                r.group({ path: '/v1' }).routes((r2) => {
+                    r2.get({ path: '/users', responder: responder('users') });
+                });
+            });
+            let result = router.match('GET', '/api/v1/users');
+            expect(result.route).toBeDefined();
+        });
+    });
+    describe('HTTP method shortcuts', () => {
+        it('get() registers for GET method', () => {
+            let router = new Router();
+            router.get({ path: '/test', responder: responder('test') });
+            let getResult = router.match('GET', '/test'), postResult = router.match('POST', '/test');
+            expect(getResult.route).toBeDefined();
+            expect(postResult.route).toBeUndefined();
+        });
+        it('post() registers for POST method', () => {
+            let router = new Router();
+            router.post({ path: '/test', responder: responder('test') });
+            let getResult = router.match('GET', '/test'), postResult = router.match('POST', '/test');
+            expect(postResult.route).toBeDefined();
+            expect(getResult.route).toBeUndefined();
+        });
+        it('put() registers for PUT method', () => {
+            let router = new Router();
+            router.put({ path: '/test', responder: responder('test') });
+            let putResult = router.match('PUT', '/test'), getResult = router.match('GET', '/test');
+            expect(putResult.route).toBeDefined();
+            expect(getResult.route).toBeUndefined();
+        });
+        it('delete() registers for DELETE method', () => {
+            let router = new Router();
+            router.delete({ path: '/test', responder: responder('test') });
+            let deleteResult = router.match('DELETE', '/test'), getResult = router.match('GET', '/test');
+            expect(deleteResult.route).toBeDefined();
+            expect(getResult.route).toBeUndefined();
+        });
+    });
+});

package/build/client/router/node.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/client/router/node.test.js

@@ -0,0 +1,214 @@
+import { describe, expect, it } from 'vitest';
+import { PARAMETER, STATIC, WILDCARD } from '../constants.js';
+import { Node } from './node.js';
+function route(name) {
+    return { name, path: null, middleware: [], subdomain: null };
+}
+describe('Node', () => {
+    describe('add', () => {
+        it('adds static path (single segment)', () => {
+            let root = new Node(), r = route('home');
+            root.add('home', r);
+            expect(root.static?.get('home')).toBeDefined();
+            expect(root.static?.get('home')?.route).toBe(r);
+        });
+        it('adds multi-segment static path', () => {
+            let root = new Node(), r = route('about-team');
+            root.add('about/team', r);
+            let aboutNode = root.static?.get('about');
+            expect(aboutNode).toBeDefined();
+            expect(aboutNode?.static?.get('team')?.route).toBe(r);
+        });
+        it('adds parameter path and creates parameter child with correct name', () => {
+            let root = new Node(), r = route('user');
+            root.add('users/:id', r);
+            let usersNode = root.static?.get('users');
+            expect(usersNode).toBeDefined();
+            expect(usersNode?.parameter).toBeDefined();
+            expect(usersNode?.parameter?.name).toBe('id');
+            expect(usersNode?.parameter?.route).toBe(r);
+        });
+        it('adds wildcard path and creates wildcard child with correct name', () => {
+            let root = new Node(), r = route('catchall');
+            root.add('files/*:path', r);
+            let filesNode = root.static?.get('files');
+            expect(filesNode).toBeDefined();
+            expect(filesNode?.wildcard).toBeDefined();
+            expect(filesNode?.wildcard?.name).toBe('path');
+            expect(filesNode?.wildcard?.route).toBe(r);
+        });
+        it('adds mixed path (static + parameter segments)', () => {
+            let root = new Node(), r = route('user-post');
+            root.add('users/:id/posts', r);
+            let usersNode = root.static?.get('users');
+            expect(usersNode?.parameter?.name).toBe('id');
+            expect(usersNode?.parameter?.static?.get('posts')?.route).toBe(r);
+        });
+        it('reuses existing static nodes for shared prefixes', () => {
+            let root = new Node(), r1 = route('team'), r2 = route('contact');
+            root.add('about/team', r1);
+            root.add('about/contact', r2);
+            let aboutNode = root.static?.get('about');
+            expect(aboutNode?.static?.get('team')?.route).toBe(r1);
+            expect(aboutNode?.static?.get('contact')?.route).toBe(r2);
+        });
+        it('reuses existing parameter node', () => {
+            let root = new Node(), r1 = route('user-posts'), r2 = route('user-comments');
+            root.add('users/:id/posts', r1);
+            root.add('users/:id/comments', r2);
+            let paramNode = root.static?.get('users')?.parameter;
+            expect(paramNode?.name).toBe('id');
+            expect(paramNode?.static?.get('posts')?.route).toBe(r1);
+            expect(paramNode?.static?.get('comments')?.route).toBe(r2);
+        });
+        it('handles unnamed parameters with auto-increment naming', () => {
+            let root = new Node(), r = route('unnamed');
+            root.add(':/:', r);
+            expect(root.parameter?.name).toBe('0');
+            expect(root.parameter?.parameter?.name).toBe('1');
+        });
+        it('handles unnamed wildcard parameters', () => {
+            let root = new Node(), r = route('unnamed-wildcard');
+            root.add('files/*:', r);
+            let filesNode = root.static?.get('files');
+            expect(filesNode?.wildcard?.name).toBe('0');
+        });
+        it('sets path, route, and type on terminal node', () => {
+            let root = new Node(), r1 = route('static-route'), r2 = route('param-route'), r3 = route('wild-route');
+            let n1 = root.add('about', r1), n2 = root.add('users/:id', r2), n3 = root.add('files/*:path', r3);
+            expect(n1.path).toBe('about');
+            expect(n1.route).toBe(r1);
+            expect(n1.type).toBe(STATIC);
+            expect(n2.path).toBe('users/:id');
+            expect(n2.route).toBe(r2);
+            expect(n2.type).toBe(PARAMETER);
+            expect(n3.path).toBe('files/*:path');
+            expect(n3.route).toBe(r3);
+            expect(n3.type).toBe(WILDCARD);
+        });
+        it('reuses existing wildcard node', () => {
+            let root = new Node(), r1 = route('catchall-1'), r2 = route('catchall-2');
+            root.add('files/*:path', r1);
+            root.add('docs/*:path', r2);
+            let filesWildcard = root.static?.get('files')?.wildcard, docsWildcard = root.static?.get('docs')?.wildcard;
+            expect(filesWildcard?.route).toBe(r1);
+            expect(docsWildcard?.route).toBe(r2);
+        });
+        it('returns the terminal node', () => {
+            let root = new Node(), r = route('terminal');
+            let result = root.add('a/b/c', r);
+            expect(result).toBeInstanceOf(Node);
+            expect(result.route).toBe(r);
+            expect(result.path).toBe('a/b/c');
+        });
+        it('sets parent on child nodes', () => {
+            let root = new Node(), r = route('user');
+            root.add('users/:id', r);
+            let usersNode = root.static?.get('users');
+            expect(usersNode?.parent).toBe(root);
+            expect(usersNode?.parameter?.parent).toBe(usersNode);
+        });
+    });
+    describe('find', () => {
+        it('finds exact static path', () => {
+            let root = new Node(), r = route('home');
+            root.add('home', r);
+            let result = root.find('home');
+            expect(result.route).toBe(r);
+            expect(result.parameters).toBeUndefined();
+        });
+        it('returns empty object for no match', () => {
+            let root = new Node();
+            root.add('home', route('home'));
+            let result = root.find('about');
+            expect(result.route).toBeUndefined();
+            expect(result.parameters).toBeUndefined();
+        });
+        it('finds parameter path and extracts params', () => {
+            let root = new Node(), r = route('user');
+            root.add('users/:id', r);
+            let result = root.find('users/42');
+            expect(result.route).toBe(r);
+            expect(result.parameters).toEqual({ id: '42' });
+        });
+        it('static segment takes priority over parameter', () => {
+            let root = new Node(), rStatic = route('users-all'), rParam = route('user-by-id');
+            root.add('users/:id', rParam);
+            root.add('users/all', rStatic);
+            let result = root.find('users/all');
+            expect(result.route).toBe(rStatic);
+            expect(result.parameters).toBeUndefined();
+        });
+        it('falls back to wildcard when no match', () => {
+            let root = new Node(), r = route('catchall');
+            root.add('files/*:path', r);
+            let result = root.find('files/docs/readme.txt');
+            expect(result.route).toBe(r);
+            expect(result.parameters).toEqual({ path: 'docs/readme.txt' });
+        });
+        it('wildcard captures remaining segments joined with /', () => {
+            let root = new Node(), r = route('catchall');
+            root.add('api/*:rest', r);
+            let result = root.find('api/v1/users/42/posts');
+            expect(result.route).toBe(r);
+            expect(result.parameters).toEqual({ rest: 'v1/users/42/posts' });
+        });
+        it('finds mixed static + parameter paths', () => {
+            let root = new Node(), r = route('user-posts');
+            root.add('users/:id/posts', r);
+            let result = root.find('users/7/posts');
+            expect(result.route).toBe(r);
+            expect(result.parameters).toEqual({ id: '7' });
+        });
+        it('returns empty when no parameter node and no static match', () => {
+            let root = new Node();
+            root.add('users/list', route('users-list'));
+            let result = root.find('users/999');
+            expect(result.route).toBeUndefined();
+            expect(result.parameters).toBeUndefined();
+        });
+        it('finds root-level segments', () => {
+            let root = new Node(), r = route('root-param');
+            root.add(':slug', r);
+            let result = root.find('hello');
+            expect(result.route).toBe(r);
+            expect(result.parameters).toEqual({ slug: 'hello' });
+        });
+        it('wildcard fallback when terminal node has no route', () => {
+            let root = new Node(), rWild = route('catchall');
+            root.add('*:rest', rWild);
+            root.add('api/v1/endpoint', route('endpoint'));
+            let result = root.find('api/v1');
+            expect(result.route).toBe(rWild);
+            expect(result.parameters).toEqual({ rest: 'api/v1' });
+        });
+        it('multiple parameters in path', () => {
+            let root = new Node(), r = route('user-post');
+            root.add('users/:userId/posts/:postId', r);
+            let result = root.find('users/5/posts/99');
+            expect(result.route).toBe(r);
+            expect(result.parameters).toEqual({ userId: '5', postId: '99' });
+        });
+        it('finds multi-segment static path', () => {
+            let root = new Node(), r = route('deep');
+            root.add('a/b/c/d', r);
+            let result = root.find('a/b/c/d');
+            expect(result.route).toBe(r);
+            expect(result.parameters).toBeUndefined();
+        });
+        it('returns empty on empty root with no routes', () => {
+            let root = new Node();
+            let result = root.find('anything');
+            expect(result.route).toBeUndefined();
+            expect(result.parameters).toBeUndefined();
+        });
+        it('parameter fallback when static does not exist for segment', () => {
+            let root = new Node(), rParam = route('by-id'), rStatic = route('known');
+            root.add('items/:id', rParam);
+            root.add('items/known', rStatic);
+            let result = root.find('items/unknown-value');
+            expect(result.route).toBe(rParam);
+            expect(result.parameters).toEqual({ id: 'unknown-value' });
+        });
+    });
+});

package/package.json

@@ -28,10 +28,14 @@
   },
   "type": "module",
   "types": "./build/index.d.ts",
-  "version": "0.7.2",
+  "devDependencies": {
+    "vitest": "^4.1.1"
+  },
+  "version": "0.7.4",
   "scripts": {
     "build": "tsc",
-    "build:test": "vite build --config test/vite.config.ts",
+    "build:test": "vite build --config tests/vite.config.ts",
+    "test": "vitest run",
     "-": "-"
   }
 }

package/src/client/index.ts

@@ -187,7 +187,6 @@ const router = <const Factories extends readonly RouteFactory<any>[]>(...factori
 
             window.location.hash = normalize(instance.uri(name as any, values as any));
         },
-        routes: instance.routes,
         uri: <RouteName extends keyof Routes>(
             name: RouteName,
             ...values: ExtractRequiredParams<RoutePath<Routes, RouteName>> extends never