@analogjs/router 3.0.0-alpha.3 → 3.0.0-alpha.30

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

@@ -0,0 +1,68 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { H3Event } from 'nitro/h3';
+export type DefineServerRouteResult = Response | unknown;
+export interface ServerRouteHandler<TQuery = unknown, TBody = unknown, TResult = unknown> {
+    (event: H3Event): Promise<Response>;
+    readonly _types: {
+        readonly query: TQuery;
+        readonly body: TBody;
+        readonly result: TResult;
+    };
+}
+export type InferRouteQuery<T> = T extends ServerRouteHandler<infer Q, any, any> ? Q : never;
+export type InferRouteBody<T> = T extends ServerRouteHandler<any, infer B, any> ? B : never;
+export type InferRouteResult<T> = T extends ServerRouteHandler<any, any, infer R> ? Exclude<R, Response> : never;
+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 DefineServerRouteContext<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 DefineServerRouteOptions<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 DefineServerRouteResult = DefineServerRouteResult> {
+    input?: TInput;
+    query?: TQuery;
+    body?: TBody;
+    params?: TParams;
+    output?: TOutput;
+    handler: (context: DefineServerRouteContext<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 { defineServerRoute } 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 defineServerRoute({
+ *   input: Input,
+ *   output: Output,
+ *   handler: async ({ data }) => {
+ *     const user = await db.users.create(data);
+ *     return user;
+ *   },
+ * });
+ * ```
+ */
+export declare function defineServerRoute<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 DefineServerRouteResult = DefineServerRouteResult>(options: DefineServerRouteOptions<TInput, TOutput, TQuery, TBody, TParams, TResult>): ServerRouteHandler<InferSchema<TQuery, undefined>, InferSchema<TBody, undefined>, TResult>;
+export {};

package/types/server/actions/src/index.d.ts

@@ -1 +1,9 @@
-export { PageServerAction, json, redirect, fail } from './actions';
+export type { PageServerAction } from './actions';
+export { json, redirect, fail } from './actions';
+export { defineAction } from './define-action';
+export type { DefineActionContext, DefineActionOptions } from './define-action';
+export { defineServerRoute } from './define-server-route';
+export type { DefineServerRouteContext, DefineServerRouteOptions, DefineServerRouteResult, ServerRouteHandler, InferRouteQuery, InferRouteBody, InferRouteResult, } from './define-server-route';
+export { definePageLoad } from './define-page-load';
+export type { PageLoadContext, DefinePageLoadOptions, } from './define-page-load';
+export { validateWithSchema } from './validate';

package/types/server/actions/src/parse-request-data.d.ts

@@ -0,0 +1,9 @@
+type RequestEntryValue = string | File;
+type ParsedRequestValue = RequestEntryValue | RequestEntryValue[];
+export declare function parseSearchParams(searchParams: URLSearchParams): Record<string, ParsedRequestValue>;
+export declare function parseFormData(formData: FormData): Record<string, ParsedRequestValue>;
+export declare function parseRequestData(event: {
+    method: string;
+    headers: Headers;
+}): Promise<unknown>;
+export {};

package/types/server/actions/src/validate.d.ts

@@ -0,0 +1,8 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+/**
+ * Validates unknown input against a Standard Schema.
+ *
+ * Handles both sync and async `validate` implementations — the Standard
+ * Schema spec allows either return shape.
+ */
+export declare function validateWithSchema<T extends StandardSchemaV1>(schema: T, data: unknown): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<T>>>;

package/types/server/src/provide-server-context.d.ts

@@ -1,5 +1,5 @@
 import { StaticProvider } from '@angular/core';
-import { ServerInternalFetch, ServerRequest, ServerResponse } from '@analogjs/router/tokens';
+import { ServerInternalFetch, ServerRequest, ServerResponse } from '../../tokens/src/index.js';
 export declare function provideServerContext({ req, res, fetch, }: {
     req: ServerRequest;
     res: ServerResponse;

package/types/server/src/render.d.ts

@@ -1,5 +1,5 @@
 import { ApplicationConfig, Provider, Type } from '@angular/core';
-import type { ServerContext } from '@analogjs/router/tokens';
+import type { ServerContext } from '../../tokens/src/index.js';
 /**
  * Returns a function that accepts the navigation URL,
  * the root HTML, and server context.

package/types/server/src/server-component-render.d.ts

@@ -1,4 +1,4 @@
 import { ApplicationConfig } from '@angular/core';
-import { ServerContext } from '@analogjs/router/tokens';
+import type { ServerContext } from '../../tokens/src/index.js';
 export declare function serverComponentRequest(serverContext: ServerContext): string | undefined;
 export declare function renderServerComponent(url: string, serverContext: ServerContext, config?: ApplicationConfig): Promise<Response>;

package/types/src/index.d.ts

@@ -1,16 +1,27 @@
 export type { RouteExport } from './lib/models';
-export type { Files } from './lib/routes';
+export type { Files } from './lib/route-files';
 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 } from './lib/route-types';
-export { injectLoad } from './lib/inject-load';
+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/cache-key.d.ts

@@ -1,3 +1,3 @@
 import { HttpRequest } from '@angular/common/http';
 import { StateKey } from '@angular/core';
-export declare function makeCacheKey(request: HttpRequest<any>, mappedRequestUrl: string): StateKey<unknown>;
+export declare function makeCacheKey(request: HttpRequest<unknown>, mappedRequestUrl: string): StateKey<unknown>;

package/types/src/lib/cookie-interceptor.d.ts

@@ -1,4 +1,4 @@
 import { HttpHandlerFn, HttpRequest, HttpEvent } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { ServerRequest } from '@analogjs/router/tokens';
+import { type ServerRequest } from '../../tokens/src/index.js';
 export declare function cookieInterceptor(req: HttpRequest<unknown>, next: HttpHandlerFn, location?: object, serverRequest?: ServerRequest | null): Observable<HttpEvent<unknown>>;

package/types/src/lib/debug/debug.page.d.ts

@@ -6,12 +6,14 @@ type CollectedRoute = {
     filename: string;
     file: string;
     isLayout: boolean;
+    source: 'page' | 'content';
 };
 export default class DebugRoutesComponent implements OnInit {
     collectedRoutes: CollectedRoute[];
-    debugRoutes: (import('@angular/router').Route & DebugRoute)[];
+    private debugRoutes;
+    private extraSources;
     ngOnInit(): void;
-    traverseRoutes(routes: DebugRoute[], parent?: string): void;
+    traverseRoutes(routes: DebugRoute[], parent?: string, source?: 'page' | 'content'): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DebugRoutesComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DebugRoutesComponent, "analogjs-debug-routes-page", never, {}, {}, never, never, true, never>;
 }

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/endpoints.d.ts

@@ -2,4 +2,4 @@ export declare const ANALOG_META_KEY: unique symbol;
 /**
  * This variable reference is replaced with a glob of all route endpoints.
  */
-export declare const ANALOG_PAGE_ENDPOINTS: any;
+export declare const ANALOG_PAGE_ENDPOINTS: Record<string, () => Promise<unknown>>;

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/form-action.directive.d.ts

@@ -1,17 +1,24 @@
-import { InputSignal, OutputEmitterRef } from '@angular/core';
+import { type InputSignal, type OutputEmitterRef, type WritableSignal } from '@angular/core';
 import * as i0 from "@angular/core";
+export type FormActionState = 'submitting' | 'error' | 'redirect' | 'success' | 'navigate';
 export declare class FormAction {
     action: InputSignal<string>;
     onSuccess: OutputEmitterRef<unknown>;
     onError: OutputEmitterRef<unknown>;
-    state: OutputEmitterRef<'submitting' | 'error' | 'redirect' | 'success' | 'navigate'>;
+    state: OutputEmitterRef<FormActionState>;
     private router;
     private route;
-    private path;
-    submitted($event: any): void;
+    protected currentState: WritableSignal<FormActionState | 'idle'>;
+    /** Cached during construction (injection context) so inject() works. */
+    private _endpointUrl;
+    submitted($event: SubmitEvent): void;
     private _handleGet;
     private _handlePost;
-    private _getPath;
+    private _getExplicitAction;
+    private _getGetPath;
+    private _getPostPath;
+    private _emitState;
+    private _navigateTo;
     private _isJSON;
     static ɵfac: i0.ɵɵFactoryDeclaration<FormAction, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FormAction, "form[action],form[method]", never, { "action": { "alias": "action"; "required": false; "isSignal": true; }; }, { "onSuccess": "onSuccess"; "onError": "onError"; "state": "state"; }, never, never, true, never>;

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

@@ -1,6 +1,9 @@
 import { Injector } from '@angular/core';
 import { Observable } from 'rxjs';
-import { PageServerLoad } from './route-types';
-export declare function injectLoad<T extends (pageServerLoad: PageServerLoad) => Promise<any>>(options?: {
+import { LoadDataResult, PageServerLoad } from './route-types';
+export declare function injectLoad<T extends (pageServerLoad: PageServerLoad) => Promise<unknown>>(options?: {
     injector?: Injector;
 }): Observable<Awaited<ReturnType<T>>>;
+export declare function injectLoadData<T extends (pageServerLoad: PageServerLoad) => Promise<unknown>>(options?: {
+    injector?: Injector;
+}): Observable<LoadDataResult<T>>;

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,32 @@
+import { Router } from '@angular/router';
+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 | WithContext<Thing>[];
+export declare const ROUTE_JSON_LD_KEY: unique symbol;
+export declare function updateJsonLdOnRouteChange(router?: Router, document?: Document | null): void;
+export declare function serializeJsonLd(entry: JsonLdObject): string | null;

package/types/src/lib/meta-tags.d.ts

@@ -1,3 +1,5 @@
+import { Meta } from '@angular/platform-browser';
+import { Router } from '@angular/router';
 export declare const ROUTE_META_TAGS_KEY: unique symbol;
 declare const CHARSET_KEY = "charset";
 declare const HTTP_EQUIV_KEY = "httpEquiv";
@@ -29,5 +31,5 @@ type MetaTagKey = typeof CHARSET_KEY | typeof HTTP_EQUIV_KEY | typeof NAME_KEY |
 type ExcludeRestMetaTagKeys<Key extends MetaTagKey> = {
     [K in Exclude<MetaTagKey, Key>]?: never;
 };
-export declare function updateMetaTagsOnRouteChange(): void;
+export declare function updateMetaTagsOnRouteChange(router?: Router, metaService?: Meta): void;
 export {};

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/provide-file-router-base.d.ts

@@ -0,0 +1,4 @@
+import { EnvironmentProviders } from '@angular/core';
+import { RouterFeatures, Routes } from '@angular/router';
+export declare function provideFileRouterWithRoutes(...features: RouterFeatures[]): EnvironmentProviders;
+export declare function withExtraRoutes(routes: Routes): RouterFeatures;

package/types/src/lib/provide-file-router.d.ts

@@ -1,5 +1,5 @@
 import { EnvironmentProviders } from '@angular/core';
-import { RouterFeatures, Routes } from '@angular/router';
+import { RouterFeatures } from '@angular/router';
 /**
  * Sets up providers for the Angular router, and registers
  * file-based routes. Additional features can be provided
@@ -9,10 +9,4 @@ import { RouterFeatures, Routes } from '@angular/router';
  * @returns Providers and features to configure the router with routes
  */
 export declare function provideFileRouter(...features: RouterFeatures[]): EnvironmentProviders;
-/**
- * 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.
- */
-export declare function withExtraRoutes(routes: Routes): RouterFeatures;
+export { withExtraRoutes } from './provide-file-router-base';

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

@@ -0,0 +1,5 @@
+import type { Route } from '@angular/router';
+import type { RouteExport } from './models';
+export type RouteModuleFactory = () => Promise<RouteExport>;
+export type RouteModuleResolver<TFile> = (filename: string, fileLoader: () => Promise<TFile>) => RouteModuleFactory;
+export declare function createRoutes<TFile>(files: Record<string, () => Promise<TFile>>, resolveModule: RouteModuleResolver<TFile>, debug?: boolean): Route[];

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

@@ -0,0 +1,18 @@
+import { InjectionToken } from '@angular/core';
+import type { RouteExport } from './models';
+export type Files = Record<string, () => Promise<RouteExport>>;
+/**
+ * This variable reference is replaced with a glob of all page routes.
+ */
+export declare const ANALOG_ROUTE_FILES: {};
+export interface ExtraRouteFileSource {
+    files: Record<string, () => Promise<unknown>>;
+    resolveModule: (filename: string, fileLoader: () => Promise<unknown>) => () => Promise<RouteExport>;
+}
+export declare const ANALOG_EXTRA_ROUTE_FILE_SOURCES: InjectionToken<ExtraRouteFileSource[]>;
+/**
+ * Replaced at build time by the Vite router plugin with the number of
+ * discovered content route files. Used in dev mode to warn when content
+ * files exist but `withContentRoutes()` is not configured.
+ */
+export declare const ANALOG_CONTENT_FILE_COUNT = 0;