@analogjs/router 3.0.0-alpha.2 → 3.0.0-alpha.21

package/fesm2022/analogjs-router.mjs

@@ -1,854 +1,999 @@
-import { Router, NavigationEnd, UrlSegment, ActivatedRoute, provideRouter, ROUTES } from '@angular/router';
-import * as i0 from '@angular/core';
-import { inject, PLATFORM_ID, makeEnvironmentProviders, ENVIRONMENT_INITIALIZER, Injector, makeStateKey, TransferState, input, output, Directive, InjectionToken, signal, effect, ChangeDetectionStrategy, Component } from '@angular/core';
-import { HttpClient, HttpHeaders, ɵHTTP_ROOT_INTERCEPTOR_FNS as _HTTP_ROOT_INTERCEPTOR_FNS, HttpResponse, HttpRequest } from '@angular/common/http';
-import { firstValueFrom, map, from, of, throwError, catchError } from 'rxjs';
-import { injectAPIPrefix, injectBaseURL, injectInternalServerFetch, injectRequest, API_PREFIX } from '@analogjs/router/tokens';
-import { Meta, DomSanitizer } from '@angular/platform-browser';
-import { filter } from 'rxjs/operators';
-import { isPlatformServer } from '@angular/common';
-
-const ROUTE_META_TAGS_KEY = Symbol('@analogjs/router Route Meta Tags Key');
-const CHARSET_KEY = 'charset';
-const HTTP_EQUIV_KEY = 'httpEquiv';
-// httpEquiv selector key needs to be in kebab case format
-const HTTP_EQUIV_SELECTOR_KEY = 'http-equiv';
-const NAME_KEY = 'name';
-const PROPERTY_KEY = 'property';
-const CONTENT_KEY = 'content';
-const ITEMPROP_KEY = 'itemprop';
-function updateMetaTagsOnRouteChange() {
-    const router = inject(Router);
-    const metaService = inject(Meta);
-    router.events
-        .pipe(filter((event) => event instanceof NavigationEnd))
-        .subscribe(() => {
-        const metaTagMap = getMetaTagMap(router.routerState.snapshot.root);
-        for (const metaTagSelector in metaTagMap) {
-            const metaTag = metaTagMap[metaTagSelector];
-            metaService.updateTag(metaTag, metaTagSelector);
-        }
-    });
+import { a as updateMetaTagsOnRouteChange, i as injectRouteEndpointURL, n as ANALOG_ROUTE_FILES, o as updateJsonLdOnRouteChange, r as createRoutes$1, t as ANALOG_EXTRA_ROUTE_FILE_SOURCES } from "./route-files.mjs";
+import { n as createRoutes, r as routes, t as injectDebugRoutes } from "./routes.mjs";
+import { ActivatedRoute, ROUTES, Router, provideRouter } from "@angular/router";
+import * as i0 from "@angular/core";
+import { ChangeDetectionStrategy, Component, Directive, ENVIRONMENT_INITIALIZER, InjectionToken, Injector, PLATFORM_ID, TransferState, effect, inject, input, isDevMode, makeEnvironmentProviders, makeStateKey, output, signal } from "@angular/core";
+import { HttpClient, HttpHeaders, HttpRequest, HttpResponse, ɵHTTP_ROOT_INTERCEPTOR_FNS } from "@angular/common/http";
+import { catchError, from, map, of, take, throwError } from "rxjs";
+import { API_PREFIX, injectAPIPrefix, injectBaseURL, injectInternalServerFetch, injectRequest } from "@analogjs/router/tokens";
+import { isPlatformServer } from "@angular/common";
+import { DomSanitizer } from "@angular/platform-browser";
+import { toSignal } from "@angular/core/rxjs-interop";
+//#region packages/router/src/lib/define-route.ts
+/**
+* @deprecated Use `RouteMeta` type instead.
+* For more info see: https://github.com/analogjs/analog/issues/223
+*
+* Defines additional route config metadata. This
+* object is merged into the route config with
+* the predefined file-based route.
+*
+* @usageNotes
+*
+* ```
+* import { Component } from '@angular/core';
+* import { defineRouteMeta } from '@analogjs/router';
+*
+*  export const routeMeta = defineRouteMeta({
+*    title: 'Welcome'
+*  });
+*
+* @Component({
+*   template: `Home`,
+*   standalone: true,
+* })
+* export default class HomeComponent {}
+* ```
+*
+* @param route
+* @returns
+*/
+var defineRouteMeta = (route) => {
+	return route;
+};
+/**
+* Returns the instance of Angular Router
+*
+* @returns The router
+*/
+var injectRouter = () => {
+	return inject(Router);
+};
+/**
+* Returns the instance of the Activate Route for the component
+*
+* @returns The activated route
+*/
+var injectActivatedRoute = () => {
+	return inject(ActivatedRoute);
+};
+//#endregion
+//#region packages/router/src/lib/cookie-interceptor.ts
+function cookieInterceptor(req, next, location = inject(PLATFORM_ID), serverRequest = injectRequest()) {
+	if (isPlatformServer(location) && req.url.includes("/_analog/")) {
+		let headers = new HttpHeaders();
+		const cookies = serverRequest?.headers.cookie;
+		headers = headers.set("cookie", cookies ?? "");
+		return next(req.clone({ headers }));
+	} else return next(req);
 }
-function getMetaTagMap(route) {
-    const metaTagMap = {};
-    let currentRoute = route;
-    while (currentRoute) {
-        const metaTags = currentRoute.data[ROUTE_META_TAGS_KEY] ?? [];
-        for (const metaTag of metaTags) {
-            metaTagMap[getMetaTagSelector(metaTag)] = metaTag;
-        }
-        currentRoute = currentRoute.firstChild;
-    }
-    return metaTagMap;
+//#endregion
+//#region packages/router/src/lib/provide-file-router-base.ts
+function provideFileRouterWithRoutes(...features) {
+	const extraRoutesFeature = features.filter((feat) => feat.ɵkind >= 100);
+	const routerFeatures = features.filter((feat) => feat.ɵkind < 100);
+	return makeEnvironmentProviders([
+		extraRoutesFeature.map((erf) => erf.ɵproviders),
+		provideRouter([], ...routerFeatures),
+		{
+			provide: ROUTES,
+			multi: true,
+			useFactory: () => {
+				const extraSources = inject(ANALOG_EXTRA_ROUTE_FILE_SOURCES, { optional: true }) ?? [];
+				if (extraSources.length === 0) return createRoutes$1(ANALOG_ROUTE_FILES, (_filename, fileLoader) => fileLoader);
+				const allFiles = { ...ANALOG_ROUTE_FILES };
+				const resolverMap = /* @__PURE__ */ new Map();
+				for (const source of extraSources) for (const [key, loader] of Object.entries(source.files)) {
+					allFiles[key] = loader;
+					resolverMap.set(key, source.resolveModule);
+				}
+				return createRoutes$1(allFiles, (filename, fileLoader) => {
+					const resolver = resolverMap.get(filename);
+					return resolver ? resolver(filename, fileLoader) : fileLoader;
+				});
+			}
+		},
+		{
+			provide: ENVIRONMENT_INITIALIZER,
+			multi: true,
+			useValue: () => updateMetaTagsOnRouteChange()
+		},
+		{
+			provide: ENVIRONMENT_INITIALIZER,
+			multi: true,
+			useValue: () => updateJsonLdOnRouteChange()
+		},
+		{
+			provide: ɵHTTP_ROOT_INTERCEPTOR_FNS,
+			multi: true,
+			useValue: cookieInterceptor
+		},
+		{
+			provide: API_PREFIX,
+			useFactory() {
+				return typeof ANALOG_API_PREFIX !== "undefined" ? ANALOG_API_PREFIX : "api";
+			}
+		}
+	]);
 }
-function getMetaTagSelector(metaTag) {
-    if (metaTag.name) {
-        return `${NAME_KEY}="${metaTag.name}"`;
-    }
-    if (metaTag.property) {
-        return `${PROPERTY_KEY}="${metaTag.property}"`;
-    }
-    if (metaTag.httpEquiv) {
-        return `${HTTP_EQUIV_SELECTOR_KEY}="${metaTag.httpEquiv}"`;
-    }
-    if (metaTag.itemprop) {
-        return `${ITEMPROP_KEY}="${metaTag.itemprop}"`;
-    }
-    return CHARSET_KEY;
+function withExtraRoutes(routes) {
+	return {
+		ɵkind: 100,
+		ɵproviders: [{
+			provide: ROUTES,
+			useValue: routes,
+			multi: true
+		}]
+	};
 }
-
-const ANALOG_META_KEY = Symbol('@analogjs/router Analog Route Metadata Key');
+//#endregion
+//#region packages/router/src/lib/provide-file-router.ts
 /**
- * This variable reference is replaced with a glob of all route endpoints.
- */
-let ANALOG_PAGE_ENDPOINTS = {};
-
-function injectRouteEndpointURL(route) {
-    const routeConfig = route.routeConfig;
-    const apiPrefix = injectAPIPrefix();
-    const baseUrl = injectBaseURL();
-    const { queryParams, fragment: hash, params, parent } = route;
-    const segment = parent?.url.map((segment) => segment.path).join('/') || '';
-    const url = new URL('', import.meta.env['VITE_ANALOG_PUBLIC_BASE_URL'] ||
-        baseUrl ||
-        (typeof window !== 'undefined' && window.location.origin
-            ? window.location.origin
-            : ''));
-    url.pathname = `${url.pathname.endsWith('/') ? url.pathname : url.pathname + '/'}${apiPrefix}/_analog${routeConfig[ANALOG_META_KEY].endpoint}`;
-    url.search = `${new URLSearchParams(queryParams).toString()}`;
-    url.hash = hash ?? '';
-    Object.keys(params).forEach((param) => {
-        url.pathname = url.pathname.replace(`[${param}]`, params[param]);
-    });
-    url.pathname = url.pathname.replace('**', segment);
-    return url;
+* Sets up providers for the Angular router, and registers
+* file-based routes. Additional features can be provided
+* to further configure the behavior of the router.
+*
+* @param features
+* @returns Providers and features to configure the router with routes
+*/
+function provideFileRouter(...features) {
+	return provideFileRouterWithRoutes(...features);
 }
-
-function toRouteConfig(routeMeta) {
-    if (routeMeta && isRedirectRouteMeta(routeMeta)) {
-        return routeMeta;
-    }
-    let { meta, ...routeConfig } = routeMeta ?? {};
-    if (Array.isArray(meta)) {
-        routeConfig.data = { ...routeConfig.data, [ROUTE_META_TAGS_KEY]: meta };
-    }
-    else if (typeof meta === 'function') {
-        routeConfig.resolve = {
-            ...routeConfig.resolve,
-            [ROUTE_META_TAGS_KEY]: meta,
-        };
-    }
-    if (!routeConfig) {
-        routeConfig = {};
-    }
-    routeConfig.runGuardsAndResolvers =
-        routeConfig.runGuardsAndResolvers ?? 'paramsOrQueryParamsChange';
-    routeConfig.resolve = {
-        ...routeConfig.resolve,
-        load: async (route) => {
-            const routeConfig = route.routeConfig;
-            if (ANALOG_PAGE_ENDPOINTS[routeConfig[ANALOG_META_KEY].endpointKey]) {
-                const http = inject(HttpClient);
-                const url = injectRouteEndpointURL(route);
-                const internalFetch = injectInternalServerFetch();
-                if (internalFetch) {
-                    return internalFetch(url.pathname);
-                }
-                if (!!import.meta.env['VITE_ANALOG_PUBLIC_BASE_URL'] &&
-                    globalThis.$fetch) {
-                    return globalThis.$fetch(url.pathname);
-                }
-                return firstValueFrom(http.get(`${url.href}`));
-            }
-            return {};
-        },
-    };
-    return routeConfig;
+//#endregion
+//#region packages/router/src/lib/inject-load.ts
+function isResponse(value) {
+	return typeof value === "object" && value instanceof Response;
 }
-function isRedirectRouteMeta(routeMeta) {
-    return !!routeMeta.redirectTo;
+function injectLoad(options) {
+	return (options?.injector ?? inject(Injector)).get(ActivatedRoute).data.pipe(map((data) => data["load"]));
 }
-
-// The Zone is currently enabled by default, so we wouldn't need this check.
-// However, leaving this open space will be useful if zone.js becomes optional
-// in the future. This means we won't have to modify the current code, and it will
-// continue to work seamlessly.
-const isNgZoneEnabled = typeof Zone !== 'undefined' && !!Zone.root;
-function toMarkdownModule(markdownFileFactory) {
-    return async () => {
-        const createLoader = () => Promise.all([import('@analogjs/content'), markdownFileFactory()]);
-        const [{ parseRawContentFile, MarkdownRouteComponent, ContentRenderer }, markdownFile,] = await (isNgZoneEnabled
-            ? // We are not able to use `runOutsideAngular` because we are not inside
-                // an injection context to retrieve the `NgZone` instance.
-                // The `Zone.root.run` is required when the code is running in the
-                // browser since asynchronous tasks being scheduled in the current context
-                // are a reason for unnecessary change detection cycles.
-                Zone.root.run(createLoader)
-            : createLoader());
-        const { content, attributes } = parseRawContentFile(markdownFile);
-        const { title, meta } = attributes;
-        return {
-            default: MarkdownRouteComponent,
-            routeMeta: {
-                data: { _analogContent: content },
-                title,
-                meta,
-                resolve: {
-                    renderedAnalogContent: async () => {
-                        const contentRenderer = inject(ContentRenderer);
-                        const rendered = await contentRenderer.render(content);
-                        return typeof rendered === 'string'
-                            ? rendered
-                            : rendered.content;
-                    },
-                },
-            },
-        };
-    };
+function injectLoadData(options) {
+	return injectLoad(options).pipe(map((result) => {
+		if (isResponse(result)) throw new Error("Expected page load data but received a response.");
+		return result;
+	}));
 }
-
-const ENDPOINT_EXTENSION = '.server.ts';
-const APP_DIR = 'src/app';
-
+//#endregion
+//#region packages/router/src/lib/get-load-resolver.ts
 /**
- * This variable reference is replaced with a glob of all page routes.
- */
-let ANALOG_ROUTE_FILES = {};
-/**
- * This variable reference is replaced with a glob of all content routes.
- */
-let ANALOG_CONTENT_ROUTE_FILES = {};
-/**
- * A function used to parse list of files and create configuration of routes.
- *
- * @param files
- * @returns Array of routes
- */
-function createRoutes(files, debug = false) {
-    const filenames = Object.keys(files);
-    if (filenames.length === 0) {
-        return [];
-    }
-    // map filenames to raw routes and group them by level
-    const rawRoutesByLevelMap = filenames.reduce((acc, filename) => {
-        const rawPath = toRawPath(filename);
-        const rawSegments = rawPath.split('/');
-        // nesting level starts at 0
-        // rawPath: /products => level: 0
-        // rawPath: /products/:id => level: 1
-        const level = rawSegments.length - 1;
-        const rawSegment = rawSegments[level];
-        const ancestorRawSegments = rawSegments.slice(0, level);
-        return {
-            ...acc,
-            [level]: {
-                ...acc[level],
-                [rawPath]: {
-                    filename,
-                    rawSegment,
-                    ancestorRawSegments,
-                    segment: toSegment(rawSegment),
-                    level,
-                    children: [],
-                },
-            },
-        };
-    }, {});
-    const allLevels = Object.keys(rawRoutesByLevelMap).map(Number);
-    const maxLevel = Math.max(...allLevels);
-    // add each raw route to its parent's children array
-    for (let level = maxLevel; level > 0; level--) {
-        const rawRoutesMap = rawRoutesByLevelMap[level];
-        const rawPaths = Object.keys(rawRoutesMap);
-        for (const rawPath of rawPaths) {
-            const rawRoute = rawRoutesMap[rawPath];
-            const parentRawPath = rawRoute.ancestorRawSegments.join('/');
-            const parentRawSegmentIndex = rawRoute.ancestorRawSegments.length - 1;
-            const parentRawSegment = rawRoute.ancestorRawSegments[parentRawSegmentIndex];
-            // create the parent level and/or raw route if it does not exist
-            // parent route won't exist for nested routes that don't have a layout route
-            rawRoutesByLevelMap[level - 1] ||= {};
-            rawRoutesByLevelMap[level - 1][parentRawPath] ||= {
-                filename: null,
-                rawSegment: parentRawSegment,
-                ancestorRawSegments: rawRoute.ancestorRawSegments.slice(0, parentRawSegmentIndex),
-                segment: toSegment(parentRawSegment),
-                level: level - 1,
-                children: [],
-            };
-            rawRoutesByLevelMap[level - 1][parentRawPath].children.push(rawRoute);
-        }
-    }
-    // only take raw routes from the root level
-    // since they already contain nested routes as their children
-    const rootRawRoutesMap = rawRoutesByLevelMap[0];
-    const rawRoutes = Object.keys(rootRawRoutesMap).map((segment) => rootRawRoutesMap[segment]);
-    sortRawRoutes(rawRoutes);
-    return toRoutes(rawRoutes, files, debug);
-}
-function toRawPath(filename) {
-    return (filename
-        .replace(
-    // convert to relative path and remove file extension
-    /^(?:[a-zA-Z]:[\\/])?(.*?)[\\/](?:routes|pages)[\\/]|(?:[\\/](?:app[\\/](?:routes|pages)|src[\\/]content)[\\/])|(\.page\.(js|ts|analog|ag)$)|(\.(ts|md|analog|ag)$)/g, '')
-        // [[...slug]] => placeholder (named empty) which is stripped by toSegment
-        .replace(/\[\[\.\.\.([^\]]+)\]\]/g, '(opt-$1)')
-        .replace(/\[\.{3}.+\]/, '**') // [...not-found] => **
-        .replace(/\[([^\]]+)\]/g, ':$1')); // [id] => :id
-}
-function toSegment(rawSegment) {
-    return rawSegment
-        .replace(/index|\(.*?\)/g, '') // replace named empty segments
-        .replace(/\.|\/+/g, '/') // replace dots with slashes and remove redundant slashes
-        .replace(/^\/+|\/+$/g, ''); // remove trailing slashes
-}
-function createOptionalCatchAllMatcher(paramName) {
-    return (segments) => {
-        if (segments.length === 0) {
-            return null;
-        }
-        const joined = segments.map((s) => s.path).join('/');
-        return {
-            consumed: segments,
-            posParams: { [paramName]: new UrlSegment(joined, {}) },
-        };
-    };
+* Get server load resolver data for the route
+*
+* @param route Provides the route to get server load resolver
+* @returns Returns server load resolver data for the route
+*/
+async function getLoadResolver(route) {
+	return route.routeConfig?.resolve?.["load"]?.(route);
 }
-function toRoutes(rawRoutes, files, debug = false) {
-    const routes = [];
-    for (const rawRoute of rawRoutes) {
-        const children = rawRoute.children.length > 0
-            ? toRoutes(rawRoute.children, files, debug)
-            : undefined;
-        let module = undefined;
-        let analogMeta = undefined;
-        if (rawRoute.filename) {
-            const isMarkdownFile = rawRoute.filename.endsWith('.md');
-            if (!debug) {
-                module = isMarkdownFile
-                    ? toMarkdownModule(files[rawRoute.filename])
-                    : files[rawRoute.filename];
-            }
-            const endpointKey = rawRoute.filename.replace(/\.page\.(ts|analog|ag)$/, ENDPOINT_EXTENSION);
-            // get endpoint path
-            const rawEndpoint = rawRoute.filename
-                .replace(/\.page\.(ts|analog|ag)$/, '')
-                .replace(/\[\[\.\.\..+\]\]/, '**')
-                .replace(/\[\.{3}.+\]/, '**') // [...not-found] => **
-                .replace(/^(.*?)\/pages/, '/pages');
-            // replace periods, remove (index) paths
-            const endpoint = (rawEndpoint || '')
-                .replace(/\./g, '/')
-                .replace(/\/\((.*?)\)$/, '/-$1-');
-            analogMeta = {
-                endpoint,
-                endpointKey,
-            };
-        }
-        // Detect Next.js-style optional catch-all at this node: [[...param]]
-        const optCatchAllMatch = rawRoute.filename?.match(/\[\[\.\.\.([^\]]+)\]\]/);
-        const optCatchAllParam = optCatchAllMatch ? optCatchAllMatch[1] : null;
-        const route = module
-            ? {
-                path: rawRoute.segment,
-                loadChildren: () => module().then((m) => {
-                    if (import.meta.env.DEV) {
-                        const hasModuleDefault = !!m.default;
-                        const hasRedirect = !!m.routeMeta?.redirectTo;
-                        if (!hasModuleDefault && !hasRedirect) {
-                            console.warn(`[Analog] Missing default export at ${rawRoute.filename}`);
-                        }
-                    }
-                    const baseChild = {
-                        path: '',
-                        component: m.default,
-                        ...toRouteConfig(m.routeMeta),
-                        children,
-                        [ANALOG_META_KEY]: analogMeta,
-                    };
-                    // Base route first so static matches win, then optional catch-all matcher
-                    return [
-                        {
-                            ...baseChild,
-                        },
-                        ...(optCatchAllParam
-                            ? [
-                                {
-                                    matcher: createOptionalCatchAllMatcher(optCatchAllParam),
-                                    component: m.default,
-                                    ...toRouteConfig(m.routeMeta),
-                                    [ANALOG_META_KEY]: analogMeta,
-                                },
-                            ]
-                            : []),
-                    ];
-                }),
-            }
-            : {
-                path: rawRoute.segment,
-                ...(debug
-                    ? {
-                        filename: rawRoute.filename ? rawRoute.filename : undefined,
-                        isLayout: children && children.length > 0 ? true : false,
-                    }
-                    : {}),
-                children,
-            };
-        routes.push(route);
-    }
-    return routes;
+//#endregion
+//#region packages/router/src/lib/cache-key.ts
+function sortAndConcatParams(params) {
+	return [...params.keys()].sort().map((k) => `${k}=${params.getAll(k)}`).join("&");
 }
-function sortRawRoutes(rawRoutes) {
-    rawRoutes.sort((a, b) => {
-        let segmentA = deprioritizeSegment(a.segment);
-        let segmentB = deprioritizeSegment(b.segment);
-        // prioritize routes with fewer children
-        if (a.children.length > b.children.length) {
-            segmentA = `~${segmentA}`;
-        }
-        else if (a.children.length < b.children.length) {
-            segmentB = `~${segmentB}`;
-        }
-        return segmentA > segmentB ? 1 : -1;
-    });
-    for (const rawRoute of rawRoutes) {
-        sortRawRoutes(rawRoute.children);
-    }
+function makeCacheKey(request, mappedRequestUrl) {
+	const { params, method, responseType } = request;
+	const encodedParams = sortAndConcatParams(params);
+	let serializedBody = request.serializeBody();
+	if (serializedBody instanceof URLSearchParams) serializedBody = sortAndConcatParams(serializedBody);
+	else if (typeof serializedBody !== "string") serializedBody = "";
+	return makeStateKey(generateHash([
+		method,
+		responseType,
+		mappedRequestUrl,
+		serializedBody,
+		encodedParams
+	].join("|")));
 }
-function deprioritizeSegment(segment) {
-    // deprioritize param and wildcard segments
-    return segment.replace(':', '~~').replace('**', '~~~~');
+function generateHash(str) {
+	let hash = 0;
+	for (let i = 0, len = str.length; i < len; i++) {
+		const chr = str.charCodeAt(i);
+		hash = (hash << 5) - hash + chr;
+		hash |= 0;
+	}
+	return `${hash}`;
 }
-const routes = createRoutes({
-    ...ANALOG_ROUTE_FILES,
-    ...ANALOG_CONTENT_ROUTE_FILES,
-});
-
+//#endregion
+//#region packages/router/src/lib/request-context.ts
 /**
- * @deprecated Use `RouteMeta` type instead.
- * For more info see: https://github.com/analogjs/analog/issues/223
- *
- * Defines additional route config metadata. This
- * object is merged into the route config with
- * the predefined file-based route.
- *
- * @usageNotes
- *
- * ```
- * import { Component } from '@angular/core';
- * import { defineRouteMeta } from '@analogjs/router';
- *
- *  export const routeMeta = defineRouteMeta({
- *    title: 'Welcome'
- *  });
- *
- * @Component({
- *   template: `Home`,
- *   standalone: true,
- * })
- * export default class HomeComponent {}
- * ```
- *
- * @param route
- * @returns
- */
-const defineRouteMeta = (route) => {
-    return route;
+* Interceptor that is server-aware when making HttpClient requests.
+* Server-side requests use the full URL
+* Prerendering uses the internal Nitro $fetch function, along with state transfer
+* Client-side requests use the window.location.origin
+*
+* @param req HttpRequest<unknown>
+* @param next HttpHandlerFn
+* @returns
+*/
+function requestContextInterceptor(req, next) {
+	const apiPrefix = injectAPIPrefix();
+	const baseUrl = injectBaseURL();
+	const transferState = inject(TransferState);
+	const nitroGlobal = globalThis;
+	const serverFetch = injectInternalServerFetch() ?? nitroGlobal.$fetch;
+	if (serverFetch && baseUrl && (req.url.startsWith("/") || req.url.startsWith(baseUrl) || req.url.startsWith(`/${apiPrefix}`))) {
+		const requestUrl = new URL(req.url, baseUrl);
+		const storeKey = makeStateKey(`analog_${makeCacheKey(req, new URL(requestUrl).pathname)}`);
+		const fetchUrl = requestUrl.pathname;
+		const responseType = req.responseType === "arraybuffer" ? "arrayBuffer" : req.responseType;
+		return from(serverFetch.raw(fetchUrl, {
+			method: req.method,
+			body: req.body ? req.body : void 0,
+			params: requestUrl.searchParams,
+			responseType,
+			headers: req.headers.keys().reduce((hdrs, current) => {
+				const value = req.headers.get(current);
+				return value != null ? {
+					...hdrs,
+					[current]: value
+				} : hdrs;
+			}, {})
+		}).then((res) => {
+			const cacheResponse = {
+				body: res._data,
+				headers: new HttpHeaders(res.headers),
+				status: res.status ?? 200,
+				statusText: res.statusText ?? "OK",
+				url: fetchUrl
+			};
+			const transferResponse = new HttpResponse(cacheResponse);
+			transferState.set(storeKey, cacheResponse);
+			return transferResponse;
+		}));
+	}
+	if (req.url.startsWith("/") || req.url.includes("/_analog/")) {
+		const requestUrl = req.url.includes("/_analog/") ? req.url : `${window.location.origin}${req.url}`;
+		const storeKey = makeStateKey(`analog_${makeCacheKey(req, new URL(requestUrl).pathname)}`);
+		const cacheRestoreResponse = transferState.get(storeKey, null);
+		if (cacheRestoreResponse) {
+			transferState.remove(storeKey);
+			return of(new HttpResponse(cacheRestoreResponse));
+		}
+		return next(req.clone({ url: requestUrl }));
+	}
+	if (baseUrl && (req.url.startsWith("/") || req.url.startsWith(baseUrl))) {
+		const requestUrl = req.url.startsWith(baseUrl) && !req.url.startsWith("/") ? req.url : `${baseUrl}${req.url}`;
+		return next(req.clone({ url: requestUrl }));
+	}
+	return next(req);
+}
+//#endregion
+//#region packages/router/src/lib/form-action.directive.ts
+var FormAction = class FormAction {
+	constructor() {
+		this.action = input("", ...[]);
+		this.onSuccess = output();
+		this.onError = output();
+		this.state = output();
+		this.router = inject(Router);
+		this.route = inject(ActivatedRoute);
+		this.currentState = signal("idle", ...[]);
+		/** Cached during construction (injection context) so inject() works. */
+		this._endpointUrl = this.route ? injectRouteEndpointURL(this.route.snapshot) : void 0;
+	}
+	submitted($event) {
+		$event.preventDefault();
+		const form = $event.target;
+		this._emitState("submitting");
+		const body = new FormData(form);
+		if (form.method.toUpperCase() === "GET") this._handleGet(body, this._getGetPath(form));
+		else this._handlePost(body, this._getPostPath(form), form.method);
+	}
+	_handleGet(body, path) {
+		const url = new URL(path, window.location.href);
+		const params = new URLSearchParams(url.search);
+		body.forEach((value, key) => {
+			params.append(key, value instanceof File ? value.name : value);
+		});
+		url.search = params.toString();
+		this._emitState("navigate");
+		this._navigateTo(url);
+	}
+	_handlePost(body, path, method) {
+		fetch(path, {
+			method,
+			body
+		}).then((res) => {
+			if (res.ok) if (res.redirected) {
+				this._emitState("redirect");
+				this._navigateTo(new URL(res.url, window.location.href));
+			} else if (this._isJSON(res.headers.get("Content-type"))) res.json().then((result) => {
+				this.onSuccess.emit(result);
+				this._emitState("success");
+			});
+			else res.text().then((result) => {
+				this.onSuccess.emit(result);
+				this._emitState("success");
+			});
+			else if (res.headers.get("X-Analog-Errors")) res.json().then((errors) => {
+				this.onError.emit(errors);
+				this._emitState("error");
+			});
+			else this._emitState("error");
+		}).catch((_) => {
+			this._emitState("error");
+		});
+	}
+	_getExplicitAction(form) {
+		return this.action().trim() || form.getAttribute("action")?.trim() || void 0;
+	}
+	_getGetPath(form) {
+		return this._getExplicitAction(form) ?? this.router.url;
+	}
+	_getPostPath(form) {
+		const explicitAction = this._getExplicitAction(form);
+		if (explicitAction) return new URL(explicitAction, window.location.href).toString();
+		if (this._endpointUrl) return this._endpointUrl.pathname;
+		return `/api/_analog/pages${window.location.pathname}`;
+	}
+	_emitState(state) {
+		this.currentState.set(state);
+		this.state.emit(state);
+	}
+	_navigateTo(url) {
+		if (url.origin === window.location.origin) {
+			this.router.navigateByUrl(`${url.pathname}${url.search}${url.hash}`, { onSameUrlNavigation: "reload" });
+			return;
+		}
+		window.location.assign(url.toString());
+	}
+	_isJSON(contentType) {
+		return (contentType ? contentType.split(";") : [])[0] === "application/json";
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "21.2.6",
+			ngImport: i0,
+			type: FormAction,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "17.1.0",
+			version: "21.2.6",
+			type: FormAction,
+			isStandalone: true,
+			selector: "form[action],form[method]",
+			inputs: { action: {
+				classPropertyName: "action",
+				publicName: "action",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			} },
+			outputs: {
+				onSuccess: "onSuccess",
+				onError: "onError",
+				state: "state"
+			},
+			host: {
+				listeners: { "submit": "submitted($event)" },
+				properties: {
+					"attr.data-state": "currentState()",
+					"attr.aria-busy": "currentState() === \"submitting\" ? \"true\" : null"
+				}
+			},
+			ngImport: i0
+		});
+	}
 };
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "21.2.6",
+	ngImport: i0,
+	type: FormAction,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "form[action],form[method]",
+			host: {
+				"(submit)": `submitted($event)`,
+				"[attr.data-state]": "currentState()",
+				"[attr.aria-busy]": "currentState() === \"submitting\" ? \"true\" : null"
+			},
+			standalone: true
+		}]
+	}],
+	propDecorators: {
+		action: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "action",
+				required: false
+			}]
+		}],
+		onSuccess: [{
+			type: i0.Output,
+			args: ["onSuccess"]
+		}],
+		onError: [{
+			type: i0.Output,
+			args: ["onError"]
+		}],
+		state: [{
+			type: i0.Output,
+			args: ["state"]
+		}]
+	}
+});
+//#endregion
+//#region packages/router/src/lib/debug/index.ts
 /**
- * Returns the instance of Angular Router
- *
- * @returns The router
- */
-const injectRouter = () => {
-    return inject(Router);
-};
+* Provides routes that provide additional
+* pages for displaying and debugging
+* routes.
+*/
+function withDebugRoutes() {
+	return {
+		ɵkind: 101,
+		ɵproviders: [{
+			provide: ROUTES,
+			useValue: [{
+				path: "__analog/routes",
+				loadComponent: () => import("./debug.page.mjs")
+			}],
+			multi: true
+		}]
+	};
+}
+//#endregion
+//#region packages/router/src/lib/server.component.ts
 /**
- * Returns the instance of the Activate Route for the component
- *
- * @returns The activated route
- */
-const injectActivatedRoute = () => {
-    return inject(ActivatedRoute);
+* @description
+* Component that defines the bridge between the client and server-only
+* components. The component passes the component ID and props to the server
+* and retrieves the rendered HTML and outputs from the server-only component.
+*
+* Status: experimental
+*/
+var ServerOnly = class ServerOnly {
+	constructor() {
+		this.component = input.required(...[]);
+		this.props = input(...[]);
+		this.outputs = output();
+		this.http = inject(HttpClient);
+		this.sanitizer = inject(DomSanitizer);
+		this.content = signal("", ...[]);
+		this.route = inject(ActivatedRoute, { optional: true });
+		this.baseURL = injectBaseURL();
+		this.transferState = inject(TransferState);
+		effect(() => {
+			const routeComponentId = this.route?.snapshot.data["component"];
+			const props = this.props() || {};
+			const componentId = routeComponentId || this.component();
+			const headers = new HttpHeaders(new Headers({
+				"Content-type": "application/json",
+				"X-Analog-Component": componentId
+			}));
+			const componentUrl = this.getComponentUrl(componentId);
+			const httpRequest = new HttpRequest("POST", componentUrl, props, { headers });
+			const storeKey = makeStateKey(makeCacheKey(httpRequest, new URL(componentUrl).pathname));
+			const componentState = this.transferState.get(storeKey, null);
+			if (componentState) {
+				this.updateContent(componentState);
+				this.transferState.remove(storeKey);
+			} else this.http.request(httpRequest).pipe(map((response) => {
+				if (response instanceof HttpResponse) return response.body;
+				return throwError(() => ({}));
+			}), catchError((error) => {
+				console.log(error);
+				return of({
+					html: "",
+					outputs: {}
+				});
+			})).subscribe((content) => this.updateContent(content));
+		});
+	}
+	updateContent(content) {
+		this.content.set(this.sanitizer.bypassSecurityTrustHtml(content.html));
+		this.outputs.emit(content.outputs);
+	}
+	getComponentUrl(componentId) {
+		let baseURL = this.baseURL;
+		if (!baseURL && typeof window !== "undefined") baseURL = window.location.origin;
+		return `${baseURL}/_analog/components/${componentId}`;
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "21.2.6",
+			ngImport: i0,
+			type: ServerOnly,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Component
+		});
+	}
+	static {
+		this.ɵcmp = i0.ɵɵngDeclareComponent({
+			minVersion: "17.1.0",
+			version: "21.2.6",
+			type: ServerOnly,
+			isStandalone: true,
+			selector: "server-only,ServerOnly,Server",
+			inputs: {
+				component: {
+					classPropertyName: "component",
+					publicName: "component",
+					isSignal: true,
+					isRequired: true,
+					transformFunction: null
+				},
+				props: {
+					classPropertyName: "props",
+					publicName: "props",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				}
+			},
+			outputs: { outputs: "outputs" },
+			ngImport: i0,
+			template: ` <div [innerHTML]="content()"></div> `,
+			isInline: true,
+			changeDetection: i0.ChangeDetectionStrategy.OnPush
+		});
+	}
 };
-
-function cookieInterceptor(req, next, location = inject(PLATFORM_ID), serverRequest = injectRequest()) {
-    if (isPlatformServer(location) && req.url.includes('/_analog/')) {
-        let headers = new HttpHeaders();
-        const cookies = serverRequest?.headers.cookie;
-        headers = headers.set('cookie', cookies ?? '');
-        const cookiedRequest = req.clone({
-            headers,
-        });
-        return next(cookiedRequest);
-    }
-    else {
-        return next(req);
-    }
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "21.2.6",
+	ngImport: i0,
+	type: ServerOnly,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "server-only,ServerOnly,Server",
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			template: ` <div [innerHTML]="content()"></div> `
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: {
+		component: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "component",
+				required: true
+			}]
+		}],
+		props: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "props",
+				required: false
+			}]
+		}],
+		outputs: [{
+			type: i0.Output,
+			args: ["outputs"]
+		}]
+	}
+});
+//#endregion
+//#region packages/router/src/lib/validation-errors.ts
+function getPathSegmentKey(segment) {
+	return typeof segment === "object" ? segment.key : segment;
 }
-
+function issuePathToFieldName(path) {
+	return path.map((segment) => String(getPathSegmentKey(segment))).join(".");
+}
+function issuesToFieldErrors(issues) {
+	return issues.reduce((errors, issue) => {
+		if (!issue.path?.length) return errors;
+		const fieldName = issuePathToFieldName(issue.path);
+		errors[fieldName] ??= [];
+		errors[fieldName].push(issue.message);
+		return errors;
+	}, {});
+}
+function issuesToFormErrors(issues) {
+	return issues.filter((issue) => !issue.path?.length).map((issue) => issue.message);
+}
+//#endregion
+//#region packages/router/src/lib/route-path.ts
 /**
- * Sets up providers for the Angular router, and registers
- * file-based routes. Additional features can be provided
- * to further configure the behavior of the router.
- *
- * @param features
- * @returns Providers and features to configure the router with routes
- */
-function provideFileRouter(...features) {
-    const extraRoutesFeature = features.filter((feat) => feat.ɵkind >= 100);
-    const routerFeatures = features.filter((feat) => feat.ɵkind < 100);
-    return makeEnvironmentProviders([
-        extraRoutesFeature.map((erf) => erf.ɵproviders),
-        provideRouter(routes, ...routerFeatures),
-        {
-            provide: ENVIRONMENT_INITIALIZER,
-            multi: true,
-            useValue: () => updateMetaTagsOnRouteChange(),
-        },
-        {
-            provide: _HTTP_ROOT_INTERCEPTOR_FNS,
-            multi: true,
-            useValue: cookieInterceptor,
-        },
-        {
-            provide: API_PREFIX,
-            useFactory() {
-                return typeof ANALOG_API_PREFIX !== 'undefined'
-                    ? ANALOG_API_PREFIX
-                    : 'api';
-            },
-        },
-    ]);
+* Typed route path utilities for Analog.
+*
+* This module provides:
+* - The `AnalogRouteTable` base interface (augmented by generated code)
+* - The `AnalogRoutePath` union type
+* - The `routePath()` URL builder function
+*
+* No Angular dependencies — can be used in any context.
+*/
+/**
+* Builds a typed route link object from a route path pattern and options.
+*
+* The returned object separates path, query params, and fragment for
+* direct use with Angular's routerLink directive inputs.
+*
+* @example
+* routePath('/about')
+* // → { path: '/about', queryParams: null, fragment: undefined }
+*
+* routePath('/users/[id]', { params: { id: '42' } })
+* // → { path: '/users/42', queryParams: null, fragment: undefined }
+*
+* routePath('/users/[id]', { params: { id: '42' }, query: { tab: 'settings' }, hash: 'bio' })
+* // → { path: '/users/42', queryParams: { tab: 'settings' }, fragment: 'bio' }
+*
+* @example Template usage
+* ```html
+* @let link = routePath('/users/[id]', { params: { id: userId } });
+* <a [routerLink]="link.path" [queryParams]="link.queryParams" [fragment]="link.fragment">
+* ```
+*/
+function routePath(path, ...args) {
+	const options = args[0];
+	return buildRouteLink(path, options);
 }
 /**
- * Provides extra custom routes in addition to the routes
- * discovered from the filesystem-based routing. These routes are
- * inserted before the filesystem-based routes, and take priority in
- * route matching.
- */
-function withExtraRoutes(routes) {
-    return {
-        ɵkind: 100,
-        ɵproviders: [{ provide: ROUTES, useValue: routes, multi: true }],
-    };
+* Internal: builds a `RouteLinkResult` from path and options.
+* Exported for direct use in tests (avoids generic constraints).
+*/
+function buildRouteLink(path, options) {
+	const resolvedPath = buildPath(path, options?.params);
+	let queryParams = null;
+	if (options?.query) {
+		const filtered = {};
+		let hasEntries = false;
+		for (const [key, value] of Object.entries(options.query)) if (value !== void 0) {
+			filtered[key] = value;
+			hasEntries = true;
+		}
+		if (hasEntries) queryParams = filtered;
+	}
+	return {
+		path: resolvedPath,
+		queryParams,
+		fragment: options?.hash
+	};
 }
-
-function injectLoad(options) {
-    const injector = options?.injector ?? inject(Injector);
-    const route = injector.get(ActivatedRoute);
-    return route.data.pipe(map((data) => data['load']));
+/**
+* Resolves param placeholders and normalises slashes.
+* Returns only the path — no query string or hash.
+*/
+function buildPath(path, params) {
+	let url = path;
+	if (params) {
+		url = url.replace(/\[\[\.\.\.([^\]]+)\]\]/g, (_, name) => {
+			const value = params[name];
+			if (value == null) return "";
+			if (Array.isArray(value)) return value.map((v) => encodeURIComponent(v)).join("/");
+			return encodeURIComponent(String(value));
+		});
+		url = url.replace(/\[\.\.\.([^\]]+)\]/g, (_, name) => {
+			const value = params[name];
+			if (value == null) throw new Error(`Missing required catch-all param "${name}" for path "${path}"`);
+			if (Array.isArray(value)) {
+				if (value.length === 0) throw new Error(`Missing required catch-all param "${name}" for path "${path}"`);
+				return value.map((v) => encodeURIComponent(v)).join("/");
+			}
+			return encodeURIComponent(String(value));
+		});
+		url = url.replace(/\[([^\]]+)\]/g, (_, name) => {
+			const value = params[name];
+			if (value == null) throw new Error(`Missing required param "${name}" for path "${path}"`);
+			return encodeURIComponent(String(value));
+		});
+	} else {
+		url = url.replace(/\[\[\.\.\.([^\]]+)\]\]/g, "");
+		url = url.replace(/\[\.\.\.([^\]]+)\]/g, "");
+		url = url.replace(/\[([^\]]+)\]/g, "");
+	}
+	url = url.replace(/\/+/g, "/");
+	if (url.length > 1 && url.endsWith("/")) url = url.slice(0, -1);
+	if (!url.startsWith("/")) url = "/" + url;
+	return url;
 }
-
 /**
- * Get server load resolver data for the route
- *
- * @param route Provides the route to get server load resolver
- * @returns Returns server load resolver data for the route
- */
-async function getLoadResolver(route) {
-    return route.routeConfig?.resolve?.['load']?.(route);
+* Internal URL builder. Separated from `routePath` so it can be
+* used without generic constraints (e.g., in `injectNavigate`).
+*/
+function buildUrl(path, options) {
+	let url = buildPath(path, options?.params);
+	if (options?.query) {
+		const parts = [];
+		for (const [key, value] of Object.entries(options.query)) {
+			if (value === void 0) continue;
+			if (Array.isArray(value)) for (const v of value) parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(v)}`);
+			else parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+		}
+		if (parts.length > 0) url += "?" + parts.join("&");
+	}
+	if (options?.hash) url += "#" + options.hash;
+	return url;
 }
-
-function sortAndConcatParams(params) {
-    return [...params.keys()]
-        .sort()
-        .map((k) => `${k}=${params.getAll(k)}`)
-        .join('&');
+//#endregion
+//#region packages/router/src/lib/inject-navigate.ts
+function isRoutePathOptionsBase(value) {
+	return !!value && typeof value === "object" && ("params" in value || "query" in value || "hash" in value);
 }
-function makeCacheKey(request, mappedRequestUrl) {
-    // make the params encoded same as a url so it's easy to identify
-    const { params, method, responseType } = request;
-    const encodedParams = sortAndConcatParams(params);
-    let serializedBody = request.serializeBody();
-    if (serializedBody instanceof URLSearchParams) {
-        serializedBody = sortAndConcatParams(serializedBody);
-    }
-    else if (typeof serializedBody !== 'string') {
-        serializedBody = '';
-    }
-    const key = [
-        method,
-        responseType,
-        mappedRequestUrl,
-        serializedBody,
-        encodedParams,
-    ].join('|');
-    const hash = generateHash(key);
-    return makeStateKey(hash);
+/**
+* Injects a typed navigate function.
+*
+* @example
+* ```ts
+* const navigate = injectNavigate();
+*
+* navigate('/users/[id]', { params: { id: '42' } });   // ✅
+* navigate('/users/[id]', { params: { id: 42 } });     // ❌ type error
+*
+* // With navigation extras
+* navigate('/users/[id]', { params: { id: '42' } }, { replaceUrl: true });
+* ```
+*/
+function injectNavigate() {
+	const router = inject(Router);
+	const navigate = ((path, ...args) => {
+		let options;
+		let extras;
+		if (args.length > 1) {
+			options = args[0];
+			extras = args[1];
+		} else if (args.length === 1) if (isRoutePathOptionsBase(args[0])) options = args[0];
+		else extras = args[0];
+		const url = buildUrl(path, options);
+		return router.navigateByUrl(url, extras);
+	});
+	return navigate;
 }
-function generateHash(str) {
-    let hash = 0;
-    for (let i = 0, len = str.length; i < len; i++) {
-        let chr = str.charCodeAt(i);
-        hash = (hash << 5) - hash + chr;
-        hash |= 0; // Convert to 32bit integer
-    }
-    return `${hash}`;
+//#endregion
+//#region packages/router/src/lib/experimental.ts
+/** @experimental */
+var EXPERIMENTAL_TYPED_ROUTER = new InjectionToken("EXPERIMENTAL_TYPED_ROUTER");
+/** @experimental */
+var EXPERIMENTAL_ROUTE_CONTEXT = new InjectionToken("EXPERIMENTAL_ROUTE_CONTEXT");
+/** @experimental */
+var EXPERIMENTAL_LOADER_CACHE = new InjectionToken("EXPERIMENTAL_LOADER_CACHE");
+/**
+* Enables experimental typed router features.
+*
+* When active, `routePath()`, `injectNavigate()`, `injectParams()`,
+* and `injectQuery()` will enforce route table constraints and
+* optionally log warnings in strict mode.
+*
+* Inspired by TanStack Router's `Register` interface and strict type
+* checking across the entire navigation surface.
+*
+* @example
+* ```ts
+* provideFileRouter(
+*   withTypedRouter({ strictRouteParams: true }),
+* )
+* ```
+*
+* @experimental
+*/
+function withTypedRouter(options) {
+	return {
+		ɵkind: 102,
+		ɵproviders: [{
+			provide: EXPERIMENTAL_TYPED_ROUTER,
+			useValue: {
+				strictRouteParams: false,
+				...options
+			}
+		}]
+	};
 }
-
 /**
- * Interceptor that is server-aware when making HttpClient requests.
- * Server-side requests use the full URL
- * Prerendering uses the internal Nitro $fetch function, along with state transfer
- * Client-side requests use the window.location.origin
- *
- * @param req HttpRequest<unknown>
- * @param next HttpHandlerFn
- * @returns
- */
-function requestContextInterceptor(req, next) {
-    const apiPrefix = injectAPIPrefix();
-    const baseUrl = injectBaseURL();
-    const transferState = inject(TransferState);
-    const nitroGlobal = globalThis;
-    const internalFetch = injectInternalServerFetch();
-    const serverFetch = internalFetch ?? nitroGlobal.$fetch;
-    // during prerendering with Nitro
-    if (serverFetch &&
-        baseUrl &&
-        (req.url.startsWith('/') ||
-            req.url.startsWith(baseUrl) ||
-            req.url.startsWith(`/${apiPrefix}`))) {
-        const requestUrl = new URL(req.url, baseUrl);
-        const cacheKey = makeCacheKey(req, new URL(requestUrl).pathname);
-        const storeKey = makeStateKey(`analog_${cacheKey}`);
-        const fetchUrl = requestUrl.pathname;
-        const responseType = req.responseType === 'arraybuffer' ? 'arrayBuffer' : req.responseType;
-        return from(serverFetch
-            .raw(fetchUrl, {
-            method: req.method,
-            body: req.body ? req.body : undefined,
-            params: requestUrl.searchParams,
-            responseType,
-            headers: req.headers
-                .keys()
-                .reduce((hdrs, current) => {
-                return {
-                    ...hdrs,
-                    [current]: req.headers.get(current),
-                };
-            }, {}),
-        })
-            .then((res) => {
-            const cacheResponse = {
-                body: res._data,
-                headers: new HttpHeaders(res.headers),
-                status: res.status ?? 200,
-                statusText: res.statusText ?? 'OK',
-                url: fetchUrl,
-            };
-            const transferResponse = new HttpResponse(cacheResponse);
-            transferState.set(storeKey, cacheResponse);
-            return transferResponse;
-        }));
-    }
-    // on the client
-    if (!import.meta.env.SSR &&
-        (req.url.startsWith('/') || req.url.includes('/_analog/'))) {
-        // /_analog/ requests are full URLs
-        const requestUrl = req.url.includes('/_analog/')
-            ? req.url
-            : `${window.location.origin}${req.url}`;
-        const cacheKey = makeCacheKey(req, new URL(requestUrl).pathname);
-        const storeKey = makeStateKey(`analog_${cacheKey}`);
-        const cacheRestoreResponse = transferState.get(storeKey, null);
-        if (cacheRestoreResponse) {
-            transferState.remove(storeKey);
-            return of(new HttpResponse(cacheRestoreResponse));
-        }
-        return next(req.clone({
-            url: requestUrl,
-        }));
-    }
-    // on the server
-    if (baseUrl && (req.url.startsWith('/') || req.url.startsWith(baseUrl))) {
-        const requestUrl = req.url.startsWith(baseUrl) && !req.url.startsWith('/')
-            ? req.url
-            : `${baseUrl}${req.url}`;
-        return next(req.clone({
-            url: requestUrl,
-        }));
-    }
-    return next(req);
+* Provides root-level route context available to all route loaders
+* and components via `injectRouteContext()`.
+*
+* Inspired by TanStack Router's `createRootRouteWithContext<T>()` where
+* a typed context object is required at router creation and automatically
+* available in every route's `beforeLoad` and `loader`.
+*
+* In Angular terms, this creates a DI token that server-side load
+* functions and components can inject to access shared services
+* without importing them individually.
+*
+* @example
+* ```ts
+* // app.config.ts
+* provideFileRouter(
+*   withRouteContext({
+*     auth: inject(AuthService),
+*     db: inject(DatabaseService),
+*   }),
+* )
+*
+* // In a component
+* const ctx = injectRouteContext<{ auth: AuthService; db: DatabaseService }>();
+* ```
+*
+* @experimental
+*/
+function withRouteContext(context) {
+	return {
+		ɵkind: 103,
+		ɵproviders: [{
+			provide: EXPERIMENTAL_ROUTE_CONTEXT,
+			useValue: context
+		}]
+	};
 }
-
-class FormAction {
-    constructor() {
-        this.action = input('', ...(ngDevMode ? [{ debugName: "action" }] : []));
-        this.onSuccess = output();
-        this.onError = output();
-        this.state = output();
-        this.router = inject(Router);
-        this.route = inject(ActivatedRoute);
-        this.path = this._getPath();
-    }
-    submitted($event) {
-        $event.preventDefault();
-        this.state.emit('submitting');
-        const body = new FormData($event.target);
-        if ($event.target.method.toUpperCase() === 'GET') {
-            this._handleGet(body, this.router.url);
-        }
-        else {
-            this._handlePost(body, this.path, $event);
-        }
-    }
-    _handleGet(body, path) {
-        const params = {};
-        body.forEach((formVal, formKey) => (params[formKey] = formVal));
-        this.state.emit('navigate');
-        const url = path.split('?')[0];
-        this.router.navigate([url], {
-            queryParams: params,
-            onSameUrlNavigation: 'reload',
-        });
-    }
-    _handlePost(body, path, $event) {
-        fetch(path, {
-            method: $event.target.method,
-            body,
-        })
-            .then((res) => {
-            if (res.ok) {
-                if (res.redirected) {
-                    const redirectUrl = new URL(res.url).pathname;
-                    this.state.emit('redirect');
-                    this.router.navigate([redirectUrl]);
-                }
-                else if (this._isJSON(res.headers.get('Content-type'))) {
-                    res.json().then((result) => {
-                        this.onSuccess.emit(result);
-                        this.state.emit('success');
-                    });
-                }
-                else {
-                    res.text().then((result) => {
-                        this.onSuccess.emit(result);
-                        this.state.emit('success');
-                    });
-                }
-            }
-            else {
-                if (res.headers.get('X-Analog-Errors')) {
-                    res.json().then((errors) => {
-                        this.onError.emit(errors);
-                        this.state.emit('error');
-                    });
-                }
-                else {
-                    this.state.emit('error');
-                }
-            }
-        })
-            .catch((_) => {
-            this.state.emit('error');
-        });
-    }
-    _getPath() {
-        if (this.route) {
-            return injectRouteEndpointURL(this.route.snapshot).pathname;
-        }
-        return `/api/_analog/pages${window.location.pathname}`;
-    }
-    _isJSON(contentType) {
-        const mime = contentType ? contentType.split(';') : [];
-        const essence = mime[0];
-        return essence === 'application/json';
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: FormAction, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.1.1", type: FormAction, isStandalone: true, selector: "form[action],form[method]", inputs: { action: { classPropertyName: "action", publicName: "action", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { onSuccess: "onSuccess", onError: "onError", state: "state" }, host: { listeners: { "submit": "submitted($event)" } }, ngImport: i0 }); }
+/**
+* Configures experimental loader caching behavior for server-loaded
+* route data.
+*
+* Inspired by TanStack Router's built-in cache where `createRouter()`
+* accepts `defaultStaleTime` and `defaultGcTime` to control when
+* loaders re-execute and when cached data is discarded.
+*
+* @example
+* ```ts
+* provideFileRouter(
+*   withLoaderCaching({
+*     defaultStaleTime: 30_000,  // 30s before re-fetch
+*     defaultGcTime: 300_000,    // 5min cache retention
+*     defaultPendingMs: 200,     // 200ms loading delay
+*   }),
+* )
+* ```
+*
+* @experimental
+*/
+function withLoaderCaching(options) {
+	return {
+		ɵkind: 104,
+		ɵproviders: [{
+			provide: EXPERIMENTAL_LOADER_CACHE,
+			useValue: {
+				defaultStaleTime: 0,
+				defaultGcTime: 3e5,
+				defaultPendingMs: 0,
+				...options
+			}
+		}]
+	};
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: FormAction, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: 'form[action],form[method]',
-                    host: {
-                        '(submit)': `submitted($event)`,
-                    },
-                    standalone: true,
-                }]
-        }], propDecorators: { action: [{ type: i0.Input, args: [{ isSignal: true, alias: "action", required: false }] }], onSuccess: [{ type: i0.Output, args: ["onSuccess"] }], onError: [{ type: i0.Output, args: ["onError"] }], state: [{ type: i0.Output, args: ["state"] }] } });
-
-const DEBUG_ROUTES = new InjectionToken('@analogjs/router debug routes', {
-    providedIn: 'root',
-    factory() {
-        const debugRoutes = createRoutes({
-            ...ANALOG_ROUTE_FILES,
-            ...ANALOG_CONTENT_ROUTE_FILES,
-        }, true);
-        return debugRoutes;
-    },
-});
-function injectDebugRoutes() {
-    return inject(DEBUG_ROUTES);
+//#endregion
+//#region packages/router/src/lib/inject-typed-params.ts
+function extractRouteParams(routePath) {
+	const params = [];
+	for (const match of routePath.matchAll(/\[\[\.\.\.([^\]]+)\]\]/g)) params.push({
+		name: match[1],
+		type: "optionalCatchAll"
+	});
+	for (const match of routePath.matchAll(/(?<!\[)\[\.\.\.([^\]]+)\](?!\])/g)) params.push({
+		name: match[1],
+		type: "catchAll"
+	});
+	for (const match of routePath.matchAll(/(?<!\[)\[(?!\.)([^\]]+)\](?!\])/g)) params.push({
+		name: match[1],
+		type: "dynamic"
+	});
+	return params;
 }
-
 /**
- * Provides routes that provide additional
- * pages for displaying and debugging
- * routes.
- */
-function withDebugRoutes() {
-    const routes = [
-        {
-            path: '__analog/routes',
-            loadComponent: () => import('./analogjs-router-debug.page-jzggTA45.mjs'),
-        },
-    ];
-    return {
-        ɵkind: 101,
-        ɵproviders: [{ provide: ROUTES, useValue: routes, multi: true }],
-    };
+* When `strictRouteParams` is enabled, warns if expected params from the
+* `_from` pattern are missing from the active `ActivatedRoute`.
+*/
+function assertRouteMatch(from, route, kind) {
+	const expectedParams = extractRouteParams(from).filter((param) => param.type === "dynamic" || param.type === "catchAll").map((param) => param.name);
+	if (expectedParams.length === 0) return;
+	route.params.pipe(take(1)).subscribe((params) => {
+		for (const name of expectedParams) if (!(name in params)) {
+			console.warn(`[Analog] ${kind}('${from}'): expected param "${name}" is not present in the active route's params. Ensure this hook is used inside a component rendered by '${from}'.`);
+			break;
+		}
+	});
 }
-
 /**
- * @description
- * Component that defines the bridge between the client and server-only
- * components. The component passes the component ID and props to the server
- * and retrieves the rendered HTML and outputs from the server-only component.
- *
- * Status: experimental
- */
-class ServerOnly {
-    constructor() {
-        this.component = input.required(...(ngDevMode ? [{ debugName: "component" }] : []));
-        this.props = input(...(ngDevMode ? [undefined, { debugName: "props" }] : []));
-        this.outputs = output();
-        this.http = inject(HttpClient);
-        this.sanitizer = inject(DomSanitizer);
-        this.content = signal('', ...(ngDevMode ? [{ debugName: "content" }] : []));
-        this.route = inject(ActivatedRoute, { optional: true });
-        this.baseURL = injectBaseURL();
-        this.transferState = inject(TransferState);
-        effect(() => {
-            const routeComponentId = this.route?.snapshot.data['component'];
-            const props = this.props() || {};
-            const componentId = routeComponentId || this.component();
-            const headers = new HttpHeaders(new Headers({
-                'Content-type': 'application/json',
-                'X-Analog-Component': componentId,
-            }));
-            const componentUrl = this.getComponentUrl(componentId);
-            const httpRequest = new HttpRequest('POST', componentUrl, props, {
-                headers,
-            });
-            const cacheKey = makeCacheKey(httpRequest, new URL(componentUrl).pathname);
-            const storeKey = makeStateKey(cacheKey);
-            const componentState = this.transferState.get(storeKey, null);
-            if (componentState) {
-                this.updateContent(componentState);
-                this.transferState.remove(storeKey);
-            }
-            else {
-                this.http
-                    .request(httpRequest)
-                    .pipe(map((response) => {
-                    if (response instanceof HttpResponse) {
-                        if (import.meta.env.SSR) {
-                            this.transferState.set(storeKey, response.body);
-                        }
-                        return response.body;
-                    }
-                    return throwError(() => ({}));
-                }), catchError((error) => {
-                    console.log(error);
-                    return of({
-                        html: '',
-                        outputs: {},
-                    });
-                }))
-                    .subscribe((content) => this.updateContent(content));
-            }
-        });
-    }
-    updateContent(content) {
-        this.content.set(this.sanitizer.bypassSecurityTrustHtml(content.html));
-        this.outputs.emit(content.outputs);
-    }
-    getComponentUrl(componentId) {
-        let baseURL = this.baseURL;
-        if (!baseURL && typeof window !== 'undefined') {
-            baseURL = window.location.origin;
-        }
-        return `${baseURL}/_analog/components/${componentId}`;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: ServerOnly, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.1.1", type: ServerOnly, isStandalone: true, selector: "server-only,ServerOnly,Server", inputs: { component: { classPropertyName: "component", publicName: "component", isSignal: true, isRequired: true, transformFunction: null }, props: { classPropertyName: "props", publicName: "props", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { outputs: "outputs" }, ngImport: i0, template: ` <div [innerHTML]="content()"></div> `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+* Injects typed route params as a signal, constrained by the route table.
+*
+* Inspired by TanStack Router's `useParams({ from: '/users/$userId' })`
+* pattern where the `from` parameter narrows the return type to only
+* the params defined for that route.
+*
+* The `from` parameter is used purely for TypeScript type inference —
+* at runtime, params are read from the current `ActivatedRoute`. This
+* means it works correctly when used inside a component rendered by
+* the specified route.
+*
+* When `withTypedRouter({ strictRouteParams: true })` is configured,
+* a dev-mode assertion checks that the expected params from `from`
+* exist in the active route and warns on mismatch.
+*
+* @example
+* ```ts
+* // In a component rendered at /users/[id]
+* const params = injectParams('/users/[id]');
+* // params() → { id: string }
+*
+* // With schema validation output types
+* const params = injectParams('/products/[slug]');
+* // params() → validated output type from routeParamsSchema
+* ```
+*
+* @experimental
+*/
+function injectParams(_from, options) {
+	const injector = options?.injector;
+	const route = injector ? injector.get(ActivatedRoute) : inject(ActivatedRoute);
+	if (isDevMode()) {
+		if ((injector ? injector.get(EXPERIMENTAL_TYPED_ROUTER, null) : inject(EXPERIMENTAL_TYPED_ROUTER, { optional: true }))?.strictRouteParams) assertRouteMatch(_from, route, "injectParams");
+	}
+	return toSignal(route.params.pipe(map((params) => params)), { requireSync: true });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: ServerOnly, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'server-only,ServerOnly,Server',
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                    template: ` <div [innerHTML]="content()"></div> `,
-                }]
-        }], ctorParameters: () => [], propDecorators: { component: [{ type: i0.Input, args: [{ isSignal: true, alias: "component", required: true }] }], props: [{ type: i0.Input, args: [{ isSignal: true, alias: "props", required: false }] }], outputs: [{ type: i0.Output, args: ["outputs"] }] } });
-
 /**
- * Generated bundle index. Do not edit.
- */
+* Injects typed route query params as a signal, constrained by the
+* route table.
+*
+* Inspired by TanStack Router's `useSearch({ from: '/issues' })` pattern
+* where search params are validated and typed per-route via
+* `validateSearch` schemas.
+*
+* In Analog, the typing comes from `routeQuerySchema` exports that are
+* detected at build time and recorded in the generated route table.
+*
+* The `from` parameter is used purely for TypeScript type inference.
+* When `withTypedRouter({ strictRouteParams: true })` is configured,
+* a dev-mode assertion checks that the expected params from `from`
+* exist in the active route and warns on mismatch.
+*
+* @example
+* ```ts
+* // In a component rendered at /issues
+* // (where routeQuerySchema validates { page: number, status: string })
+* const query = injectQuery('/issues');
+* // query() → { page: number; status: string }
+* ```
+*
+* @experimental
+*/
+function injectQuery(_from, options) {
+	const injector = options?.injector;
+	const route = injector ? injector.get(ActivatedRoute) : inject(ActivatedRoute);
+	if (isDevMode()) {
+		if ((injector ? injector.get(EXPERIMENTAL_TYPED_ROUTER, null) : inject(EXPERIMENTAL_TYPED_ROUTER, { optional: true }))?.strictRouteParams) assertRouteMatch(_from, route, "injectQuery");
+	}
+	return toSignal(route.queryParams.pipe(map((params) => params)), { requireSync: true });
+}
+//#endregion
+//#region packages/router/src/lib/inject-route-context.ts
+/**
+* Injects the root route context provided via `withRouteContext()`.
+*
+* Inspired by TanStack Router's context inheritance where
+* `createRootRouteWithContext<T>()` makes a typed context available
+* to every route's `beforeLoad` and `loader` callbacks.
+*
+* In Angular, this uses DI under the hood — `withRouteContext(ctx)`
+* provides the value, and `injectRouteContext<T>()` retrieves it
+* with the expected type.
+*
+* @example
+* ```ts
+* // app.config.ts
+* provideFileRouter(
+*   withRouteContext({
+*     auth: inject(AuthService),
+*     analytics: inject(AnalyticsService),
+*   }),
+* )
+*
+* // any-page.page.ts
+* const ctx = injectRouteContext<{
+*   auth: AuthService;
+*   analytics: AnalyticsService;
+* }>();
+* ctx.analytics.trackPageView();
+* ```
+*
+* @experimental
+*/
+function injectRouteContext() {
+	return inject(EXPERIMENTAL_ROUTE_CONTEXT);
+}
+//#endregion
+export { EXPERIMENTAL_LOADER_CACHE, EXPERIMENTAL_ROUTE_CONTEXT, EXPERIMENTAL_TYPED_ROUTER, FormAction, ServerOnly, createRoutes, defineRouteMeta, getLoadResolver, injectActivatedRoute, injectDebugRoutes, injectLoad, injectLoadData, injectNavigate, injectParams, injectQuery, injectRouteContext, injectRouteEndpointURL, injectRouter, issuePathToFieldName, issuesToFieldErrors, issuesToFormErrors, provideFileRouter, requestContextInterceptor, routePath, routes, withDebugRoutes, withExtraRoutes, withLoaderCaching, withRouteContext, withTypedRouter };
 
-export { FormAction, ServerOnly, createRoutes, defineRouteMeta, getLoadResolver, injectActivatedRoute, injectDebugRoutes, injectLoad, injectRouteEndpointURL, injectRouter, provideFileRouter, requestContextInterceptor, routes, withDebugRoutes, withExtraRoutes };
-//# sourceMappingURL=analogjs-router.mjs.map
+//# sourceMappingURL=analogjs-router.mjs.map