@analogjs/router 3.0.0-alpha.13 → 3.0.0-alpha.15

package/fesm2022/analogjs-router.mjs

@@ -1,12 +1,13 @@
-import { a as updateMetaTagsOnRouteChange, i as injectRouteEndpointURL, n as createRoutes, r as routes, t as injectDebugRoutes } from "./routes.mjs";
+import { a as updateMetaTagsOnRouteChange, i as injectRouteEndpointURL, n as createRoutes, o as updateJsonLdOnRouteChange, 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, Injector, PLATFORM_ID, TransferState, effect, inject, input, makeEnvironmentProviders, makeStateKey, output, signal } 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, throwError } from "rxjs";
+import { catchError, from, map, of, take, throwError } from "rxjs";
 import { API_PREFIX, injectAPIPrefix, injectBaseURL, injectInternalServerFetch, injectRequest } from "@analogjs/router/tokens";
-import { DomSanitizer } from "@angular/platform-browser";
 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.
@@ -86,6 +87,11 @@ function provideFileRouter(...features) {
 			multi: true,
 			useValue: () => updateMetaTagsOnRouteChange()
 		},
+		{
+			provide: ENVIRONMENT_INITIALIZER,
+			multi: true,
+			useValue: () => updateJsonLdOnRouteChange()
+		},
 		{
 			provide: ɵHTTP_ROOT_INTERCEPTOR_FNS,
 			multi: true,
@@ -550,6 +556,425 @@ i0.ɵɵngDeclareClassMetadata({
 	}
 });
 //#endregion
-export { FormAction, ServerOnly, createRoutes, defineRouteMeta, getLoadResolver, injectActivatedRoute, injectDebugRoutes, injectLoad, injectLoadData, injectRouteEndpointURL, injectRouter, provideFileRouter, requestContextInterceptor, routes, withDebugRoutes, withExtraRoutes };
+//#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
+/**
+* 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);
+}
+/**
+* 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
+	};
+}
+/**
+* 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;
+}
+/**
+* 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;
+}
+//#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);
+}
+/**
+* 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;
+}
+//#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
+			}
+		}]
+	};
+}
+/**
+* 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
+		}]
+	};
+}
+/**
+* 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
+			}
+		}]
+	};
+}
+//#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;
+}
+/**
+* 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;
+		}
+	});
+}
+/**
+* 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 });
+}
+/**
+* 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 };
 
 //# sourceMappingURL=analogjs-router.mjs.map

package/fesm2022/routes.mjs

@@ -3,8 +3,61 @@ import { InjectionToken, inject } from "@angular/core";
 import { HttpClient } from "@angular/common/http";
 import { firstValueFrom } from "rxjs";
 import { injectAPIPrefix, injectBaseURL, injectInternalServerFetch } from "@analogjs/router/tokens";
-import { Meta } from "@angular/platform-browser";
+import { DOCUMENT } from "@angular/common";
 import { filter } from "rxjs/operators";
+import { Meta } from "@angular/platform-browser";
+//#region packages/router/src/lib/json-ld.ts
+function isJsonLdObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeJsonLd(value) {
+	if (Array.isArray(value)) return value.filter(isJsonLdObject);
+	return isJsonLdObject(value) ? [value] : [];
+}
+var ROUTE_JSON_LD_KEY = Symbol("@analogjs/router Route JSON-LD Key");
+var JSON_LD_SCRIPT_SELECTOR = "script[data-analog-json-ld]";
+function updateJsonLdOnRouteChange() {
+	const router = inject(Router);
+	const document = inject(DOCUMENT);
+	router.events.pipe(filter((event) => event instanceof NavigationEnd)).subscribe(() => {
+		applyJsonLdToDocument(document, getJsonLdEntries(router.routerState.snapshot.root));
+	});
+}
+function serializeJsonLd(entry) {
+	try {
+		return JSON.stringify(entry).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+	} catch {
+		return null;
+	}
+}
+function getJsonLdEntries(route) {
+	const entries = [];
+	let currentRoute = route;
+	while (currentRoute) {
+		entries.push(...normalizeJsonLd(currentRoute.data[ROUTE_JSON_LD_KEY]));
+		currentRoute = currentRoute.firstChild;
+	}
+	return entries;
+}
+function applyJsonLdToDocument(document, entries) {
+	document.querySelectorAll(JSON_LD_SCRIPT_SELECTOR).forEach((element) => {
+		element.remove();
+	});
+	if (entries.length === 0) return;
+	const head = document.head || document.getElementsByTagName("head")[0];
+	if (!head) return;
+	entries.forEach((entry, index) => {
+		const serialized = serializeJsonLd(entry);
+		if (!serialized) return;
+		const script = document.createElement("script");
+		script.type = "application/ld+json";
+		script.setAttribute("data-analog-json-ld", "true");
+		script.setAttribute("data-analog-json-ld-index", String(index));
+		script.textContent = serialized;
+		head.appendChild(script);
+	});
+}
+//#endregion
 //#region packages/router/src/lib/meta-tags.ts
 var ROUTE_META_TAGS_KEY = Symbol("@analogjs/router Route Meta Tags Key");
 var CHARSET_KEY = "charset";
@@ -74,8 +127,8 @@ function injectRouteEndpointURL(route) {
 //#endregion
 //#region packages/router/src/lib/route-config.ts
 function toRouteConfig(routeMeta) {
-	if (routeMeta && isRedirectRouteMeta(routeMeta)) return routeMeta;
-	const { meta, ...routeConfig } = routeMeta ?? {};
+	if (routeMeta && isRedirectRouteMeta$1(routeMeta)) return routeMeta;
+	const { meta, jsonLd, ...routeConfig } = routeMeta ?? {};
 	if (Array.isArray(meta)) routeConfig.data = {
 		...routeConfig.data,
 		[ROUTE_META_TAGS_KEY]: meta
@@ -84,6 +137,14 @@ function toRouteConfig(routeMeta) {
 		...routeConfig.resolve,
 		[ROUTE_META_TAGS_KEY]: meta
 	};
+	if (Array.isArray(jsonLd) || isJsonLdObject(jsonLd)) routeConfig.data = {
+		...routeConfig.data,
+		[ROUTE_JSON_LD_KEY]: jsonLd
+	};
+	else if (typeof jsonLd === "function") routeConfig.resolve = {
+		...routeConfig.resolve,
+		[ROUTE_JSON_LD_KEY]: jsonLd
+	};
 	routeConfig.runGuardsAndResolvers = routeConfig.runGuardsAndResolvers ?? "paramsOrQueryParamsChange";
 	routeConfig.resolve = {
 		...routeConfig.resolve,
@@ -107,7 +168,7 @@ function toRouteConfig(routeMeta) {
 	};
 	return routeConfig;
 }
-function isRedirectRouteMeta(routeMeta) {
+function isRedirectRouteMeta$1(routeMeta) {
 	return !!routeMeta.redirectTo;
 }
 //#endregion
@@ -118,13 +179,14 @@ function toMarkdownModule(markdownFileFactory) {
 		const createLoader = () => Promise.all([import("@analogjs/content"), markdownFileFactory()]);
 		const [{ parseRawContentFile, MarkdownRouteComponent, ContentRenderer }, markdownFile] = await (isNgZoneEnabled ? Zone.root.run(createLoader) : createLoader());
 		const { content, attributes } = parseRawContentFile(markdownFile);
-		const { title, meta } = attributes;
+		const { title, meta, jsonLd } = attributes;
 		return {
 			default: MarkdownRouteComponent,
 			routeMeta: {
 				data: { _analogContent: content },
 				title,
 				meta,
+				jsonLd,
 				resolve: { renderedAnalogContent: async () => {
 					const rendered = await inject(ContentRenderer).render(content);
 					return typeof rendered === "string" ? rendered : rendered.content;
@@ -239,17 +301,24 @@ function toRoutes(rawRoutes, files, debug = false) {
 		const route = module ? {
 			path: rawRoute.segment,
 			loadChildren: () => module().then((m) => {
-				return [{
+				const routeConfig = toRouteConfig(mergeRouteJsonLdIntoRouteMeta(m.routeMeta, m.routeJsonLd));
+				const hasRedirect = "redirectTo" in routeConfig;
+				return [{ ...hasRedirect ? {
+					path: "",
+					...routeConfig
+				} : {
 					path: "",
 					component: m.default,
-					...toRouteConfig(m.routeMeta),
+					...routeConfig,
 					children,
 					[ANALOG_META_KEY]: analogMeta
-				}, ...optCatchAllParam ? [{
+				} }, ...optCatchAllParam ? [{
 					matcher: createOptionalCatchAllMatcher(optCatchAllParam),
-					component: m.default,
-					...toRouteConfig(m.routeMeta),
-					[ANALOG_META_KEY]: analogMeta
+					...hasRedirect ? routeConfig : {
+						component: m.default,
+						...routeConfig,
+						[ANALOG_META_KEY]: analogMeta
+					}
 				}] : []];
 			})
 		} : {
@@ -264,6 +333,18 @@ function toRoutes(rawRoutes, files, debug = false) {
 	}
 	return routes;
 }
+function mergeRouteJsonLdIntoRouteMeta(routeMeta, routeJsonLd) {
+	if (!routeJsonLd) return routeMeta;
+	if (!routeMeta) return { jsonLd: routeJsonLd };
+	if (isRedirectRouteMeta(routeMeta) || routeMeta.jsonLd) return routeMeta;
+	return {
+		...routeMeta,
+		jsonLd: routeJsonLd
+	};
+}
+function isRedirectRouteMeta(routeMeta) {
+	return "redirectTo" in routeMeta && !!routeMeta.redirectTo;
+}
 function sortRawRoutes(rawRoutes) {
 	rawRoutes.sort((a, b) => {
 		let segmentA = deprioritizeSegment(a.segment);
@@ -296,6 +377,6 @@ function injectDebugRoutes() {
 	return inject(DEBUG_ROUTES);
 }
 //#endregion
-export { updateMetaTagsOnRouteChange as a, injectRouteEndpointURL as i, createRoutes as n, routes as r, injectDebugRoutes as t };
+export { updateMetaTagsOnRouteChange as a, injectRouteEndpointURL as i, createRoutes as n, updateJsonLdOnRouteChange as o, routes as r, injectDebugRoutes as t };
 
 //# sourceMappingURL=routes.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@analogjs/router",
-  "version": "3.0.0-alpha.13",
+  "version": "3.0.0-alpha.15",
   "description": "Filesystem-based routing for Angular",
   "type": "module",
   "author": "Brandon Roberts <robertsbt@gmail.com>",
@@ -54,11 +54,12 @@
     "url": "https://github.com/sponsors/brandonroberts"
   },
   "peerDependencies": {
-    "@analogjs/content": "^3.0.0-alpha.13",
+    "@analogjs/content": "^3.0.0-alpha.15",
     "@angular/core": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0",
     "@angular/platform-server": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0",
     "@angular/router": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0",
-    "@tanstack/angular-query-experimental": ">=5.95.0"
+    "@tanstack/angular-query-experimental": ">=5.95.0",
+    "schema-dts": "^2.0.0"
   },
   "peerDependenciesMeta": {
     "@angular/platform-server": {
@@ -66,6 +67,9 @@
     },
     "@tanstack/angular-query-experimental": {
       "optional": true
+    },
+    "schema-dts": {
+      "optional": true
     }
   },
   "dependencies": {
@@ -73,7 +77,7 @@
     "tslib": "^2.0.0"
   },
   "devDependencies": {
-    "@analogjs/vite-plugin-angular": "^3.0.0-alpha.13"
+    "@analogjs/vite-plugin-angular": "^3.0.0-alpha.15"
   },
   "ng-update": {
     "packageGroup": [

package/types/server/actions/src/define-api-route.d.ts

@@ -0,0 +1,57 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { H3Event } from 'nitro/h3';
+export type DefineApiRouteResult = Response | unknown;
+type OptionalSchema = StandardSchemaV1 | undefined;
+type InferSchema<TSchema extends OptionalSchema, TFallback = unknown> = TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TFallback;
+type ResolveDataSchema<TInput extends OptionalSchema, TQuery extends OptionalSchema, TBody extends OptionalSchema> = TInput extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TInput> : TQuery extends StandardSchemaV1 ? TBody extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TQuery> | StandardSchemaV1.InferOutput<TBody> : StandardSchemaV1.InferOutput<TQuery> : TBody extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TBody> : unknown;
+export interface DefineApiRouteContext<TInput extends StandardSchemaV1 | undefined = undefined, TQuery extends StandardSchemaV1 | undefined = undefined, TBody extends StandardSchemaV1 | undefined = undefined, TParams extends StandardSchemaV1 | undefined = undefined> {
+    data: ResolveDataSchema<TInput, TQuery, TBody>;
+    query: InferSchema<TQuery, undefined>;
+    body: InferSchema<TBody, undefined>;
+    params: InferSchema<TParams, H3Event['context']['params']>;
+    event: H3Event;
+}
+export interface DefineApiRouteOptions<TInput extends StandardSchemaV1 | undefined = undefined, TOutput extends StandardSchemaV1 | undefined = undefined, TQuery extends StandardSchemaV1 | undefined = undefined, TBody extends StandardSchemaV1 | undefined = undefined, TParams extends StandardSchemaV1 | undefined = undefined, TResult extends DefineApiRouteResult = DefineApiRouteResult> {
+    input?: TInput;
+    query?: TQuery;
+    body?: TBody;
+    params?: TParams;
+    output?: TOutput;
+    handler: (context: DefineApiRouteContext<TInput, TQuery, TBody, TParams>) => Promise<TResult> | TResult;
+}
+/**
+ * Creates an h3-compatible event handler with Standard Schema validation.
+ *
+ * - `input` schema validates the request body (POST/PUT/PATCH) or query
+ *   params (GET). Returns 422 with `StandardSchemaV1.Issue[]` on failure.
+ * - `output` schema validates the response in development only (stripped
+ *   in production for zero overhead). Logs a warning on mismatch.
+ * - Plain return values are serialized with `json(...)`; raw `Response`
+ *   objects are returned unchanged.
+ *
+ * @example
+ * ```typescript
+ * import { defineApiRoute } from '@analogjs/router/server/actions';
+ * import * as v from 'valibot';
+ *
+ * const Input = v.object({
+ *   name: v.pipe(v.string(), v.minLength(1)),
+ *   email: v.pipe(v.string(), v.email()),
+ * });
+ * const Output = v.object({
+ *   id: v.string(),
+ *   name: v.string(),
+ * });
+ *
+ * export default defineApiRoute({
+ *   input: Input,
+ *   output: Output,
+ *   handler: async ({ data }) => {
+ *     const user = await db.users.create(data);
+ *     return user;
+ *   },
+ * });
+ * ```
+ */
+export declare function defineApiRoute<TInput extends StandardSchemaV1 | undefined = undefined, TOutput extends StandardSchemaV1 | undefined = undefined, TQuery extends StandardSchemaV1 | undefined = undefined, TBody extends StandardSchemaV1 | undefined = undefined, TParams extends StandardSchemaV1 | undefined = undefined, TResult extends DefineApiRouteResult = DefineApiRouteResult>(options: DefineApiRouteOptions<TInput, TOutput, TQuery, TBody, TParams, TResult>): (event: H3Event) => Promise<Response>;
+export {};

package/types/src/index.d.ts

@@ -2,15 +2,26 @@ export type { RouteExport } from './lib/models';
 export type { Files } from './lib/routes';
 export { routes, createRoutes } from './lib/routes';
 export { defineRouteMeta, injectActivatedRoute, injectRouter, } from './lib/define-route';
-export { RouteMeta } from './lib/models';
+export type { RouteMeta } from './lib/models';
 export { provideFileRouter, withExtraRoutes } from './lib/provide-file-router';
-export { MetaTag } from './lib/meta-tags';
-export { PageServerLoad, LoadResult, LoadDataResult } from './lib/route-types';
+export type { MetaTag } from './lib/meta-tags';
+export type { PageServerLoad, LoadResult, LoadDataResult, } from './lib/route-types';
 export { injectLoad, injectLoadData } from './lib/inject-load';
 export { getLoadResolver } from './lib/get-load-resolver';
 export { requestContextInterceptor } from './lib/request-context';
 export { injectRouteEndpointURL } from './lib/inject-route-endpoint-url';
 export { FormAction } from './lib/form-action.directive';
+export type { FormActionState } from './lib/form-action.directive';
 export { injectDebugRoutes } from './lib/debug/routes';
 export { withDebugRoutes } from './lib/debug';
 export { ServerOnly } from './lib/server.component';
+export type { AnalogJsonLdDocument } from './lib/json-ld';
+export { issuesToFieldErrors, issuesToFormErrors, issuePathToFieldName, } from './lib/validation-errors';
+export type { ValidationFieldErrors } from './lib/validation-errors';
+export type { AnalogRouteTable, AnalogRoutePath, RoutePathOptions, RoutePathArgs, RoutePathOptionsBase, RouteParamsOutput, RouteQueryOutput, RouteLinkResult, } from './lib/route-path';
+export { routePath } from './lib/route-path';
+export { injectNavigate } from './lib/inject-navigate';
+export { withTypedRouter, withRouteContext, withLoaderCaching, EXPERIMENTAL_TYPED_ROUTER, EXPERIMENTAL_ROUTE_CONTEXT, EXPERIMENTAL_LOADER_CACHE, } from './lib/experimental';
+export type { TypedRouterOptions, LoaderCacheOptions, } from './lib/experimental';
+export { injectParams, injectQuery } from './lib/inject-typed-params';
+export { injectRouteContext } from './lib/inject-route-context';

package/types/src/lib/define-route.d.ts

@@ -1,7 +1,12 @@
 import { Route as NgRoute, Router } from '@angular/router';
 import { ActivatedRoute } from '@angular/router';
+import { AnalogJsonLdDocument } from './json-ld';
+import { MetaTag } from './meta-tags';
 type RouteOmitted = 'component' | 'loadComponent' | 'loadChildren' | 'path' | 'pathMatch';
-type RestrictedRoute = Omit<NgRoute, RouteOmitted>;
+type RestrictedRoute = Omit<NgRoute, RouteOmitted> & {
+    meta?: MetaTag[];
+    jsonLd?: AnalogJsonLdDocument;
+};
 /**
  * @deprecated Use `RouteMeta` type instead.
  * For more info see: https://github.com/analogjs/analog/issues/223

package/types/src/lib/experimental.d.ts

@@ -0,0 +1,140 @@
+import { InjectionToken } from '@angular/core';
+import type { RouterFeatures } from '@angular/router';
+/**
+ * Configuration for experimental typed router features.
+ *
+ * Inspired by TanStack Router's type-safe navigation system where
+ * routes are registered globally and all navigation/hooks are typed
+ * against the route tree.
+ *
+ * @experimental
+ */
+export interface TypedRouterOptions {
+    /**
+     * When true, logs warnings in development when navigating to
+     * routes with params that don't match the generated route table.
+     *
+     * Similar to TanStack Router's strict mode where `useParams()`
+     * without a `from` constraint returns a union of all possible params.
+     *
+     * @default false
+     */
+    strictRouteParams?: boolean;
+}
+/**
+ * Configuration for experimental loader caching.
+ *
+ * Inspired by TanStack Router's built-in data caching where route
+ * loaders automatically cache results and support stale-while-revalidate.
+ *
+ * @experimental
+ */
+export interface LoaderCacheOptions {
+    /**
+     * Time in milliseconds before loader data is considered stale.
+     * While data is fresh, navigating back to the route uses cached
+     * data without re-invoking the server load function.
+     *
+     * Mirrors TanStack Router's `defaultStaleTime` option on `createRouter()`.
+     *
+     * @default 0 (always re-fetch)
+     */
+    defaultStaleTime?: number;
+    /**
+     * Time in milliseconds to retain unused loader data in cache
+     * after leaving a route. After this period the cached entry is
+     * garbage-collected.
+     *
+     * Mirrors TanStack Router's `defaultGcTime` (default 30 min).
+     *
+     * @default 300_000 (5 minutes)
+     */
+    defaultGcTime?: number;
+    /**
+     * Delay in milliseconds before showing a pending/loading indicator
+     * during route transitions. Prevents flash-of-loading-state for
+     * fast navigations.
+     *
+     * Mirrors TanStack Router's `defaultPendingMs`.
+     *
+     * @default 0 (show immediately)
+     */
+    defaultPendingMs?: number;
+}
+/** @experimental */
+export declare const EXPERIMENTAL_TYPED_ROUTER: InjectionToken<TypedRouterOptions>;
+/** @experimental */
+export declare const EXPERIMENTAL_ROUTE_CONTEXT: InjectionToken<Record<string, unknown>>;
+/** @experimental */
+export declare const EXPERIMENTAL_LOADER_CACHE: InjectionToken<LoaderCacheOptions>;
+/**
+ * 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
+ */
+export declare function withTypedRouter(options?: TypedRouterOptions): RouterFeatures;
+/**
+ * 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
+ */
+export declare function withRouteContext<T extends Record<string, unknown>>(context: T): RouterFeatures;
+/**
+ * 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
+ */
+export declare function withLoaderCaching(options?: LoaderCacheOptions): RouterFeatures;

package/types/src/lib/inject-navigate.d.ts

@@ -0,0 +1,23 @@
+import { type NavigationBehaviorOptions } from '@angular/router';
+import type { AnalogRoutePath, RoutePathArgs } from './route-path';
+type NavigateWithExtrasArgs<P extends AnalogRoutePath> = RoutePathArgs<P> extends [options?: infer Options] ? [extras: NavigationBehaviorOptions] | [options: Options | undefined, extras: NavigationBehaviorOptions] : [options: RoutePathArgs<P>[0], extras: NavigationBehaviorOptions];
+type TypedNavigate = {
+    <P extends AnalogRoutePath>(path: P, ...args: RoutePathArgs<P>): Promise<boolean>;
+    <P extends AnalogRoutePath>(path: P, ...args: NavigateWithExtrasArgs<P>): Promise<boolean>;
+};
+/**
+ * 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 });
+ * ```
+ */
+export declare function injectNavigate(): TypedNavigate;
+export {};

package/types/src/lib/inject-route-context.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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
+ */
+export declare function injectRouteContext<T extends Record<string, unknown> = Record<string, unknown>>(): T;

package/types/src/lib/inject-typed-params.d.ts

@@ -0,0 +1,63 @@
+import { Injector, Signal } from '@angular/core';
+import type { AnalogRoutePath, RouteParamsOutput, RouteQueryOutput } from './route-path';
+/**
+ * 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
+ */
+export declare function injectParams<P extends AnalogRoutePath>(_from: P, options?: {
+    injector?: Injector;
+}): Signal<RouteParamsOutput<P>>;
+/**
+ * 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
+ */
+export declare function injectQuery<P extends AnalogRoutePath>(_from: P, options?: {
+    injector?: Injector;
+}): Signal<RouteQueryOutput<P>>;

package/types/src/lib/json-ld.d.ts

@@ -0,0 +1,31 @@
+import type { Graph, Thing, WithContext } from 'schema-dts';
+export type JsonLdObject = Record<string, unknown>;
+export declare function isJsonLdObject(value: unknown): value is JsonLdObject;
+export declare function normalizeJsonLd(value: unknown): JsonLdObject[];
+export type JsonLd = JsonLdObject | JsonLdObject[];
+/**
+ * Typed JSON-LD document based on `schema-dts`.
+ *
+ * Accepts single Schema.org nodes (`WithContext<Thing>`),
+ * `@graph`-based documents (`Graph`), or arrays of nodes.
+ *
+ * This is the canonical JSON-LD type for route authoring surfaces
+ * (`routeMeta.jsonLd`, `routeJsonLd`, generated manifest).
+ *
+ * @example
+ * ```ts
+ * import type { WebPage, WithContext } from 'schema-dts';
+ *
+ * export const routeMeta = {
+ *   jsonLd: {
+ *     '@context': 'https://schema.org',
+ *     '@type': 'WebPage',
+ *     name: 'Products',
+ *   } satisfies WithContext<WebPage>,
+ * };
+ * ```
+ */
+export type AnalogJsonLdDocument = WithContext<Thing> | Graph | Array<WithContext<Thing>>;
+export declare const ROUTE_JSON_LD_KEY: unique symbol;
+export declare function updateJsonLdOnRouteChange(): void;
+export declare function serializeJsonLd(entry: JsonLdObject): string | null;

package/types/src/lib/models.d.ts

@@ -1,6 +1,7 @@
 import { Type } from '@angular/core';
 import { CanActivateChildFn, CanActivateFn, CanDeactivateFn, CanMatchFn, DeprecatedGuard, ResolveFn, Route } from '@angular/router';
 import { defineRouteMeta } from './define-route';
+import { AnalogJsonLdDocument } from './json-ld';
 import { MetaTag } from './meta-tags';
 type OmittedRouteProps = 'path' | 'matcher' | 'component' | 'loadComponent' | 'children' | 'loadChildren' | 'canLoad' | 'outlet';
 export type RouteConfig = Omit<Route, OmittedRouteProps>;
@@ -14,6 +15,7 @@ export interface DefaultRouteMeta extends Omit<Route, OmittedRouteProps | keyof
     };
     title?: string | ResolveFn<string>;
     meta?: MetaTag[] | ResolveFn<MetaTag[]>;
+    jsonLd?: AnalogJsonLdDocument | ResolveFn<AnalogJsonLdDocument | undefined>;
 }
 export interface RedirectRouteMeta {
     redirectTo: string;
@@ -25,5 +27,6 @@ export type RouteMeta = (DefaultRouteMeta & {
 export type RouteExport = {
     default: Type<unknown>;
     routeMeta?: RouteMeta | ReturnType<typeof defineRouteMeta>;
+    routeJsonLd?: AnalogJsonLdDocument | ResolveFn<AnalogJsonLdDocument | undefined>;
 };
 export {};

package/types/src/lib/route-path.d.ts

@@ -0,0 +1,124 @@
+/**
+ * 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.
+ */
+/**
+ * Base interface for the typed route table.
+ *
+ * This interface is augmented by generated code in `src/routeTree.gen.ts`.
+ * When no routes are generated, it is empty and `AnalogRoutePath` falls
+ * back to `string`.
+ */
+export interface AnalogRouteTable {
+}
+/**
+ * Union of all valid route paths.
+ *
+ * When routes are generated, this is a string literal union.
+ * When no routes are generated, this falls back to `string`.
+ */
+export type AnalogRoutePath = keyof AnalogRouteTable extends never ? string : Extract<keyof AnalogRouteTable, string>;
+/**
+ * Options for building a route URL.
+ */
+export interface RoutePathOptionsBase {
+    params?: Record<string, string | string[] | undefined>;
+    query?: Record<string, string | string[] | undefined>;
+    hash?: string;
+}
+/**
+ * Extracts the validated output type for route params.
+ *
+ * When a route exports `routeParamsSchema`, this resolves to the schema's
+ * output type (e.g., `{ id: number }` after coercion).
+ * When no schema exists, this is the same as the navigation param type.
+ */
+export type RouteParamsOutput<P extends string> = P extends keyof AnalogRouteTable ? AnalogRouteTable[P] extends {
+    paramsOutput: infer O;
+} ? O : AnalogRouteTable[P] extends {
+    params: infer Params;
+} ? Params : Record<string, unknown> : Record<string, unknown>;
+/**
+ * Extracts the validated output type for route query params.
+ */
+export type RouteQueryOutput<P extends string> = P extends keyof AnalogRouteTable ? AnalogRouteTable[P] extends {
+    queryOutput: infer O;
+} ? O : Record<string, string | string[] | undefined> : Record<string, string | string[] | undefined>;
+type RequiredRouteParamKeys<Params> = Params extends Record<string, never> ? never : {
+    [K in keyof Params]-?: Record<string, never> extends Pick<Params, K> ? never : K;
+}[keyof Params];
+type HasRequiredRouteParams<Params> = [RequiredRouteParamKeys<Params>] extends [
+    never
+] ? false : true;
+/**
+ * Typed options that infer params from the route table when available.
+ */
+export type RoutePathOptions<P extends string = string> = P extends keyof AnalogRouteTable ? AnalogRouteTable[P] extends {
+    params: infer Params;
+} ? Params extends Record<string, never> ? {
+    query?: RouteQueryOutput<P>;
+    hash?: string;
+} : HasRequiredRouteParams<Params> extends true ? {
+    params: Params;
+    query?: RouteQueryOutput<P>;
+    hash?: string;
+} : {
+    params?: Params;
+    query?: RouteQueryOutput<P>;
+    hash?: string;
+} : RoutePathOptionsBase : RoutePathOptionsBase;
+/**
+ * Conditional args: require options when the route has params.
+ */
+export type RoutePathArgs<P extends string = string> = P extends keyof AnalogRouteTable ? AnalogRouteTable[P] extends {
+    params: infer Params;
+} ? Params extends Record<string, never> ? [options?: RoutePathOptions<P>] : HasRequiredRouteParams<Params> extends true ? [options: RoutePathOptions<P>] : [options?: RoutePathOptions<P>] : [options?: RoutePathOptionsBase] : [options?: RoutePathOptionsBase];
+/**
+ * Result of `routePath()` — contains properties that map directly
+ * to Angular's `[routerLink]`, `[queryParams]`, and `[fragment]` inputs.
+ */
+export interface RouteLinkResult {
+    path: string;
+    queryParams: Record<string, string | string[]> | null;
+    fragment: string | undefined;
+}
+/**
+ * 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">
+ * ```
+ */
+export declare function routePath<P extends AnalogRoutePath>(path: P, ...args: RoutePathArgs<P>): RouteLinkResult;
+/**
+ * Internal: builds a `RouteLinkResult` from path and options.
+ * Exported for direct use in tests (avoids generic constraints).
+ */
+export declare function buildRouteLink(path: string, options?: RoutePathOptionsBase): RouteLinkResult;
+/**
+ * Internal URL builder. Separated from `routePath` so it can be
+ * used without generic constraints (e.g., in `injectNavigate`).
+ */
+export declare function buildUrl(path: string, options?: RoutePathOptionsBase): string;
+export {};

package/types/src/lib/validation-errors.d.ts

@@ -0,0 +1,7 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+export type ValidationFieldErrors = Record<string, string[]>;
+export declare function issuePathToFieldName(path: ReadonlyArray<string | number | symbol | {
+    key: string | number | symbol;
+}>): string;
+export declare function issuesToFieldErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>): ValidationFieldErrors;
+export declare function issuesToFormErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>): string[];