@sveltejs/kit 3.0.0-next.2 → 3.0.0-next.20

package/src/runtime/app/forms/types.d.ts

@@ -0,0 +1,56 @@
+// kept separate from public.d.ts so generated $types can resolve these without pulling in the runtime graph
+import type { MaybePromise } from '../../../types/private.js';
+/**
+ * When calling a form action via fetch, the response will be one of these shapes.
+ * ```svelte
+ * <form method="post" use:enhance={() => {
+ *   return ({ result }) => {
+ * 		// result is of type ActionResult
+ *   };
+ * }}
+ * ```
+ *
+ * Success and failure results carry the root-relative `pathname + search` of the action URL, with
+ * the `?/actionName` parameter removed. Redirect results carry the redirect target. Server-generated
+ * error results also carry the action location, while client-generated errors such as network
+ * failures do not. `update` uses this location to emulate native form navigation.
+ */
+export type ActionResult<
+	Success extends Record<string, unknown> | undefined = Record<string, any>,
+	Failure extends Record<string, unknown> | undefined = Record<string, any>
+> =
+	| { type: 'success'; status: number; data?: Success; location: string }
+	| { type: 'failure'; status: number; data?: Failure; location: string }
+	| { type: 'redirect'; status: number; location: string }
+	| { type: 'error'; status?: number; error: App.Error; location?: string };
+
+export type SubmitFunction<
+	Success extends Record<string, unknown> | undefined = Record<string, any>,
+	Failure extends Record<string, unknown> | undefined = Record<string, any>
+> = (input: {
+	action: URL;
+	formData: FormData;
+	formElement: HTMLFormElement;
+	controller: AbortController;
+	submitter: HTMLElement | null;
+	cancel: () => void;
+}) => MaybePromise<
+	| void
+	| ((opts: {
+			formData: FormData;
+			formElement: HTMLFormElement;
+			action: URL;
+			result: ActionResult<Success, Failure>;
+			/**
+			 * Call this to get the default behavior of a form submission response.
+			 * @param options Set `reset: false` if you don't want the `<form>` values to be reset after a successful submission. `refreshAll` defaults to `true` for successful results and `false` for failures. When the submission navigates, setting it to `false` still runs the destination's `load` functions but may reuse shared layout data. Set `navigate: false` to apply non-redirect results to the current page instead of navigating to `result.location`. Redirects are always followed.
+			 */
+			update: (options?: {
+				reset?: boolean;
+				refreshAll?: boolean;
+				navigate?: boolean;
+				/** @deprecated Use `refreshAll` instead. */
+				invalidateAll?: boolean;
+			}) => Promise<void>;
+	  }) => MaybePromise<void>)
+>;

package/src/runtime/app/internal/transport.js

@@ -0,0 +1,53 @@
+/** @import { Transport } from '@sveltejs/kit/hooks' */
+import * as devalue from 'devalue';
+import { DEV } from 'esm-env';
+
+/** @type {(thing: any) => string} */
+export let uneval = () => {
+	throw new Error(DEV ? 'called uneval before init_transport' : '');
+};
+
+/** @type {(data: any) => string} */
+export let stringify = () => {
+	throw new Error(DEV ? 'called stringify before init_transport' : '');
+};
+
+/** @type {(data: string) => any} */
+export let parse = () => {
+	throw new Error(DEV ? 'called parse before init_transport' : '');
+};
+
+/** @type {Record<string, (data: any) => any>} */
+export let encoders = {};
+
+/** @type {Record<string, (data: any) => any>} */
+export let decoders = {};
+
+export let has_custom_transporters = false;
+
+/**
+ *
+ * @param {Transport} transport
+ */
+export function init_transport(transport) {
+	const transporters = Object.entries(transport);
+
+	has_custom_transporters = transporters.length > 0;
+
+	/** @param {unknown} thing */
+	const replacer = (thing) => {
+		for (const key of Object.keys(transport)) {
+			const encoded = transport[key].encode(thing);
+			if (encoded) {
+				return `app.decode('${key}', ${devalue.uneval(encoded, replacer)})`;
+			}
+		}
+	};
+
+	encoders = Object.fromEntries(transporters.map(([k, v]) => [k, v.encode]));
+	decoders = Object.fromEntries(transporters.map(([k, v]) => [k, v.decode]));
+
+	uneval = (data) => devalue.uneval(data, replacer);
+	stringify = (data) => devalue.stringify(data, encoders);
+	parse = (data) => devalue.parse(data, decoders);
+}

package/src/runtime/app/manifest/index.js

@@ -0,0 +1 @@
+export * from '__sveltekit/manifest-data';

package/src/runtime/app/{navigation.js → navigation/index.js}

@@ -11,4 +11,5 @@ export {
 	preloadData,
 	pushState,
 	replaceState
-} from '../client/client.js';
+} from '../../client/client.js';
+export { snapshot } from '../../client/snapshots.js';

package/src/runtime/app/navigation/public.d.ts

@@ -0,0 +1,237 @@
+import type { LayoutParams as AppLayoutParams, RouteId as AppRouteId } from '$app/types';
+
+export * from './index.js';
+
+/**
+ * Information about the target of a specific navigation.
+ */
+export interface NavigationTarget<
+	Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
+	RouteId extends AppRouteId | null = AppRouteId | null
+> {
+	/**
+	 * Parameters of the target page - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object.
+	 * Is `null` if the target is not part of the SvelteKit app (could not be resolved to a route).
+	 */
+	params: Params | null;
+	/**
+	 * Info about the target route
+	 */
+	route: {
+		/**
+		 * The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.
+		 */
+		id: RouteId | null;
+	};
+	/**
+	 * The URL that is navigated to
+	 */
+	url: URL;
+	/**
+	 * The scroll position associated with this navigation.
+	 *
+	 * For the `from` target, this is the scroll position at the moment of navigation.
+	 *
+	 * For the `to` target, this represents the scroll position that will be or was restored:
+	 * - In `beforeNavigate` and `onNavigate`, this is only available for `popstate` navigations (back/forward button)
+	 *   and will be `null` for other navigation types, since the final scroll position isn't known
+	 *   ahead of time.
+	 * - In `afterNavigate`, this is always the scroll position that was applied after the navigation
+	 *   completed.
+	 */
+	scroll: { x: number; y: number } | null;
+}
+
+export interface GotoOptions {
+	/**
+	 * If `true`, replaces the current history entry rather than creating a new one.
+	 * @default false
+	 */
+	replace?: boolean;
+	/** @deprecated Use `replace` instead. */
+	replaceState?: boolean;
+	/**
+	 * If `true`, updates the URL and `page.state` without navigating.
+	 * @default false
+	 */
+	shallow?: boolean;
+	/**
+	 * If `true`, resets the scroll position (to the top of the page, or to the element
+	 * matching the URL's `#hash` if there is one) and resets focus (to the `<body>`, or the
+	 * `autofocus` element if there is one) once the navigation completes.
+	 *
+	 * If `false`, the current scroll position and focused element are left alone.
+	 * @default true, or false when `shallow` is true
+	 */
+	reset?: boolean;
+	/**
+	 * If `true`, reruns all `load` functions and queries of the page.
+	 * @default false
+	 */
+	refreshAll?: boolean;
+	/** Causes any `load` functions to rerun if they depend on one of the URLs. */
+	invalidate?: Array<string | URL | ((url: URL) => boolean)>;
+	/** @deprecated Use `refreshAll` instead. */
+	invalidateAll?: boolean;
+	/** An optional object that will be available as `page.state`. */
+	state?: App.PageState;
+	/**
+	 * If `true`, `page.state` will be restored after a full page reload.
+	 * @default false
+	 */
+	persistState?: boolean;
+}
+
+/**
+ * - `enter`: The app has hydrated/started
+ * - `form`: The user submitted a `<form method="GET">`
+ * - `goto`: Navigation was triggered by a `goto(...)` call or a redirect
+ * - `leave`: The app is being left either because the tab is being closed or a navigation to a different document is occurring
+ * - `link`: Navigation was triggered by a link click
+ * - `popstate`: Navigation was triggered by back/forward navigation
+ */
+export type NavigationType = 'enter' | 'form' | 'leave' | 'link' | 'goto' | 'popstate';
+
+export interface NavigationBase {
+	/**
+	 * The type of navigation:
+	 * - `enter`: The app has hydrated/started
+	 * - `form`: The user submitted a `<form method="GET">`
+	 * - `goto`: Navigation was triggered by a `goto(...)` call or a redirect
+	 * - `leave`: The app is being left either because the tab is being closed or a navigation to a different document is occurring
+	 * - `link`: Navigation was triggered by a link click
+	 * - `popstate`: Navigation was triggered by back/forward navigation
+	 */
+	type: NavigationType;
+	/** Whether this is a shallow navigation. */
+	shallow: boolean;
+	/**
+	 * Where navigation was triggered from
+	 */
+	from: NavigationTarget | null;
+	/**
+	 * Where navigation is going to/has gone to
+	 */
+	to: NavigationTarget | null;
+	/**
+	 * Whether or not the navigation will result in the page being unloaded (i.e. not a client-side navigation).
+	 */
+	willUnload: boolean;
+	/**
+	 * A promise that resolves once the navigation is complete, and rejects if the navigation
+	 * fails or is aborted. In the case of a `willUnload` navigation, the promise will never resolve
+	 */
+	complete: Promise<void>;
+}
+
+/**
+ * The navigation that occurs when the app starts/hydrates
+ */
+export interface NavigationEnter extends NavigationBase {
+	type: 'enter';
+
+	/**
+	 * In case of a history back/forward navigation, the number of steps to go back/forward
+	 */
+	delta?: undefined;
+
+	/**
+	 * Dispatched `Event` object when navigation occurred by `popstate` or `link`.
+	 */
+	event?: undefined;
+}
+
+export type NavigationExternal = NavigationGoto | NavigationLeave;
+
+/**
+ * A navigation triggered by a `goto(...)` call or a redirect
+ */
+export interface NavigationGoto extends NavigationBase {
+	type: 'goto';
+}
+
+/**
+ * A navigation triggered by the tab being closed, or the user navigating to a different document
+ */
+export interface NavigationLeave extends NavigationBase {
+	type: 'leave';
+}
+
+/**
+ * A navigation triggered by a `<form method="GET">`
+ */
+export interface NavigationFormSubmit extends NavigationBase {
+	type: 'form';
+
+	/**
+	 * The `SubmitEvent` that caused the navigation
+	 */
+	event: SubmitEvent;
+}
+
+/**
+ * A navigation triggered by back/forward navigation
+ */
+export interface NavigationPopState extends NavigationBase {
+	type: 'popstate';
+
+	/**
+	 * In case of a history back/forward navigation, the number of steps to go back/forward
+	 */
+	delta: number;
+
+	/**
+	 * The `PopStateEvent` that caused the navigation
+	 */
+	event: PopStateEvent;
+}
+
+/**
+ * A navigation triggered by a link click
+ */
+export interface NavigationLink extends NavigationBase {
+	type: 'link';
+
+	/**
+	 * The `PointerEvent` that caused the navigation
+	 */
+	event: PointerEvent;
+}
+
+export type Navigation =
+	| NavigationExternal
+	| NavigationFormSubmit
+	| NavigationPopState
+	| NavigationLink;
+
+/**
+ * The argument passed to [`beforeNavigate`](https://svelte.dev/docs/kit/$app-navigation#beforeNavigate) callbacks.
+ */
+export type BeforeNavigate = Navigation & {
+	/**
+	 * Call this to prevent the navigation from starting.
+	 */
+	cancel: () => void;
+};
+
+/**
+ * The argument passed to [`onNavigate`](https://svelte.dev/docs/kit/$app-navigation#onNavigate) callbacks.
+ */
+export type OnNavigate = Navigation & {
+	type: Exclude<NavigationType, 'enter' | 'leave'>;
+	/**
+	 * Since `onNavigate` callbacks are called immediately before a client-side navigation, they will never be called with a navigation that unloads the page.
+	 */
+	willUnload: false;
+};
+
+/**
+ * The argument passed to [`afterNavigate`](https://svelte.dev/docs/kit/$app-navigation#afterNavigate) callbacks.
+ */
+export type AfterNavigate = (Navigation | NavigationEnter) & {
+	type: Exclude<NavigationType, 'leave'>;
+	/**
+	 * Since `afterNavigate` callbacks are called after a navigation completes, they will never be called with a navigation that unloads the page.
+	 */
+	willUnload: false;
+};

package/src/runtime/app/paths/client.js

@@ -1,11 +1,13 @@
-/** @import { Asset, RouteId, RouteIdWithSearchOrHash, Pathname, PathnameWithSearchOrHash, ResolvedPathname } from '$app/types' */
+/** @import { AssetPath, RouteId, RouteIdWithSearchOrHash, PathnameWithSearchOrHash, ResolvedPathname, RouteParams } from '$app/types' */
 /** @import { ResolveArgs } from './types.js' */
-import { base, assets, hash_routing } from './internal/client.js';
+import { base, assets, hash_routing, match_implementation } from './internal/client.js';
 import { resolve_route } from '../../../utils/routing.js';
-import { get_navigation_intent } from '../../client/client.js';
+import { DEV } from 'esm-env';
+
+export { base, assets, app_dir } from './internal/client.js';
 
 /**
- * Resolve the URL of an asset in your `static` directory, by prefixing it with [`config.kit.paths.assets`](https://svelte.dev/docs/kit/configuration#paths) if configured, or otherwise by prefixing it with the base path.
+ * Resolve the URL of an asset in your `static` directory, by prefixing it with [`config.paths.assets`](https://svelte.dev/docs/kit/configuration#paths) if configured, or otherwise by prefixing it with the base path.
  *
  * During server rendering, the base path is relative and depends on the page currently being rendered.
  *
@@ -15,15 +17,26 @@ import { get_navigation_intent } from '../../client/client.js';
  * 	import { asset } from '$app/paths';
  * </script>
  *
- * <img alt="a potato" src={asset('/potato.jpg')} />
+ * <img alt="a potato" src={asset('potato.jpg')} />
  * ```
  * @since 2.26
  *
- * @param {Asset} file
+ * @param {AssetPath} file
  * @returns {string}
  */
 export function asset(file) {
-	return (assets || base) + file;
+	let path = /** @type {string} */ (file);
+
+	// TODO 4.0 remove this
+	if (path[0] === '/') {
+		if (DEV) {
+			console.warn(`\`asset('${path}')\` should now be \`asset('${path.slice(1)}')\``);
+		}
+
+		path = path.slice(1);
+	}
+
+	return (assets || base) + '/' + path;
 }
 
 const pathname_prefix = hash_routing ? '#' : '';
@@ -38,7 +51,7 @@ const pathname_prefix = hash_routing ? '#' : '';
  * import { resolve } from '$app/paths';
  *
  * // using a pathname
- * const resolved = resolve(`/blog/hello-world`);
+ * const resolved = resolve(`blog/hello-world`);
  *
  * // using a route ID plus parameters
  * const resolved = resolve('/blog/[slug]', {
@@ -52,18 +65,20 @@ const pathname_prefix = hash_routing ? '#' : '';
  * @returns {ResolvedPathname}
  */
 export function resolve(...args) {
-	if (!args[0].startsWith('/')) {
-		throw new Error(
-			`Cannot use \`resolve(...)\` with a non-absolute pathname or route ID (got "${args[0]}"). ` +
-				'`resolve` is only for internal pathnames and route IDs; external URLs should be used directly.'
+	const [id, params] = /** @type {[string, Record<string, string>?]} */ (args);
+
+	if (id[0] === '/') {
+		// route ID
+		if (id.includes('[') && !params) {
+			throw new Error(`Missing params for dynamic route ID ${id}`);
+		}
+
+		return (
+			/** @type {ResolvedPathname} */ (base + pathname_prefix + resolve_route(id, params ?? {}))
 		);
 	}
 
-	// The type error is correct here, and if someone doesn't pass params when they should there's a runtime error,
-	// but we don't want to adjust the internal resolve_route function to accept `undefined`, hence the type cast.
-	return (
-		base + pathname_prefix + resolve_route(args[0], /** @type {Record<string, string>} */ (args[1]))
-	);
+	return /** @type {ResolvedPathname} */ (base + pathname_prefix + '/' + id);
 }
 
 /**
@@ -73,7 +88,7 @@ export function resolve(...args) {
  * ```js
  * import { match } from '$app/paths';
  *
- * const route = await match('/blog/hello-world');
+ * const route = await match('blog/hello-world');
  *
  * if (route?.id === '/blog/[slug]') {
  * 	const slug = route.params.slug;
@@ -83,24 +98,9 @@ export function resolve(...args) {
  * ```
  * @since 2.52.0
  *
- * @param {Pathname | URL | (string & {})} url
- * @returns {Promise<{ id: RouteId, params: Record<string, string> } | null>}
+ * @param {URL | string} url
+ * @returns {Promise<{ [K in RouteId]: { id: K; params: RouteParams<K>; } }[RouteId] | null>}
  */
-export async function match(url) {
-	if (typeof url === 'string') {
-		url = new URL(url, location.href);
-	}
-
-	const intent = await get_navigation_intent(url, false);
-
-	if (intent) {
-		return {
-			id: /** @type {RouteId} */ (intent.route.id),
-			params: intent.params
-		};
-	}
-
-	return null;
+export function match(url) {
+	return match_implementation(url);
 }
-
-export { base, assets, resolve as resolveRoute };

package/src/runtime/app/paths/index.js

@@ -1 +1 @@
-export * from '#app/paths';
+export { asset, resolve, match } from '#app/paths';

package/src/runtime/app/paths/internal/client.js

@@ -1,4 +1,36 @@
-export const base = __SVELTEKIT_PAYLOAD__?.base ?? __SVELTEKIT_PATHS_BASE__;
-export const assets = __SVELTEKIT_PAYLOAD__?.assets ?? base ?? __SVELTEKIT_PATHS_ASSETS__;
+// TODO get rid of this module — merge the contents into `../client.js`, and expose it to the
+// rest of the codebase as `#app/paths/client`, with an export condition that errors if
+// it is imported on the server
+
+/** @import { RouteId } from '$app/types' */
+import { payload } from '../../../client/payload.js';
+
+export const base = payload.base ?? __SVELTEKIT_PATHS_BASE__;
+export const assets = payload.assets ?? base ?? __SVELTEKIT_PATHS_ASSETS__;
 export const app_dir = __SVELTEKIT_APP_DIR__;
 export const hash_routing = __SVELTEKIT_HASH_ROUTING__;
+
+/**
+ * We make this configurable per-environment so that it's possible to import `$app/paths`
+ * into a service worker without importing the entire client
+ * @param {URL | string} _url
+ * @returns {Promise<{ [K in RouteId]: { id: K; params: import('$app/types').RouteParams<K>; } }[RouteId] | null>}
+ */
+// eslint-disable-next-line @typescript-eslint/require-await
+export let match_implementation = async (_url) => {
+	// @ts-ignore
+	if (typeof ServiceWorkerGlobalScope !== 'undefined' && self instanceof ServiceWorkerGlobalScope) {
+		throw new Error(
+			'Cannot use `match(...)` inside a service worker, as it depends on the SvelteKit client instance'
+		);
+	}
+
+	return null;
+};
+
+/**
+ * @param {typeof match_implementation} fn
+ */
+export function set_match_implementation(fn) {
+	match_implementation = fn;
+}

package/src/runtime/app/paths/internal/server.js

@@ -1,30 +1,13 @@
-export let base = __SVELTEKIT_PATHS_BASE__;
+// TODO get rid of this module — merge the contents into `../server.js`, and expose it to the
+// rest of the codebase as `#app/paths/server`, with an export condition that errors if
+// it is imported on the client
+
+export const base = __SVELTEKIT_PATHS_BASE__;
 export let assets = __SVELTEKIT_PATHS_ASSETS__ || base;
 export const app_dir = __SVELTEKIT_APP_DIR__;
 export const relative = __SVELTEKIT_PATHS_RELATIVE__;
 
-const initial = { base, assets };
-
-/**
- * `base` could be overridden during rendering to be relative;
- * this one's the original non-relative base path
- */
-export const initial_base = initial.base;
-
-/**
- * @param {{ base: string, assets: string }} paths
- */
-export function override(paths) {
-	base = paths.base;
-	assets = paths.assets;
-}
-
-export function reset() {
-	base = initial.base;
-	assets = initial.assets;
-}
-
 /** @param {string} path */
 export function set_assets(path) {
-	assets = initial.assets = path;
+	assets = path;
 }

package/src/runtime/app/paths/internal.d.ts

@@ -0,0 +1,3 @@
+import '../../../types/global-private.js';
+
+export * from './client.js';

package/src/runtime/app/paths/public.d.ts

@@ -1,29 +1 @@
-import { RouteIdWithSearchOrHash, PathnameWithSearchOrHash, ResolvedPathname } from '$app/types';
-import { ResolveArgs } from './types.js';
-
-export { resolve, asset, match } from './client.js';
-
-/**
- * A string that matches [`config.kit.paths.base`](https://svelte.dev/docs/kit/configuration#paths).
- *
- * Example usage: `<a href="{base}/your-page">Link</a>`
- *
- * @deprecated Use [`resolve(...)`](https://svelte.dev/docs/kit/$app-paths#resolve) instead
- */
-export let base: '' | `/${string}`;
-
-/**
- * An absolute path that matches [`config.kit.paths.assets`](https://svelte.dev/docs/kit/configuration#paths).
- *
- * > [!NOTE] If a value for `config.kit.paths.assets` is specified, it will be replaced with `'/_svelte_kit_assets'` during `vite dev` or `vite preview`, since the assets don't yet live at their eventual URL.
- *
- * @deprecated Use [`asset(...)`](https://svelte.dev/docs/kit/$app-paths#asset) instead
- */
-export let assets: '' | `https://${string}` | `http://${string}` | '/_svelte_kit_assets';
-
-/**
- * @deprecated Use [`resolve(...)`](https://svelte.dev/docs/kit/$app-paths#resolve) instead
- */
-export function resolveRoute<T extends RouteIdWithSearchOrHash | PathnameWithSearchOrHash>(
-	...args: ResolveArgs<T>
-): ResolvedPathname;
+export { asset, resolve, match } from './client.js';

package/src/runtime/app/paths/server.js

@@ -1,32 +1,53 @@
-import { base, assets, relative, initial_base } from './internal/server.js';
+import { base, assets, relative } from './internal/server.js';
 import { resolve_route, find_route } from '../../../utils/routing.js';
 import { decode_pathname } from '../../../utils/url.js';
+import { add_data_suffix } from '../../../pathname.js';
 import { try_get_request_store } from '@sveltejs/kit/internal/server';
-import { manifest } from '__sveltekit/server';
+import { manifest } from '../../server/internal.js';
 import { get_hooks } from '__SERVER__/internal.js';
+import { DEV } from 'esm-env';
 
-/** @type {import('./client.js').asset} */
+export { base, assets, app_dir } from './internal/server.js';
+
+/** @type {typeof import('./client.js').asset} */
 export function asset(file) {
-	// @ts-expect-error we use the `resolve` mechanism, but with the 'wrong' input
-	return assets && assets !== base ? assets + file : resolve(file);
+	// TODO 4.0 remove this
+	if (file[0] === '/') {
+		if (DEV) {
+			console.warn(`\`asset('${file}')\` should now be \`asset('${file.slice(1)}')\``);
+		}
+
+		file = file.slice(1);
+	}
+
+	return assets !== base ? `${assets}/${file}` : resolve(file);
 }
 
-/** @type {import('./client.js').resolve} */
+/** @type {typeof import('./client.js').resolve} */
 export function resolve(id, params) {
-	if (!id.startsWith('/')) {
-		throw new Error(
-			`Cannot use \`resolve(...)\` with a non-absolute pathname or route ID (got "${id}"). ` +
-				'`resolve` is only for internal pathnames and route IDs; external URLs should be used directly.'
-		);
-	}
+	let resolved;
 
-	const resolved = resolve_route(id, /** @type {Record<string, string>} */ (params));
+	if (id[0] === '/') {
+		// route ID
+		if (id.includes('[') && !params) {
+			throw new Error(`Missing params for dynamic route ID ${id}`);
+		}
+
+		resolved = resolve_route(id, params ?? {});
+	} else {
+		resolved = '/' + id;
+	}
 
 	if (relative) {
 		const store = try_get_request_store();
 
 		if (store && !store.state.prerendering?.fallback) {
-			const after_base = store.event.url.pathname.slice(initial_base.length);
+			// the relative path depth must reflect the URL the browser is actually at, which
+			// for a data request includes the `__data.json` suffix that was stripped during routing
+			const pathname = store.event.isDataRequest
+				? add_data_suffix(store.event.url.pathname)
+				: store.event.url.pathname;
+			const after_base = pathname.slice(base.length);
 			const segments = after_base.split('/').slice(2);
 			const prefix = segments.map(() => '..').join('/') || '.';
 
@@ -37,7 +58,7 @@ export function resolve(id, params) {
 	return base + resolved;
 }
 
-/** @type {import('./client.js').match} */
+/** @type {typeof import('./client.js').match} */
 export async function match(url) {
 	const store = try_get_request_store();
 
@@ -74,5 +95,3 @@ export async function match(url) {
 
 	return null;
 }
-
-export { base, assets, resolve as resolveRoute };