@analogjs/router 3.0.0-alpha.7 → 3.0.0-alpha.70

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;
@@ -9,3 +9,17 @@ export declare function getBaseUrl(req: ServerRequest): string;
 export declare function getRequestProtocol(req: ServerRequest, opts?: {
     xForwardedProto?: boolean;
 }): string;
+/**
+ * Detects the locale from the request URL path prefix or Accept-Language header.
+ * URL prefix takes priority (e.g. /fr/about -> 'fr').
+ */
+export declare function detectLocale(req: ServerRequest): string | undefined;
+/**
+ * Extracts a locale from the first URL path segment if it matches
+ * a BCP 47-like pattern (e.g. 'en', 'en-US', 'zh-Hans-CN').
+ */
+export declare function extractLocaleFromUrl(url: string): string | undefined;
+/**
+ * Parses the Accept-Language header and returns the most preferred language.
+ */
+export declare function parseAcceptLanguage(header: string | undefined): string | undefined;

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

@@ -0,0 +1,40 @@
+/**
+ * Progressive streaming SSR renderer — EXPERIMENTAL.
+ *
+ * Returns a `ReadableStream<Uint8Array>` that flushes bytes DURING the render,
+ * not after it:
+ *   1. the document head + a client reconcile runtime are flushed immediately,
+ *      before the app has finished rendering, so the browser starts fetching
+ *      assets right away;
+ *   2. each `@defer (hydrate …)` block's content is flushed the moment it
+ *      resolves on the server — out of document order — while later blocks are
+ *      still pending (proven: a slow block does not hold back an early one);
+ *   3. once the app is stable, the authoritative, fully hydration-annotated
+ *      document is flushed as the tail. This is byte-identical to a buffered
+ *      `renderApplication`, and is what Angular's incremental hydration runs
+ *      against on the client.
+ *
+ * Unlike a buffered renderer, this drives the platform directly
+ * (`platformServer` + `bootstrapApplication` + `ɵrenderInternal`) so it can
+ * interleave flushes with rendering. Angular's hydration annotation is
+ * whole-document (the root's `ngh` index references every `@defer` container),
+ * so the authoritative hydration payload is necessarily the tail: RENDERING
+ * streams progressively, and hydration begins once the tail arrives.
+ *
+ * Depends on an upstream Angular per-block resolution hook exposed on two
+ * globals (see {@link SsrStreamingGlobals}). When the primitive is absent,
+ * `renderStream` degrades to a single buffered chunk so behaviour matches the
+ * classic `render()` path, which is unchanged and remains the default.
+ */
+import { ApplicationConfig, Provider, Type } from '@angular/core';
+import type { ServerContext } from '@analogjs/router/tokens';
+/**
+ * Returns a function that renders a URL to a `ReadableStream<Uint8Array>`.
+ *
+ * Usage in main.server.ts:
+ * ```ts
+ * import { renderStream } from '@analogjs/router/server';
+ * export default renderStream(App, config);
+ * ```
+ */
+export declare function renderStream(rootComponent: Type<unknown>, config: ApplicationConfig, platformProviders?: Provider[]): (url: string, document: string, serverContext: ServerContext) => Promise<ReadableStream<Uint8Array>>;

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.
@@ -7,6 +7,6 @@ import type { ServerContext } from '@analogjs/router/tokens';
  * @param rootComponent
  * @param config
  * @param platformProviders
- * @returns Promise<string | Reponse>
+ * @returns Promise<string>
  */
-export declare function render(rootComponent: Type<unknown>, config: ApplicationConfig, platformProviders?: Provider[]): (url: string, document: string, serverContext: ServerContext) => Promise<string | Response>;
+export declare function render(rootComponent: Type<unknown>, config: ApplicationConfig, platformProviders?: Provider[]): (url: string, document: string, serverContext: ServerContext) => Promise<string>;

package/types/server/src/server-fn/app-injector.d.ts

@@ -0,0 +1,30 @@
+import { type ApplicationConfig, Injector, type StaticProvider } from '@angular/core';
+/**
+ * Builds the parent injector the server-function dispatch endpoint runs handlers
+ * against, over HTTP.
+ *
+ * A plain `Injector.create({ providers })` resolves explicitly-listed providers
+ * but not tree-shakeable `providedIn: 'root'` services — those attach to a
+ * *bootstrapped* application's root injector, which `Injector.create` is not.
+ * So the in-process SSR leg (whose parent is the app's own bootstrapped
+ * injector) resolved `root` services while the HTTP leg did not — the same
+ * handler could work while rendering and fail when called from the browser.
+ *
+ * Bootstrapping a real application on the server platform closes that gap: the
+ * returned `appRef.injector` is a root environment injector, so both listed
+ * providers and `providedIn: 'root'` services resolve, matching SSR.
+ *
+ * The generated endpoint passes the app's own server `ApplicationConfig` (the
+ * one `main.server.ts` renders with), so a handler sees exactly the DI the app
+ * configured — services, tokens, and interceptors alike — with no second
+ * provider list to keep in sync. No root component is bootstrapped
+ * (`createApplication`, not `bootstrapApplication`), so nothing renders, no
+ * change detection runs, and the router registers but never navigates. It is a
+ * DI container with the app's providers, built once and reused for the process,
+ * with only `REQUEST`/`RESPONSE` rebuilt per call in the child.
+ *
+ * A bare provider array is also accepted (direct callers and tests without an
+ * app config); it is wrapped with `provideServerRendering` so the server tokens
+ * resolve the same way.
+ */
+export declare function createServerFnAppInjector(configOrProviders?: ApplicationConfig | StaticProvider[]): Promise<Injector>;

package/types/server/src/server-fn/dispatch.d.ts

@@ -0,0 +1,56 @@
+import { Injector, type StaticProvider } from '@angular/core';
+import type { H3Event } from 'nitro/h3';
+export interface DispatchResult {
+    status: number;
+    body: unknown;
+    /**
+     * Headers from a returned `Response` (`fail`/`redirect`): Location, … The
+     * value is an array when the header legitimately repeats, which is why
+     * `Set-Cookie` is read separately below — collapsing several cookies into one
+     * comma-joined value corrupts them.
+     */
+    headers?: Record<string, string | string[]>;
+}
+export interface DispatchServerFnOptions {
+    /**
+     * The app's environment injector. The per-request injector is created as its
+     * child, so handlers resolve app services (and `providedIn: 'root'` services,
+     * when this is the app's bootstrapped injector) and registered interceptors
+     * without re-listing them per request.
+     */
+    parent?: Injector;
+    /** Extra per-request providers, for direct callers without an app injector. */
+    providers?: StaticProvider[];
+    /** Request HTTP method; enforced against the function's configured method. */
+    method?: string;
+    /**
+     * Origins permitted beyond same-origin, merged with any registered through DI
+     * (`provideServerFns(withAllowedOrigins([...]))`). The transport is
+     * same-origin by default (cross-origin browser calls are rejected with 403);
+     * `'*'` disables the check entirely. Only consulted for HTTP-transport calls
+     * (those that pass `method`).
+     */
+    allowedOrigins?: string[];
+}
+/**
+ * Server-side dispatch for a server function call.
+ *
+ * 1. reject cross-origin browser calls (403), unless allow-listed — HTTP
+ *    transport only (in-process callers omit `method` and are exempt)
+ * 2. look up the function by id
+ * 3. enforce the configured HTTP method (405 on mismatch)
+ * 4. require a JSON body on input-bearing calls (415 otherwise)
+ * 5. validate `input` against the Standard-Schema (4xx on failure)
+ * 6. build a per-request injector (REQUEST/RESPONSE + app providers)
+ * 7. run the interceptor chain, then the handler, re-entering
+ *    `runInInjectionContext` at every hop so `inject()` works even after an
+ *    interceptor `await`s before calling `next`
+ * 8. a `Response` returned by an interceptor/handler (`fail`/`redirect`)
+ *    short-circuits with its status AND headers
+ *
+ * `options.method` is the request's HTTP method; when provided it is enforced
+ * against the function's configured method AND it turns on the same-origin
+ * guard. Transports (the generated Nitro handler) always pass it; trusted
+ * in-process callers may omit it, which also exempts them from the origin guard.
+ */
+export declare function dispatchServerFn(id: string, rawInput: unknown, event: Pick<H3Event, 'node'>, options?: DispatchServerFnOptions): Promise<DispatchResult>;

package/types/server/src/server-fn/event-handler.d.ts

@@ -0,0 +1,22 @@
+import type { Injector } from '@angular/core';
+import { type EventHandler, type H3Event } from 'nitro/h3';
+/**
+ * The h3 request/response layer for the server-function dispatch route.
+ *
+ * `createServerFnAppInjector` bootstraps the parent injector once; this wraps
+ * that in the `/_analog/fn/:id` handler the Nitro build registers. Kept as a
+ * runtime function (rather than inlined into the generated module) so the
+ * transport behaviour — body decoding, the malformed-body contract, and header
+ * propagation — is unit-tested directly instead of by matching generated source.
+ *
+ * `appInjector` may be a promise: the generated module bootstraps the app at
+ * import time and passes the pending injector, which is awaited on first request
+ * and resolved instantly thereafter.
+ */
+export declare function createServerFnEventHandler(appInjector: Injector | Promise<Injector>): EventHandler;
+/**
+ * Decode a server-function request, dispatch it, and write the result to the
+ * h3 response. Same-origin, method, content-type, validation, and interceptors
+ * are enforced inside `dispatchServerFn`; this owns only the h3 I/O around it.
+ */
+export declare function handleServerFnRequest(event: H3Event, appInjector: Injector | Promise<Injector>): Promise<unknown>;

package/types/server/src/server-fn/interceptors.d.ts

@@ -0,0 +1,30 @@
+import { InjectionToken, type Provider } from '@angular/core';
+import type { ServerFnContext } from '@analogjs/router';
+/** Context threaded through the interceptor chain and handed to the handler. */
+export interface ServerFnInterceptorContext {
+    readonly input: unknown;
+    readonly context: ServerFnContext;
+    /** Return a new context with additional typed fields merged in. */
+    with(patch: Partial<ServerFnContext> & Record<string, unknown>): ServerFnInterceptorContext;
+}
+export type ServerFnNext = (ctx: ServerFnInterceptorContext) => Promise<unknown>;
+/** Functional interceptor, modeled on `HttpInterceptorFn`. */
+export type ServerFnInterceptorFn = (ctx: ServerFnInterceptorContext, next: ServerFnNext) => Promise<unknown> | unknown;
+export declare const SERVER_FN_INTERCEPTORS: InjectionToken<ServerFnInterceptorFn[]>;
+export interface ServerFnsFeature {
+    providers: Provider[];
+}
+/** `withServerFnInterceptors([...])` — registers the chain (DI, ordered). */
+export declare function withServerFnInterceptors(interceptors: ServerFnInterceptorFn[]): ServerFnsFeature;
+/** `provideServerFns(withServerFnInterceptors(...))` — mirrors provideHttpClient. */
+export declare function provideServerFns(...features: ServerFnsFeature[]): Provider[];
+/**
+ * Run the interceptor chain, then the handler, threading the context.
+ *
+ * `runInCtx` re-establishes the DI injection context around each interceptor
+ * and the handler individually. This is what keeps `inject()` working in a
+ * handler even when an upstream interceptor `await`s before calling `next`
+ * (which would otherwise resume outside Angular's synchronous injection
+ * context). It defaults to a pass-through for non-DI callers/tests.
+ */
+export declare function runInterceptors(interceptors: ServerFnInterceptorFn[], input: unknown, handler: (input: unknown, context: ServerFnContext) => Promise<unknown> | unknown, runInCtx?: <T>(fn: () => T) => T): Promise<unknown>;

package/types/server/src/server-fn/node-context.d.ts

@@ -0,0 +1,14 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { H3Event } from 'nitro/h3';
+type NodeContext = NonNullable<H3Event['node']>;
+type NodeRuntimeContext = NodeContext & {
+    req: IncomingMessage;
+    res: ServerResponse;
+};
+/**
+ * Dispatch provides the Node request and response through `REQUEST` and
+ * `RESPONSE`, which are typed as Node primitives, so server functions only run
+ * on a Node runtime. h3 leaves `node` undefined on other runtimes.
+ */
+export declare function assertNodeContext(event: Pick<H3Event, 'node'>): NodeRuntimeContext;
+export {};

package/types/server/src/server-fn/registry.d.ts

@@ -0,0 +1,7 @@
+import type { ServerFnDef } from '@analogjs/router';
+/**
+ * Server-side registry of server functions, keyed by id. A `.server.ts` module
+ * populates it as a side effect of `serverFn(...)` running at import time; the
+ * Nitro dispatch route imports those modules to fill it, then looks up by id.
+ */
+export declare const serverFnRegistry: Map<string, ServerFnDef>;

package/types/server/src/server-fn/same-origin.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Same-origin enforcement for the server-function HTTP transport.
+ *
+ * Server functions are same-origin RPC: a client proxy only ever calls the
+ * relative `/_analog/fn/:id` URL of its own app. A cross-origin page must not be
+ * able to invoke them against a logged-in user (a CSRF-shaped attack), so the
+ * transport rejects browser requests whose origin is not the app's own — out of
+ * the box, with no per-app configuration.
+ *
+ * The signals used (`Sec-Fetch-Site`, `Origin`) are added by the browser and
+ * cannot be forged by a cross-origin page's `fetch`. Non-browser callers (curl,
+ * server-to-server, SSR in-process) send neither, so they are unaffected: the
+ * guard blocks the cross-origin browser attack it is meant to, and nothing else.
+ */
+import { InjectionToken } from '@angular/core';
+import type { ServerFnsFeature } from './interceptors';
+/** Node/h3 header bag shape (`IncomingHttpHeaders`). */
+export type HeaderBag = Record<string, string | string[] | undefined>;
+/**
+ * Origins permitted beyond the app's own, registered through DI:
+ * `provideServerFns(withAllowedOrigins([...]))`. Empty by default — the
+ * transport is same-origin unless an app opts out explicitly.
+ */
+export declare const SERVER_FN_ALLOWED_ORIGINS: InjectionToken<string[]>;
+/**
+ * `withAllowedOrigins([...])` — permit cross-origin browser calls from the
+ * listed origins, or pass `'*'` to disable the same-origin guard entirely.
+ * Server functions are frequently cookie-authenticated, so this is an explicit
+ * opt-out of CSRF protection: allow-list the exact origins you control.
+ */
+export declare function withAllowedOrigins(origins: string[]): ServerFnsFeature;
+/**
+ * Whether an HTTP request to a server function may proceed.
+ *
+ * Allowed when the request is same-origin, carries no browser-origin signal at
+ * all (a non-browser client, or a same-origin GET that omits `Origin`), or its
+ * `Origin` is listed in `allowedOrigins`. Passing `'*'` in `allowedOrigins`
+ * disables the check — the explicit opt-in to cross-origin access.
+ *
+ * `Sec-Fetch-Site` is the authoritative signal when present: `same-origin` and
+ * `none` (a direct navigation, not a cross-site fetch) pass; `same-site` and
+ * `cross-site` require an explicit `allowedOrigins` entry. When the header is
+ * absent (older browsers, some proxies) the `Origin` host is compared to the
+ * request host as a fallback.
+ */
+export declare function isServerFnOriginAllowed(headers: HeaderBag, allowedOrigins?: readonly string[]): boolean;

package/types/server/src/server-fn/server-fn.d.ts

@@ -0,0 +1,21 @@
+import type { ServerFn, ServerFnConfig, ServerFnHandler, StandardSchemaV1 } from '@analogjs/router';
+/**
+ * Define a server function. Authored in a `*.server.ts` module.
+ *
+ * Three call shapes, chosen for ergonomics — they all normalize to the same
+ * `(config, handler)` form and the build transform derives the route id for each:
+ *
+ * ```ts
+ * serverFn(() => inject(Svc).list());                  // input-less GET
+ * serverFn(schema, (input) => …);                      // schema ⇒ POST + input
+ * serverFn({ method: 'POST' }, () => …);               // explicit config
+ * ```
+ *
+ * On the server the function self-registers and its handler runs via
+ * `dispatchServerFn`. On the client the build transform replaces the body with a
+ * proxy that calls `/_analog/fn/<id>`; the reference still carries
+ * `id`/`url`/`method` so `injectServerFn`/`ServerFnClient` can dispatch.
+ */
+export declare function serverFn<Out>(handler: ServerFnHandler<void, Out>): ServerFn<void, Out>;
+export declare function serverFn<In, Out>(input: StandardSchemaV1<In>, handler: ServerFnHandler<In, Out>): ServerFn<In, Out>;
+export declare function serverFn<In, Out>(config: ServerFnConfig<In>, handler: ServerFnHandler<In, Out>): ServerFn<In, Out>;

package/types/server/src/server-fn/ssr-dispatcher.d.ts

@@ -0,0 +1,17 @@
+import type { ServerRequest, ServerResponse } from '@analogjs/router/tokens';
+import type { ServerFnDispatcher } from '@analogjs/router';
+/**
+ * The in-process transport used during SSR. `ServerFnClient` picks this up from
+ * DI and calls the handler directly instead of issuing an HTTP request back
+ * into the app — the render and the handler already share a process and a
+ * request, so the round-trip only adds latency (and would need an absolute URL).
+ *
+ * `method` is deliberately not passed to `dispatchServerFn`: this is a trusted
+ * in-process caller, so the HTTP-transport-only checks (same-origin, method
+ * enforcement, content type) do not apply. Validation and the interceptor chain
+ * still run, so an SSR call behaves like a browser call in every other respect.
+ *
+ * A non-2xx result is thrown as an `HttpErrorResponse` so the failure surfaces
+ * on `resource.error()` exactly as it does in the browser.
+ */
+export declare function createServerFnDispatcher(req: ServerRequest, res: ServerResponse): ServerFnDispatcher;

package/types/server/src/utils/reset-component-def-tviews.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Nulls `def.tView` on every component definition that Angular has
+ * compiled in this process. Angular caches the result of `consts()` on
+ * `def.tView` — that factory is where `$localize` tagged templates are
+ * evaluated — so without this reset the first rendered locale would be
+ * frozen into the cache for the process lifetime.
+ *
+ * The set on `globalThis.__ngComponentDefs` is populated by a Vite
+ * transform in `@analogjs/platform` that patches `@angular/core`'s
+ * `getComponentId()` to mirror every compiled component definition to
+ * a global Set, bypassing the `ngServerMode` guard that normally
+ * prevents registration on the server.
+ */
+export declare function resetComponentDefTViews(): void;

package/types/server/src/utils/stream-html.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Pure string helpers for slicing a fully rendered SSR document into the parts
+ * the streaming renderer flushes: the shell up to `<body>`, the authoritative
+ * `<body>` inner HTML for the tail, and the authoritative `<head>` inner HTML
+ * for the finalize-time head reconcile. Extracted from `render-stream` so they
+ * can be unit tested without driving the platform.
+ */
+/** Byte offset just after the opening `<body>` tag, or 0 if none. */
+export declare function afterBodyOpen(html: string): number;
+/** Inner HTML of `<body>` from a fully rendered document string. */
+export declare function bodyInner(html: string): string;
+/** Inner HTML of `<head>` from a fully rendered document string. */
+export declare function headInner(html: string): string;

package/types/server/src/utils/stream-request.d.ts

@@ -0,0 +1,24 @@
+import type { ServerContext } from '@analogjs/router/tokens';
+/**
+ * Per-request decisions about whether the streaming renderer should fall back
+ * to a buffered render. Extracted from `render-stream` so they can be unit
+ * tested without driving the platform.
+ */
+/**
+ * User agents that receive a fully buffered render (with a resolved `<head>`)
+ * instead of the streamed shell. Streaming flushes the head before the app has
+ * set a dynamic title/meta and reconciles it via a finalize script; a crawler
+ * that does not run that script would index the shell's static head. Mirrors
+ * Nuxt's bot bypass — streaming targets interactive clients, bots get the
+ * buffered path whose head is byte-identical to the classic `render()`.
+ */
+export declare const SSR_BOT_RE: RegExp;
+export declare function isLikelyBot(serverContext: ServerContext): boolean;
+/**
+ * Whether streaming is disabled for this request by a `streaming: false` route
+ * rule. The platform plugin translates that rule into an `x-analog-no-streaming`
+ * response header (mirroring how `ssr: false` becomes `x-analog-no-ssr`); when
+ * present, `renderStream` produces the buffered `render()` output for this
+ * route instead of streaming.
+ */
+export declare function streamingDisabledByRoute(serverContext: ServerContext): boolean;

package/types/src/index.d.ts

@@ -1,16 +1,30 @@
 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 { injectServerFn, injectServerFnMutation, provideServerFnClient, ServerFnClient, } from './lib/server-fn/inject-server-fn';
+export { createServerFnRef, type ServerFnRefConfig, } from './lib/server-fn/server-fn-ref';
+export { SERVER_FN_DISPATCHER, type ServerFnDispatcher, } from './lib/server-fn/dispatcher';
+export type { ServerFn, ServerFnConfig, ServerFnContext, ServerFnDef, ServerFnHandler, ServerFnMethod, StandardSchemaV1, } from './lib/server-fn/types';
+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;