diff --git a/README.md b/README.md
index 719df12..49756ba 100644
--- a/README.md
+++ b/README.md
@@ -52,6 +52,7 @@ const App = () => (
 Primarily meant for use with prerendering via [`@preact/preset-vite`](https://github.com/preactjs/preset-vite#prerendering-configuration) or other prerendering systems that share the API. If you're server-side rendering your app via any other method, you can use `preact-render-to-string` (specifically `renderToStringAsync()`) directly.
 
 ```js
+import { render, hydrate } from 'preact';
 import { LocationProvider, ErrorBoundary, Router, lazy, prerender as ssr } from 'preact-iso';
 
 // Asynchronous (throws a promise)
@@ -67,7 +68,10 @@ const App = () => (
 	</LocationProvider>
 );
 
-hydrate(<App />);
+if (typeof window !== 'undefined') {
+	const target = document.getElementById('app');
+	import.meta.env.DEV ? render(<App />, target) : hydrate(<App />, target);
+}
 
 export async function prerender(data) {
 	return await ssr(<App />);
@@ -270,31 +274,6 @@ const App = () => (
 );
 ```
 
-### `hydrate`
-
-A thin wrapper around Preact's `hydrate` export, it switches between hydrating and rendering the provided element, depending on whether the current page has been prerendered. Additionally, it checks to ensure it's running in a browser context before attempting any rendering, making it a no-op during SSR.
-
-Pairs with the `prerender()` function.
-
-Params:
-
--   `jsx: ComponentChild` - The JSX element or component to render
--   `parent?: Element | Document | ShadowRoot | DocumentFragment` - The parent element to render into. Defaults to `document.body` if not provided.
-
-```js
-import { hydrate } from 'preact-iso';
-
-const App = () => (
-	<div class="app">
-		<h1>Hello World</h1>
-	</div>
-);
-
-hydrate(<App />);
-```
-
-However, it is just a simple utility method. By no means is it essential to use, you can always use Preact's `hydrate` export directly.
-
 ### `prerender`
 
 Renders a Virtual DOM tree to an HTML string using `preact-render-to-string`. The Promise returned from `prerender()` resolves to an Object with `html` and `links[]` properties. The `html` property contains your pre-rendered static HTML markup, and `links` is an Array of any non-external URL strings found in links on the generated page.
diff --git a/package.json b/package.json
index 30a1202..509a3c0 100644
--- a/package.json
+++ b/package.json
@@ -7,10 +7,8 @@
 	"types": "src/index.d.ts",
 	"exports": {
 		".": "./src/index.js",
-		"./router": "./src/router.js",
-		"./lazy": "./src/lazy.js",
 		"./prerender": "./src/prerender.js",
-		"./hydrate": "./src/hydrate.js"
+		"./package.json": "./package.json"
 	},
 	"license": "MIT",
 	"description": "Isomorphic utilities for Preact",
@@ -35,6 +33,11 @@
 		"preact": ">=10",
 		"preact-render-to-string": ">=6.4.0"
 	},
+	"peerDependenciesMeta": {
+		"preact-render-to-string": {
+			"optional": true
+		}
+	},
 	"devDependencies": {
 		"@types/mocha": "^10.0.7",
 		"@types/sinon-chai": "^3.2.12",
diff --git a/src/hydrate.d.ts b/src/hydrate.d.ts
deleted file mode 100644
index 227b5ec..0000000
--- a/src/hydrate.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { ComponentChild, ContainerNode } from 'preact';
-
-export default function hydrate(jsx: ComponentChild, parent?: ContainerNode): void;
diff --git a/src/hydrate.js b/src/hydrate.js
deleted file mode 100644
index 269bc58..0000000
--- a/src/hydrate.js
+++ /dev/null
@@ -1,17 +0,0 @@
-import { render, hydrate as hydrativeRender } from 'preact';
-
-let initialized;
-
-/** @type {typeof hydrativeRender} */
-export default function hydrate(jsx, parent) {
-	if (typeof window === 'undefined') return;
-	let isodata = document.querySelector('script[type=isodata]');
-	// @ts-ignore-next
-	parent = parent || (isodata && isodata.parentNode) || document.body;
-	if (!initialized && isodata) {
-		hydrativeRender(jsx, parent);
-	} else {
-		render(jsx, parent);
-	}
-	initialized = true;
-}
diff --git a/src/index.d.ts b/src/index.d.ts
index 70ba4a2..2cb7567 100644
--- a/src/index.d.ts
+++ b/src/index.d.ts
@@ -1,4 +1,2 @@
-export { default as prerender } from './prerender.js';
+export * from './lazy.js';
 export * from './router.js';
-export { default as lazy, ErrorBoundary } from './lazy.js';
-export { default as hydrate } from './hydrate.js';
diff --git a/src/index.js b/src/index.js
index 3bfc751..2cb7567 100644
--- a/src/index.js
+++ b/src/index.js
@@ -1,7 +1,2 @@
-export { Router, LocationProvider, useLocation, Route, useRoute } from './router.js';
-export { default as lazy, ErrorBoundary } from './lazy.js';
-export { default as hydrate } from './hydrate.js';
-
-export function prerender(vnode, options) {
-	return import('./prerender.js').then(m => m.default(vnode, options));
-}
+export * from './lazy.js';
+export * from './router.js';
diff --git a/src/lazy.d.ts b/src/lazy.d.ts
index 24e3b1b..7841eef 100644
--- a/src/lazy.d.ts
+++ b/src/lazy.d.ts
@@ -1,6 +1,6 @@
 import { ComponentChildren, VNode } from 'preact';
 
-export default function lazy<T>(load: () => Promise<{ default: T } | T>): T & {
+export function lazy<T>(load: () => Promise<{ default: T } | T>): T & {
 	preload: () => Promise<T>;
 };
 
diff --git a/src/lazy.js b/src/lazy.js
index 9fb7fe3..a0feaa2 100644
--- a/src/lazy.js
+++ b/src/lazy.js
@@ -10,7 +10,7 @@ options.__b = (vnode) => {
 	if (oldDiff) oldDiff(vnode);
 };
 
-export default function lazy(load) {
+export function lazy(load) {
 	let p, c;
 
 	const loadModule = () =>
diff --git a/src/prerender.d.ts b/src/prerender.d.ts
index b9958bc..104ba3d 100644
--- a/src/prerender.d.ts
+++ b/src/prerender.d.ts
@@ -9,7 +9,7 @@ export interface PrerenderResult {
 	links?: Set<string>
 }
 
-export default function prerender(
+export function prerender(
 	vnode: VNode,
 	options?: PrerenderOptions
 ): Promise<PrerenderResult>;
diff --git a/src/prerender.js b/src/prerender.js
index 879576f..9ef2211 100644
--- a/src/prerender.js
+++ b/src/prerender.js
@@ -14,7 +14,7 @@ options.vnode = vnode => {
  * @param {object} [options]
  * @param {object} [options.props] Additional props to merge into the root JSX element
  */
-export default async function prerender(vnode, options) {
+export async function prerender(vnode, options) {
 	options = options || {};
 
 	const props = options.props;
@@ -25,7 +25,7 @@ export default async function prerender(vnode, options) {
 		vnode = cloneElement(vnode, props);
 	}
 
-	let links = new Set();
+	const links = new Set();
 	vnodeHook = ({ type, props }) => {
 		if (type === 'a' && props && props.href && (!props.target || props.target === '_self')) {
 			links.add(props.href);
@@ -33,8 +33,7 @@ export default async function prerender(vnode, options) {
 	};
 
 	try {
-		let html = await renderToStringAsync(vnode);
-		html += `<script type="isodata"></script>`;
+		const html = await renderToStringAsync(vnode);
 		return { html, links };
 	} finally {
 		vnodeHook = null;
diff --git a/src/router.d.ts b/src/router.d.ts
index f58d550..d142a08 100644
--- a/src/router.d.ts
+++ b/src/router.d.ts
@@ -9,7 +9,7 @@ type NestedArray<T> = Array<T | NestedArray<T>>;
 
 /**
  * Check if a URL path matches against a URL path pattern.
- * 
+ *
  * Warning: This is an internal API exported only for testing purpose. API could change in future.
  * @param url - URL path (e.g. /user/12345)
  * @param route - URL pattern (e.g. /user/:id)
@@ -38,18 +38,12 @@ export function Router(props: {
 interface LocationHook {
 	url: string;
 	path: string;
-	query: Record<string, string>;
+	pathParams: Record<string, string>;
+	searchParams: Record<string, string>;
 	route: (url: string, replace?: boolean) => void;
 }
 export const useLocation: () => LocationHook;
 
-interface RouteHook {
-	path: string;
-	query: Record<string, string>;
-	params: Record<string, string>;
-}
-export const useRoute: () => RouteHook;
-
 type RoutableProps =
 	| { path: string; default?: false; }
 	| { path?: never; default: true; }
diff --git a/src/router.js b/src/router.js
index ac5d5cc..90290cc 100644
--- a/src/router.js
+++ b/src/router.js
@@ -51,12 +51,12 @@ const UPDATE = (state, url) => {
 export const exec = (url, route, matches = {}) => {
 	url = url.split('/').filter(Boolean);
 	route = (route || '').split('/').filter(Boolean);
-	if (!matches.params) matches.params = {};
+	if (!matches.pathParams) matches.pathParams = {};
 	for (let i = 0, val, rest; i < Math.max(url.length, route.length); i++) {
-		let [, m, param, flag] = (route[i] || '').match(/^(:?)(.*?)([+*?]?)$/);
+		let [, m, pathParam, flag] = (route[i] || '').match(/^(:?)(.*?)([+*?]?)$/);
 		val = url[i];
 		// segment match:
-		if (!m && param == val) continue;
+		if (!m && pathParam == val) continue;
 		// /foo/* match
 		if (!m && val && flag == '*') {
 			matches.rest = '/' + url.slice(i).map(decodeURIComponent).join('/');
@@ -69,8 +69,8 @@ export const exec = (url, route, matches = {}) => {
 		if (rest) val = url.slice(i).map(decodeURIComponent).join('/') || undefined;
 		// normal/optional field:
 		else if (val) val = decodeURIComponent(val);
-		matches.params[param] = val;
-		if (!(param in matches)) matches[param] = val;
+		matches.pathParams[pathParam] = val;
+		if (!(pathParam in matches)) matches[pathParam] = val;
 		if (rest) break;
 	}
 	return matches;
@@ -80,19 +80,19 @@ export const exec = (url, route, matches = {}) => {
  * @type {import('./router.d.ts').LocationProvider}
  */
 export function LocationProvider(props) {
-	// @ts-expect-error - props.url is not implemented correctly & will be removed in the future
-	const [url, route] = useReducer(UPDATE, props.url || location.pathname + location.search);
+	const [url, route] = useReducer(UPDATE, location.pathname + location.search);
 	if (props.scope) scope = props.scope;
 	const wasPush = push === true;
 
 	const value = useMemo(() => {
 		const u = new URL(url, location.origin);
 		const path = u.pathname.replace(/\/+$/g, '') || '/';
-		// @ts-ignore-next
+
 		return {
 			url,
 			path,
-			query: Object.fromEntries(u.searchParams),
+			pathParams: {},
+			searchParams: Object.fromEntries(u.searchParams),
 			route: (url, replace) => route({ url, replace }),
 			wasPush
 		};
@@ -108,7 +108,6 @@ export function LocationProvider(props) {
 		};
 	}, []);
 
-	// @ts-ignore
 	return h(LocationProvider.ctx.Provider, { value }, props.children);
 }
 
@@ -117,8 +116,8 @@ const RESOLVED = Promise.resolve();
 export function Router(props) {
 	const [c, update] = useReducer(c => c + 1, 0);
 
-	const { url, query, wasPush, path } = useLocation();
-	const { rest = path, params = {} } = useContext(RouteContext);
+	const { url, path, pathParams, searchParams, wasPush } = useLocation();
+	const { rest = path } = useContext(RouterContext);
 
 	const isLoading = useRef(false);
 	const prevRoute = useRef(path);
@@ -138,7 +137,7 @@ export function Router(props) {
 
 	let pathRoute, defaultRoute, matchProps;
 	toChildArray(props.children).some((/** @type {VNode<any>} */ vnode) => {
-		const matches = exec(rest, vnode.props.path, (matchProps = { ...vnode.props, path: rest, query, params, rest: '' }));
+		const matches = exec(rest, vnode.props.path, (matchProps = { ...vnode.props, path: rest, pathParams, searchParams }));
 		if (matches) return (pathRoute = cloneElement(vnode, matchProps));
 		if (vnode.props.default) defaultRoute = cloneElement(vnode, matchProps);
 	});
@@ -151,7 +150,7 @@ export function Router(props) {
 	const routeChanged = useMemo(() => {
 		prev.current = cur.current;
 
-		cur.current = /** @type {VNode<any>} */ (h(RouteContext.Provider, { value: matchProps }, incoming));
+		cur.current = /** @type {VNode<any>} */ (h(RouterContext.Provider, { value: matchProps }, incoming));
 
 		// Only mark as an update if the route component changed.
 		const outgoing = prev.current && prev.current.props.children;
@@ -265,11 +264,10 @@ Router.Provider = LocationProvider;
 LocationProvider.ctx = createContext(
 	/** @type {import('./router.d.ts').LocationHook & { wasPush: boolean }} */ ({})
 );
-const RouteContext = createContext(
-	/** @type {import('./router.d.ts').RouteHook & { rest: string }} */ ({})
+const RouterContext = createContext(
+	/** @type {{ rest: string }} */ ({})
 );
 
 export const Route = props => h(props.component, props);
 
 export const useLocation = () => useContext(LocationProvider.ctx);
-export const useRoute = () => useContext(RouteContext);
diff --git a/test/lazy.test.js b/test/lazy.test.js
index 1d29f57..6af6f80 100644
--- a/test/lazy.test.js
+++ b/test/lazy.test.js
@@ -4,7 +4,7 @@ import * as sinon from 'sinon';
 import sinonChai from 'sinon-chai';
 
 import { LocationProvider, Router } from '../src/router.js';
-import lazy, { ErrorBoundary } from '../src/lazy.js';
+import { lazy, ErrorBoundary } from '../src/lazy.js';
 
 import './setup.js';
 
diff --git a/test/node/prerender.test.js b/test/node/prerender.test.js
index 434b151..ba771e7 100644
--- a/test/node/prerender.test.js
+++ b/test/node/prerender.test.js
@@ -2,7 +2,7 @@ import { test } from 'uvu';
 import * as assert from 'uvu/assert';
 import { html } from 'htm/preact';
 
-import { default as prerender } from '../../src/prerender.js';
+import { prerender } from '../../src/prerender.js';
 
 test('extracts links', async () => {
 	const App = () => html`
@@ -20,10 +20,4 @@ test('extracts links', async () => {
 	assert.ok(links.has('/baz'), `missing: /baz`);
 });
 
-test('appends iso data script', async () => {
-	const { html: h } = await prerender(html`<div />`);
-	// Empty for now, but used for hydration vs render detection
-	assert.match(h, /<script type="isodata"><\/script>/, 'missing iso data script tag');
-});
-
 test.run();
diff --git a/test/node/router-match.test.js b/test/node/router-match.test.js
index 2e6743c..f171e02 100644
--- a/test/node/router-match.test.js
+++ b/test/node/router-match.test.js
@@ -4,12 +4,12 @@ import * as assert from 'uvu/assert';
 import { exec } from '../../src/router.js';
 
 function execPath(path, pattern, opts) {
-	return exec(path, pattern, { path, query: {}, params: {}, ...(opts || {}) });
+	return exec(path, pattern, { path, searchParams: {}, pathParams: {}, ...(opts || {}) });
 }
 
 test('Base route', () => {
 	const accurateResult = execPath('/', '/');
-	assert.equal(accurateResult, { path: '/', params: {}, query: {} });
+	assert.equal(accurateResult, { path: '/', pathParams: {}, searchParams: {} });
 
 	const inaccurateResult = execPath('/user/1', '/');
 	assert.equal(inaccurateResult, undefined);
@@ -17,7 +17,7 @@ test('Base route', () => {
 
 test('Param route', () => {
 	const accurateResult = execPath('/user/2', '/user/:id');
-	assert.equal(accurateResult, { path: '/user/2', params: { id: '2' }, id: '2', query: {} });
+	assert.equal(accurateResult, { path: '/user/2', pathParams: { id: '2' }, id: '2', searchParams: {} });
 
 	const inaccurateResult = execPath('/', '/user/:id');
 	assert.equal(inaccurateResult, undefined);
@@ -25,10 +25,10 @@ test('Param route', () => {
 
 test('Param rest segment', () => {
 	const accurateResult = execPath('/user/foo', '/user/*');
-	assert.equal(accurateResult, { path: '/user/foo', params: {}, query: {}, rest: '/foo' });
+	assert.equal(accurateResult, { path: '/user/foo', pathParams: {}, searchParams: {}, rest: '/foo' });
 
 	const accurateResult2 = execPath('/user/foo/bar/baz', '/user/*');
-	assert.equal(accurateResult2, { path: '/user/foo/bar/baz', params: {}, query: {}, rest: '/foo/bar/baz' });
+	assert.equal(accurateResult2, { path: '/user/foo/bar/baz', pathParams: {}, searchParams: {}, rest: '/foo/bar/baz' });
 
 	const inaccurateResult = execPath('/user', '/user/*');
 	assert.equal(inaccurateResult, undefined);
@@ -36,14 +36,14 @@ test('Param rest segment', () => {
 
 test('Param route with rest segment', () => {
 	const accurateResult = execPath('/user/2/foo', '/user/:id/*');
-	assert.equal(accurateResult, { path: '/user/2/foo', params: { id: '2' }, id: '2', query: {}, rest: '/foo' });
+	assert.equal(accurateResult, { path: '/user/2/foo', pathParams: { id: '2' }, id: '2', searchParams: {}, rest: '/foo' });
 
 	const accurateResult2 = execPath('/user/2/foo/bar/bob', '/user/:id/*');
 	assert.equal(accurateResult2, {
 		path: '/user/2/foo/bar/bob',
-		params: { id: '2' },
+		pathParams: { id: '2' },
 		id: '2',
-		query: {},
+		searchParams: {},
 		rest: '/foo/bar/bob'
 	});
 
@@ -53,7 +53,7 @@ test('Param route with rest segment', () => {
 
 test('Optional param route', () => {
 	const accurateResult = execPath('/user', '/user/:id?');
-	assert.equal(accurateResult, { path: '/user', params: { id: undefined }, id: undefined, query: {} });
+	assert.equal(accurateResult, { path: '/user', pathParams: { id: undefined }, id: undefined, searchParams: {} });
 
 	const inaccurateResult = execPath('/', '/user/:id?');
 	assert.equal(inaccurateResult, undefined);
@@ -61,22 +61,22 @@ test('Optional param route', () => {
 
 test('Optional rest param route "/:x*"', () => {
 	const matchedResult = execPath('/user', '/user/:id*');
-	assert.equal(matchedResult, { path: '/user', params: { id: undefined }, id: undefined, query: {} });
+	assert.equal(matchedResult, { path: '/user', pathParams: { id: undefined }, id: undefined, searchParams: {} });
 
 	const matchedResultWithSlash = execPath('/user/foo/bar', '/user/:id*');
 	assert.equal(matchedResultWithSlash, {
 		path: '/user/foo/bar',
-		params: { id: 'foo/bar' },
+		pathParams: { id: 'foo/bar' },
 		id: 'foo/bar',
-		query: {}
+		searchParams: {}
 	});
 
 	const emptyResult = execPath('/user', '/user/:id*');
 	assert.equal(emptyResult, {
 		path: '/user',
-		params: { id: undefined },
+		pathParams: { id: undefined },
 		id: undefined,
-		query: {}
+		searchParams: {}
 	});
 
 	const inaccurateResult = execPath('/', '/user/:id*');
@@ -85,14 +85,14 @@ test('Optional rest param route "/:x*"', () => {
 
 test('Rest param route "/:x+"', () => {
 	const matchedResult = execPath('/user/foo', '/user/:id+');
-	assert.equal(matchedResult, { path: '/user/foo', params: { id: 'foo' }, id: 'foo', query: {} });
+	assert.equal(matchedResult, { path: '/user/foo', pathParams: { id: 'foo' }, id: 'foo', searchParams: {} });
 
 	const matchedResultWithSlash = execPath('/user/foo/bar', '/user/:id+');
 	assert.equal(matchedResultWithSlash, {
 		path: '/user/foo/bar',
-		params: { id: 'foo/bar' },
+		pathParams: { id: 'foo/bar' },
 		id: 'foo/bar',
-		query: {}
+		searchParams: {}
 	});
 
 	const emptyResult = execPath('/user', '/user/:id+');
@@ -106,22 +106,22 @@ test('Handles leading/trailing slashes', () => {
 	const result = execPath('/about-late/_SEGMENT1_/_SEGMENT2_/', '/about-late/:seg1/:seg2/');
 	assert.equal(result, {
 		path: '/about-late/_SEGMENT1_/_SEGMENT2_/',
-		params: {
+		pathParams: {
 			seg1: '_SEGMENT1_',
 			seg2: '_SEGMENT2_'
 		},
 		seg1: '_SEGMENT1_',
 		seg2: '_SEGMENT2_',
-		query: {}
+		searchParams: {}
 	});
 });
 
 test('should not overwrite existing properties', () => {
-	const result = execPath('/foo/bar', '/:path/:query', { path: '/custom-path' });
+	const result = execPath('/foo/bar', '/:path/:searchParams', { path: '/custom-path' });
 	assert.equal(result, {
-		params: { path: 'foo', query: 'bar' },
+		pathParams: { path: 'foo', searchParams: 'bar' },
 		path: '/custom-path',
-		query: {}
+		searchParams: {},
 	});
 });
 
diff --git a/test/router.test.js b/test/router.test.js
index df64c0c..cb587d8 100644
--- a/test/router.test.js
+++ b/test/router.test.js
@@ -4,8 +4,8 @@ import * as chai from 'chai';
 import * as sinon from 'sinon';
 import sinonChai from 'sinon-chai';
 
-import { LocationProvider, Router, useLocation, Route, useRoute } from '../src/router.js';
-import lazy, { ErrorBoundary } from '../src/lazy.js';
+import { LocationProvider, Router, useLocation, Route } from '../src/router.js';
+import { lazy, ErrorBoundary } from '../src/lazy.js';
 
 import './setup.js';
 
@@ -44,16 +44,19 @@ describe('Router', () => {
 
 	it('should strip trailing slashes from path', async () => {
 		render(
-			<LocationProvider url="/a/">
+			<LocationProvider>
 				<ShallowLocation />
 			</LocationProvider>,
 			scratch
 		);
 
+		loc.route('/a/');
+		await sleep(1);
+
 		expect(loc).to.deep.include({
 			url: '/a/',
 			path: '/a',
-			query: {},
+			searchParams: {},
 		});
 	});
 
@@ -71,11 +74,11 @@ describe('Router', () => {
 		);
 
 		expect(scratch).to.have.property('textContent', 'Home');
-		expect(Home).to.have.been.calledWith({ path: '/', query: {}, params: {}, rest: '', test: '2' });
+		expect(Home).to.have.been.calledWith({ path: '/', searchParams: {}, pathParams: {}, test: '2' });
 		expect(loc).to.deep.include({
 			url: '/',
 			path: '/',
-			query: {},
+			searchParams: {},
 		});
 	});
 
@@ -100,21 +103,21 @@ describe('Router', () => {
 		render(<App />, scratch);
 
 		expect(scratch).to.have.property('textContent', 'Home');
-		expect(Home).to.have.been.calledWith({ path: '/', query: {}, params: {}, rest: '', test: '2' });
+		expect(Home).to.have.been.calledWith({ path: '/', searchParams: {}, pathParams: {}, test: '2' });
 		expect(loc).to.deep.include({
 			url: '/',
 			path: '/',
-			query: {},
+			searchParams: {},
 		});
 
 		set('3')
 		await sleep(1);
 
-		expect(Home).to.have.been.calledWith({ path: '/', query: {}, params: {}, rest: '', test: '3' });
+		expect(Home).to.have.been.calledWith({ path: '/', searchParams: {}, pathParams: {}, test: '3' });
 		expect(loc).to.deep.include({
 			url: '/',
 			path: '/',
-			query: {},
+			searchParams: {},
 		});
 		expect(scratch).to.have.property('textContent', 'Home');
 	});
@@ -122,7 +125,7 @@ describe('Router', () => {
 	it('should switch between synchronous routes', async () => {
 		const Home = sinon.fake(() => <h1>Home</h1>);
 		const Profiles = sinon.fake(() => <h1>Profiles</h1>);
-		const Profile = sinon.fake(({ params }) => <h1>Profile: {params.id}</h1>);
+		const Profile = sinon.fake(({ pathParams }) => <h1>Profile: {pathParams.id}</h1>);
 		const Fallback = sinon.fake(() => <h1>Fallback</h1>);
 		const stack = [];
 
@@ -140,14 +143,14 @@ describe('Router', () => {
 		);
 
 		expect(scratch).to.have.property('textContent', 'Home');
-		expect(Home).to.have.been.calledWith({ path: '/', query: {}, params: {}, rest: '' });
+		expect(Home).to.have.been.calledWith({ path: '/', searchParams: {}, pathParams: {} });
 		expect(Profiles).not.to.have.been.called;
 		expect(Profile).not.to.have.been.called;
 		expect(Fallback).not.to.have.been.called;
 		expect(loc).to.deep.include({
 			url: '/',
 			path: '/',
-			query: {},
+			searchParams: {},
 		});
 
 		Home.resetHistory();
@@ -156,14 +159,14 @@ describe('Router', () => {
 
 		expect(scratch).to.have.property('textContent', 'Profiles');
 		expect(Home).not.to.have.been.called;
-		expect(Profiles).to.have.been.calledWith({ path: '/profiles', query: {}, params: {}, rest: '' });
+		expect(Profiles).to.have.been.calledWith({ path: '/profiles', searchParams: {}, pathParams: {} });
 		expect(Profile).not.to.have.been.called;
 		expect(Fallback).not.to.have.been.called;
 
 		expect(loc).to.deep.include({
 			url: '/profiles',
 			path: '/profiles',
-			query: {}
+			searchParams: {}
 		});
 
 		Profiles.resetHistory();
@@ -174,14 +177,14 @@ describe('Router', () => {
 		expect(Home).not.to.have.been.called;
 		expect(Profiles).not.to.have.been.called;
 		expect(Profile).to.have.been.calledWith(
-			{ path: '/profiles/bob', query: {}, params: { id: 'bob' }, id: 'bob', rest: '' },
+			{ path: '/profiles/bob', searchParams: {}, pathParams: { id: 'bob' }, id: 'bob' },
 		);
 		expect(Fallback).not.to.have.been.called;
 
 		expect(loc).to.deep.include({
 			url: '/profiles/bob',
 			path: '/profiles/bob',
-			query: {}
+			searchParams: {}
 		});
 
 		Profile.resetHistory();
@@ -193,13 +196,13 @@ describe('Router', () => {
 		expect(Profiles).not.to.have.been.called;
 		expect(Profile).not.to.have.been.called;
 		expect(Fallback).to.have.been.calledWith(
-			{ default: true, path: '/other', query: { a: 'b', c: 'd' }, params: {}, rest: '' },
+			{ default: true, path: '/other', searchParams: { a: 'b', c: 'd' }, pathParams: {} },
 		);
 
 		expect(loc).to.deep.include({
 			url: '/other?a=b&c=d',
 			path: '/other',
-			query: { a: 'b', c: 'd' }
+			searchParams: { a: 'b', c: 'd' }
 		});
 		expect(stack).to.eql(['/profiles', '/profiles/bob', '/other?a=b&c=d']);
 	});
@@ -230,13 +233,13 @@ describe('Router', () => {
 		);
 
 		expect(scratch).to.have.property('innerHTML', '');
-		expect(A).to.have.been.calledWith({ path: '/', query: {}, params: {}, rest: '' });
+		expect(A).to.have.been.calledWith({ path: '/', searchParams: {}, pathParams: {} });
 
 		A.resetHistory();
 		await sleep(10);
 
 		expect(scratch).to.have.property('innerHTML', '<h1>A</h1><p>hello</p>');
-		expect(A).to.have.been.calledWith({ path: '/', query: {}, params: {}, rest: '' });
+		expect(A).to.have.been.calledWith({ path: '/', searchParams: {}, pathParams: {} });
 
 		A.resetHistory();
 		loc.route('/b');
@@ -250,14 +253,14 @@ describe('Router', () => {
 		// We should never re-invoke <A /> while loading <B /> (that would be a remount of the old route):
 		// ...but we do
 		//expect(A).not.to.have.been.called;
-		expect(B).to.have.been.calledWith({ path: '/b', query: {}, params: {}, rest: '' });
+		expect(B).to.have.been.calledWith({ path: '/b', searchParams: {}, pathParams: {} });
 
 		B.resetHistory();
 		await sleep(10);
 
 		expect(scratch).to.have.property('innerHTML', '<h1>B</h1><p>hello</p>');
 		expect(B).to.have.been.calledOnce;
-		expect(B).to.have.been.calledWith({ path: '/b', query: {}, params: {}, rest: '' });
+		expect(B).to.have.been.calledWith({ path: '/b', searchParams: {}, pathParams: {} });
 
 		B.resetHistory();
 		loc.route('/c');
@@ -277,14 +280,14 @@ describe('Router', () => {
 		// We should never re-invoke <B /> while loading <C /> (that would be a remount of the old route):
 		// ...but we do
 		//expect(B).not.to.have.been.called;
-		expect(C).to.have.been.calledWith({ path: '/c', query: {}, params: {}, rest: '' });
+		expect(C).to.have.been.calledWith({ path: '/c', searchParams: {}, pathParams: {} });
 
 		C.resetHistory();
 		await sleep(10);
 
 		expect(scratch).to.have.property('innerHTML', '<h1>C</h1>');
 		expect(C).to.have.been.calledOnce;
-		expect(C).to.have.been.calledWith({ path: '/c', query: {}, params: {}, rest: '' });
+		expect(C).to.have.been.calledWith({ path: '/c', searchParams: {}, pathParams: {} });
 
 		// "instant" routing to already-loaded routes
 
@@ -296,7 +299,7 @@ describe('Router', () => {
 		expect(scratch).to.have.property('innerHTML', '<h1>B</h1><p>hello</p>');
 		expect(C).not.to.have.been.called;
 		expect(B).to.have.been.calledOnce;
-		expect(B).to.have.been.calledWith({ path: '/b', query: {}, params: {}, rest: '' });
+		expect(B).to.have.been.calledWith({ path: '/b', searchParams: {}, pathParams: {} });
 
 		A.resetHistory();
 		B.resetHistory();
@@ -306,7 +309,7 @@ describe('Router', () => {
 		expect(scratch).to.have.property('innerHTML', '<h1>A</h1><p>hello</p>');
 		expect(B).not.to.have.been.called;
 		expect(A).to.have.been.calledOnce;
-		expect(A).to.have.been.calledWith({ path: '/', query: {}, params: {}, rest: '' });
+		expect(A).to.have.been.calledWith({ path: '/', searchParams: {}, pathParams: {} });
 	});
 
 	it('rerenders same-component routes rather than swap', async () => {
@@ -395,7 +398,7 @@ describe('Router', () => {
 		);
 
 		expect(scratch).to.have.property('innerHTML', '');
-		expect(A).to.have.been.calledWith({ path: '/', query: {}, params: {}, rest: '' });
+		expect(A).to.have.been.calledWith({ path: '/', searchParams: {}, pathParams: {} });
 		expect(loadStart).to.have.been.calledWith('/');
 		expect(loadEnd).not.to.have.been.called;
 		expect(routeChange).not.to.have.been.called;
@@ -407,7 +410,7 @@ describe('Router', () => {
 		await sleep(1);
 
 		expect(scratch).to.have.property('innerHTML', '<h1>A</h1><p>hello</p>');
-		expect(A).to.have.been.calledWith({ path: '/', query: {}, params: {}, rest: '' });
+		expect(A).to.have.been.calledWith({ path: '/', searchParams: {}, pathParams: {} });
 		expect(loadStart).not.to.have.been.called;
 		expect(loadEnd).to.have.been.calledWith('/');
 		expect(routeChange).not.to.have.been.called;
@@ -810,15 +813,11 @@ describe('Router', () => {
 	});
 
 	it('should match nested routes', async () => {
-		let route;
 		const Inner = () => (
 			<Router>
 				<Route
-					path="/bob"
-					component={() => {
-						route = useRoute();
-						return null;
-					}}
+					path="/baz"
+					component={() => <h1>Baz</h1>}
 				/>
 			</Router>
 		);
@@ -828,26 +827,24 @@ describe('Router', () => {
 				<Router>
 					<Route path="/foo/:id/*" component={Inner} />
 				</Router>
-				<a href="/foo/bar/bob"></a>
+				<a href="/foo/bar/baz"></a>
+				<ShallowLocation />
 			</LocationProvider>,
 			scratch
 		);
 
-		scratch.querySelector('a[href="/foo/bar/bob"]').click();
+		scratch.querySelector('a[href="/foo/bar/baz"]').click();
 		await sleep(1);
-		expect(route).to.deep.include({ path: '/bob', params: { id: 'bar' } });
+		expect(loc).to.deep.include({ path: '/foo/bar/baz', pathParams: { id: 'bar' }, searchParams: {} });
+		expect(scratch).to.have.property('textContent', 'Baz');
 	});
 
 	it('should append params in nested routes', async () => {
-		let params;
 		const Inner = () => (
 			<Router>
 				<Route
 					path="/bob"
-					component={() => {
-						params = useRoute().params;
-						return null;
-					}}
+					component={() => null}
 				/>
 			</Router>
 		);
@@ -858,13 +855,14 @@ describe('Router', () => {
 					<Route path="/foo/:id/*" component={Inner} />
 				</Router>
 				<a href="/foo/bar/bob"></a>
+				<ShallowLocation />
 			</LocationProvider>,
 			scratch
 		);
 
 		scratch.querySelector('a[href="/foo/bar/bob"]').click();
 		await sleep(1);
-		expect(params).to.deep.include({ id: 'bar' });
+		expect(loc.pathParams).to.deep.include({ id: 'bar' });
 	});
 
 	it('should replace the current URL', async () => {
@@ -934,17 +932,17 @@ describe('hydration', () => {
 		mutationObserver.observe(scratch, { childList: true, subtree: true });
 
 		expect(scratch).to.have.property('innerHTML', '<div><h1>A</h1><p>hello</p></div>');
-		expect(A).to.have.been.calledWith({ path: '/', query: {}, params: {}, rest: '' });
+		expect(A).to.have.been.calledWith({ path: '/', searchParams: {}, pathParams: {} });
 		const oldOptionsVnode = options.__b;
 		let hasMatched = false;
 		options.__b = (vnode) => {
 			if (vnode.type === A && !hasMatched) {
 				hasMatched = true;
-				if (vnode.__ && vnode.__.__h) {
-					expect(vnode.__.__h).to.equal(true)
-				} else if (vnode.__ && vnode.__.__u) {
-					expect(!!(vnode.__.__u & MODE_SUSPENDED)).to.equal(true);
-					expect(!!(vnode.__.__u & MODE_HYDRATE)).to.equal(true);
+				if (vnode.__h) {
+					expect(vnode.__h).to.equal(true)
+				} else if (vnode.__u) {
+					expect(!!(vnode.__u & MODE_SUSPENDED)).to.equal(true);
+					expect(!!(vnode.__u & MODE_HYDRATE)).to.equal(true);
 				} else {
 					expect(true).to.equal(false);
 				}
@@ -958,7 +956,7 @@ describe('hydration', () => {
 		await sleep(10);
 
 		expect(scratch).to.have.property('innerHTML', '<div><h1>A</h1><p>hello</p></div>');
-		expect(A).to.have.been.calledWith({ path: '/', query: {}, params: {}, rest: '' });
+		expect(A).to.have.been.calledWith({ path: '/', searchParams: {}, pathParams: {} });
 		expect(mutations).to.have.length(0);
 
 		options.__b = oldOptionsVnode;