@qwik.dev/router 2.0.0-beta.4 → 2.0.0-beta.41

package/lib/index.d.ts

@@ -1,17 +1,23 @@
 /// <reference path="./modules.d.ts" />
 
+import type { AbortMessage } from '@qwik.dev/router/middleware/request-handler';
+import type { CacheControl } from '@qwik.dev/router/middleware/request-handler';
 import { Component } from '@qwik.dev/core';
+import type { ComputedSignal } from '@qwik.dev/core';
 import { Cookie } from '@qwik.dev/router/middleware/request-handler';
 import { CookieOptions } from '@qwik.dev/router/middleware/request-handler';
 import { CookieValue } from '@qwik.dev/router/middleware/request-handler';
 import { DeferReturn } from '@qwik.dev/router/middleware/request-handler';
 import type { EnvGetter } from '@qwik.dev/router/middleware/request-handler';
-import { JSXOutput as JSXOutput_2 } from '@qwik.dev/core';
+import { InternalRequest } from '@qwik.dev/router/middleware/request-handler';
+import { JSXOutput } from '@qwik.dev/core';
+import { NoSerialize } from '@qwik.dev/core';
 import { QRL } from '@qwik.dev/core';
 import { QRLEventHandlerMulti } from '@qwik.dev/core';
 import { QwikIntrinsicElements } from '@qwik.dev/core';
 import { QwikJSX } from '@qwik.dev/core';
-import type { ReadonlySignal } from '@qwik.dev/core';
+import { Render } from '@qwik.dev/core/server';
+import { RenderToStreamOptions } from '@qwik.dev/core/server';
 import { RequestEvent } from '@qwik.dev/router/middleware/request-handler';
 import { RequestEventAction } from '@qwik.dev/router/middleware/request-handler';
 import { RequestEventBase } from '@qwik.dev/router/middleware/request-handler';
@@ -20,8 +26,11 @@ import { RequestEventLoader } from '@qwik.dev/router/middleware/request-handler'
 import { RequestHandler } from '@qwik.dev/router/middleware/request-handler';
 import type { ResolveSyncValue } from '@qwik.dev/router/middleware/request-handler';
 import type { SerializationStrategy } from '@qwik.dev/core/internal';
+import type { ServerError } from '@qwik.dev/router/middleware/request-handler';
+import type { Signal } from '@qwik.dev/core';
 import type * as v from 'valibot';
 import type { ValueOrPromise } from '@qwik.dev/core';
+import { ValueOrPromise as ValueOrPromise_2 } from '@qwik.dev/core/internal';
 import { z } from 'zod';
 import type * as z_2 from 'zod';
 
@@ -32,51 +41,53 @@ export declare type Action<RETURN, INPUT = Record<string, unknown>, OPTIONAL ext
      * component$(). Like all `use-` functions and methods, it can only be invoked within a
      * `component$()`.
      */
-    (): ActionStore<RETURN, INPUT, OPTIONAL>;
+    (): ActionStore<ExcludeControlFlow<RETURN>, INPUT, OPTIONAL>;
 };
 
 /** @public */
 export declare type ActionConstructor = {
-    <OBJ extends Record<string, any> | void | null, VALIDATOR extends TypedDataValidator, REST extends [DataValidator, ...DataValidator[]]>(actionQrl: (data: GetValidatorOutputType<VALIDATOR>, event: RequestEventAction) => ValueOrPromise<OBJ>, options: {
-        readonly id?: string;
+    <OBJ extends Record<string, any> | void | null, VALIDATOR extends TypedDataValidator, REST extends [DataValidator, ...DataValidator[]]>(actionQrl: (data: GetValidatorOutputType<VALIDATOR>, event: RequestEventAction) => ValueOrPromise<OBJ>, options: ActionOptions & {
         readonly validation: [VALIDATOR, ...REST];
     }): Action<StrictUnion<OBJ | FailReturn<ValidatorErrorType<GetValidatorInputType<VALIDATOR>>> | FailReturn<FailOfRest<REST>>>, GetValidatorInputType<VALIDATOR>, false>;
-    <OBJ extends Record<string, any> | void | null, VALIDATOR extends TypedDataValidator>(actionQrl: (data: GetValidatorOutputType<VALIDATOR>, event: RequestEventAction) => ValueOrPromise<OBJ>, options: {
-        readonly id?: string;
+    <OBJ extends Record<string, any> | void | null, VALIDATOR extends TypedDataValidator>(actionQrl: (data: GetValidatorOutputType<VALIDATOR>, event: RequestEventAction) => ValueOrPromise<OBJ>, options: ActionOptions & {
         readonly validation: [VALIDATOR];
     }): Action<StrictUnion<OBJ | FailReturn<ValidatorErrorType<GetValidatorInputType<VALIDATOR>>>>, GetValidatorInputType<VALIDATOR>, false>;
-    <OBJ extends Record<string, any> | void | null, REST extends [DataValidator, ...DataValidator[]]>(actionQrl: (data: JSONObject, event: RequestEventAction) => ValueOrPromise<OBJ>, options: {
-        readonly id?: string;
+    <OBJ extends Record<string, any> | void | null, REST extends [DataValidator, ...DataValidator[]]>(actionQrl: (data: JSONObject, event: RequestEventAction) => ValueOrPromise<OBJ>, options: ActionOptions & {
         readonly validation: REST;
     }): Action<StrictUnion<OBJ | FailReturn<FailOfRest<REST>>>>;
     <OBJ extends Record<string, any> | void | null, VALIDATOR extends TypedDataValidator, REST extends [DataValidator, ...DataValidator[]]>(actionQrl: (data: GetValidatorOutputType<VALIDATOR>, event: RequestEventAction) => ValueOrPromise<OBJ>, options: VALIDATOR, ...rest: REST): Action<StrictUnion<OBJ | FailReturn<ValidatorErrorType<GetValidatorInputType<VALIDATOR>>> | FailReturn<FailOfRest<REST>>>, GetValidatorInputType<VALIDATOR>, false>;
     <OBJ extends Record<string, any> | void | null, VALIDATOR extends TypedDataValidator>(actionQrl: (data: GetValidatorOutputType<VALIDATOR>, event: RequestEventAction) => ValueOrPromise<OBJ>, options: VALIDATOR): Action<StrictUnion<OBJ | FailReturn<ValidatorErrorType<GetValidatorInputType<VALIDATOR>>>>, GetValidatorInputType<VALIDATOR>, false>;
     <OBJ extends Record<string, any> | void | null, REST extends [DataValidator, ...DataValidator[]]>(actionQrl: (form: JSONObject, event: RequestEventAction) => ValueOrPromise<OBJ>, ...rest: REST): Action<StrictUnion<OBJ | FailReturn<FailOfRest<REST>>>>;
-    <OBJ>(actionQrl: (form: JSONObject, event: RequestEventAction) => ValueOrPromise<OBJ>, options?: {
-        readonly id?: string;
-    }): Action<StrictUnion<OBJ>>;
+    <OBJ>(actionQrl: (form: JSONObject, event: RequestEventAction) => ValueOrPromise<OBJ>, options?: ActionOptions): Action<StrictUnion<OBJ>>;
 };
 
 /** @public */
 declare type ActionConstructorQRL = {
-    <OBJ extends Record<string, any> | void | null, VALIDATOR extends TypedDataValidator, REST extends [DataValidator, ...DataValidator[]]>(actionQrl: QRL<(data: GetValidatorOutputType<VALIDATOR>, event: RequestEventAction) => ValueOrPromise<OBJ>>, options: {
-        readonly id?: string;
+    <OBJ extends Record<string, any> | void | null, VALIDATOR extends TypedDataValidator, REST extends [DataValidator, ...DataValidator[]]>(actionQrl: QRL<(data: GetValidatorOutputType<VALIDATOR>, event: RequestEventAction) => ValueOrPromise<OBJ>>, options: ActionOptions & {
         readonly validation: [VALIDATOR, ...REST];
     }): Action<StrictUnion<OBJ | FailReturn<ValidatorErrorType<GetValidatorInputType<VALIDATOR>>> | FailReturn<FailOfRest<REST>>>, GetValidatorInputType<VALIDATOR>, false>;
-    <OBJ extends Record<string, any> | void | null, VALIDATOR extends TypedDataValidator>(actionQrl: QRL<(data: GetValidatorOutputType<VALIDATOR>, event: RequestEventAction) => ValueOrPromise<OBJ>>, options: {
-        readonly id?: string;
+    <OBJ extends Record<string, any> | void | null, VALIDATOR extends TypedDataValidator>(actionQrl: QRL<(data: GetValidatorOutputType<VALIDATOR>, event: RequestEventAction) => ValueOrPromise<OBJ>>, options: ActionOptions & {
         readonly validation: [VALIDATOR];
     }): Action<StrictUnion<OBJ | FailReturn<ValidatorErrorType<GetValidatorInputType<VALIDATOR>>>>, GetValidatorInputType<VALIDATOR>, false>;
-    <OBJ extends Record<string, any> | void | null, REST extends [DataValidator, ...DataValidator[]]>(actionQrl: QRL<(data: JSONObject, event: RequestEventAction) => ValueOrPromise<OBJ>>, options: {
-        readonly id?: string;
+    <OBJ extends Record<string, any> | void | null, REST extends [DataValidator, ...DataValidator[]]>(actionQrl: QRL<(data: JSONObject, event: RequestEventAction) => ValueOrPromise<OBJ>>, options: ActionOptions & {
         readonly validation: REST;
     }): Action<StrictUnion<OBJ | FailReturn<FailOfRest<REST>>>>;
     <OBJ extends Record<string, any> | void | null, VALIDATOR extends TypedDataValidator, REST extends [DataValidator, ...DataValidator[]]>(actionQrl: QRL<(data: GetValidatorOutputType<VALIDATOR>, event: RequestEventAction) => ValueOrPromise<OBJ>>, options: VALIDATOR, ...rest: REST): Action<StrictUnion<OBJ | FailReturn<ValidatorErrorType<GetValidatorInputType<VALIDATOR>>> | FailReturn<FailOfRest<REST>>>, GetValidatorInputType<VALIDATOR>, false>;
     <OBJ extends Record<string, any> | void | null, VALIDATOR extends TypedDataValidator>(actionQrl: QRL<(data: GetValidatorOutputType<VALIDATOR>, event: RequestEventAction) => ValueOrPromise<OBJ>>, options: VALIDATOR): Action<StrictUnion<OBJ | FailReturn<ValidatorErrorType<GetValidatorInputType<VALIDATOR>>>>, GetValidatorInputType<VALIDATOR>, false>;
     <OBJ extends Record<string, any> | void | null, REST extends [DataValidator, ...DataValidator[]]>(actionQrl: QRL<(form: JSONObject, event: RequestEventAction) => ValueOrPromise<OBJ>>, ...rest: REST): Action<StrictUnion<OBJ | FailReturn<FailOfRest<REST>>>>;
-    <OBJ>(actionQrl: QRL<(form: JSONObject, event: RequestEventAction) => ValueOrPromise<OBJ>>, options?: {
-        readonly id?: string;
-    }): Action<StrictUnion<OBJ>>;
+    <OBJ>(actionQrl: QRL<(form: JSONObject, event: RequestEventAction) => ValueOrPromise<OBJ>>, options?: ActionOptions): Action<StrictUnion<OBJ>>;
+};
+
+/** @public */
+export declare type ActionOptions = {
+    readonly id?: string;
+    readonly validation?: DataValidator[];
+    /**
+     * Route loaders to invalidate after this action completes. The loader hooks' hashes are sent to
+     * the client so it knows which loaders to re-fetch. If omitted, ALL route loaders are invalidated
+     * (unless `strictLoaders` is enabled globally in the Vite plugin).
+     */
+    readonly invalidate?: Loader_2<any>[];
 };
 
 /** @public */
@@ -157,6 +168,27 @@ export declare type ActionStore<RETURN, INPUT, OPTIONAL extends boolean = true>
 
 declare type AnchorAttributes = QwikIntrinsicElements['a'];
 
+/**
+ * Cache key function. Used by `routeConfig.cacheKey` (SSR HTML cache) and by `routeLoader$`'s
+ * `cacheKey` option (per-loader JSON cache).
+ *
+ * - `true`: use the surface's default key.
+ *
+ *   - SSR default: `${status}|${eTag}|${pathname}` when an eTag is set, otherwise
+ *       `${status}|${pathname}`.
+ *   - Loader default: `${pathname}|${filteredSearch}|${loaderId}|${eTag}` when an eTag is set,
+ *       otherwise `${pathname}|${filteredSearch}|${loaderId}`.
+ * - Function: receives the request event and the normalized, unquoted eTag (or an empty string when
+ *   none was provided). Return the cache key string, or `null` or `''` to skip caching for this
+ *   request. Loader callbacks receive the loader-scoped request event, with `url`, `query`, and
+ *   `request.url` filtered by the loader's `search` allowlist.
+ *
+ * Note: valid cacheKeys are non-empty strings.
+ *
+ * @public
+ */
+export declare type CacheKeyFn = true | ((requestEv: RequestEvent, eTag: string) => string | null);
+
 /** @public */
 export declare interface ContentHeading {
     readonly text: string;
@@ -173,9 +205,28 @@ export declare interface ContentMenu {
 
 declare type ContentModule = PageModule | LayoutModule;
 
-declare type ContentModuleHead = DocumentHead | ResolvedDocumentHead;
+/**
+ * The eTag export type for routeConfig.
+ *
+ * - `string` — static ETag value.
+ * - `(props: DocumentHeadProps) => string | null` — compute the ETag from route context (params, URL,
+ *   loaded data via `resolveValue`, etc.). Return `null` to skip eTag for this request.
+ *
+ * Qwik normalizes eTag values by stripping weak-form `W/` prefixes, quotes, and forbidden chars,
+ * then sends a strong `ETag` header. Values that normalize to an empty string are treated as
+ * absent.
+ *
+ * When set (and a value is produced), the server includes an `ETag` header and returns `304` if
+ * `If-None-Match` matches.
+ *
+ * @public
+ */
+export declare type ContentModuleETag = string | ((props: DocumentHeadProps) => string | null);
 
-declare type ContentModuleLoader = () => Promise<ContentModule>;
+/** @public */
+export declare type ContentModuleHead = DocumentHead | ResolvedDocumentHead;
+
+declare type ContentModuleLoader = () => ValueOrPromise<ContentModule>;
 
 /** @public */
 declare interface ContentState {
@@ -189,6 +240,38 @@ export { CookieOptions }
 
 export { CookieValue }
 
+/**
+ * Creates the `render()` function that is required by `createQwikRouter()`. It requires a function
+ * that returns the `jsx` and `options` for the renderer.
+ *
+ * @example
+ *
+ * ```tsx
+ * const renderer = createRenderer((opts) => {
+ *   if (opts.requestHeaders['x-hello'] === 'world') {
+ *     return { jsx: <Hello />, options: opts };
+ *   }
+ *   return { jsx: <Root />, options: {
+ *     ...opts,
+ *     serverData: {
+ *       ...opts.serverData,
+ *       documentHead: {
+ *         meta: [
+ *           { name: 'renderedAt', content: new Date().toISOString() },
+ *         ],
+ *       },
+ *     },
+ *   } };
+ * });
+ * ```
+ *
+ * @public
+ */
+export declare const createRenderer: (getOptions: (options: RendererOptions) => {
+    jsx: JSXOutput;
+    options: RendererOutputOptions;
+}) => Render;
+
 /** @public */
 export declare type DataValidator<T extends Record<string, any> = {}> = {
     validate(ev: RequestEvent, data: unknown): Promise<ValidatorReturn<T>>;
@@ -196,32 +279,48 @@ export declare type DataValidator<T extends Record<string, any> = {}> = {
 
 export { DeferReturn }
 
-/** @public */
-declare interface DevJSX {
-    fileName: string;
-    lineNumber: number;
-    columnNumber: number;
-    stack?: string;
-}
-
 /** @public */
 export declare type DocumentHead = DocumentHeadValue | ((props: DocumentHeadProps) => DocumentHeadValue);
 
 /** @public */
 export declare interface DocumentHeadProps extends RouteLocation {
     readonly head: ResolvedDocumentHead;
+    /** The HTTP status code of the response (e.g. 200, 404). */
+    readonly status: number;
+    /** @deprecated This is not necessary, it works correctly without */
     readonly withLocale: <T>(fn: () => T) => T;
     readonly resolveValue: ResolveSyncValue;
 }
 
+/**
+ * This renders all the tags collected from `head`.
+ *
+ * You can partially override the head, for example if you want to change the title:
+ *
+ * ```tsx
+ * import { DocumentHeadTags, useDocumentHead } from '@qwik.dev/router';
+ *
+ * export default component$(() => {
+ *   const head = useDocumentHead();
+ *   return <DocumentHeadTags title={`${head.title} - My App`} />;
+ * });
+ * ```
+ *
+ * You don't have to use this component, you can also do it yourself for full control. Just copy the
+ * code from this component and modify it to your needs.
+ *
+ * Note that this component normally only runs once, during SSR. You can use Signals in your
+ * `src/root.tsx` to make runtime changes to `<head>` if needed.
+ *
+ * @public
+ */
+export declare const DocumentHeadTags: Component<DocumentHeadValue<Record<string, unknown>>>;
+
 /** @public */
 export declare interface DocumentHeadValue<FrontMatter extends Record<string, any> = Record<string, unknown>> {
     /** Sets `document.title`. */
     readonly title?: string;
-    /**
-     * Used to manually set meta tags in the head. Additionally, the `data` property could be used to
-     * set arbitrary data which the `<head>` component could later use to generate `<meta>` tags.
-     */
+    /** Used to manually set meta tags in the head. */
     readonly meta?: readonly DocumentMeta[];
     /** Used to manually append `<link>` elements to the `<head>`. */
     readonly links?: readonly DocumentLink[];
@@ -238,53 +337,60 @@ export declare interface DocumentHeadValue<FrontMatter extends Record<string, an
 }
 
 /** @public */
-export declare interface DocumentLink {
-    as?: string;
-    crossorigin?: string;
-    disabled?: boolean;
-    href?: string;
-    hreflang?: string;
-    id?: string;
-    imagesizes?: string;
-    imagesrcset?: string;
-    integrity?: string;
-    media?: string;
-    prefetch?: string;
-    referrerpolicy?: string;
-    rel?: string;
-    sizes?: string;
-    title?: string;
-    type?: string;
-    key?: string;
-}
+export declare type DocumentLink = QwikIntrinsicElements['link'];
 
 /** @public */
-export declare interface DocumentMeta {
-    readonly content?: string;
-    readonly httpEquiv?: string;
-    readonly name?: string;
-    readonly property?: string;
-    readonly key?: string;
-    readonly itemprop?: string;
-    readonly media?: string;
-}
-
-/** @beta */
-export declare interface DocumentScript {
-    readonly script?: string;
-    readonly props?: Readonly<QwikIntrinsicElements['script']>;
-    readonly key?: string;
-}
+export declare type DocumentMeta = QwikIntrinsicElements['meta'];
 
 /** @public */
-export declare interface DocumentStyle {
-    readonly style: string;
-    readonly props?: Readonly<QwikIntrinsicElements['style']>;
-    readonly key?: string;
+export declare type DocumentScript = ((Omit<QwikIntrinsicElements['script'], 'dangerouslySetInnerHTML'> & {
+    props?: never;
+}) | {
+    key?: string;
+    /**
+     * The props of the script element. @deprecated Prefer setting the properties directly instead
+     * of using this property.
+     */
+    props: Readonly<QwikIntrinsicElements['script']>;
+}) & ({
+    /** The inline script content. */
+    script?: string;
+    dangerouslySetInnerHTML?: never;
+} | {
+    dangerouslySetInnerHTML?: string;
+    script?: never;
+});
+
+/** @public */
+export declare type DocumentStyle = Readonly<((Omit<QwikIntrinsicElements['style'], 'dangerouslySetInnerHTML'> & {
+    props?: never;
+}) | {
+    key?: string;
+    /**
+     * The props of the style element. @deprecated Prefer setting the properties directly
+     * instead of using this property.
+     */
+    props: Readonly<QwikIntrinsicElements['style']>;
+}) & ({
+    /** The inline style content. */
+    style?: string;
+    dangerouslySetInnerHTML?: never;
+} | {
+    dangerouslySetInnerHTML?: string;
+    style?: never;
+})>;
+
+declare type EndpointModuleLoader = () => ValueOrPromise<RouteModule>;
+
+declare interface EndpointResponse {
+    status: number;
+    statusMessage?: string;
+    formData?: FormData;
+    action?: string;
+    actionResult?: unknown;
+    loaderHashes?: string[];
 }
 
-declare type EndpointModuleLoader = () => Promise<RouteModule>;
-
 /** @public */
 export declare const ErrorBoundary: Component<ErrorBoundaryProps>;
 
@@ -293,6 +399,14 @@ declare interface ErrorBoundaryProps {
     fallback$?: QRL<(error: any) => any>;
 }
 
+/**
+ * Drops control-flow signals (`ev.redirect()`, `ev.error()`, etc.) from a loader/action return
+ * type: those are thrown, not surfaced as data. `ev.fail()` is plain data and is kept.
+ *
+ * @public
+ */
+export declare type ExcludeControlFlow<T> = Exclude<T, AbortMessage | ServerError>;
+
 declare type Failed = {
     failed: true;
 };
@@ -304,7 +418,7 @@ export declare type FailOfRest<REST extends readonly DataValidator[]> = REST ext
 export declare type FailReturn<T> = T & Failed;
 
 /** @public */
-export declare const Form: <O, I>({ action, spaReset, reloadDocument, onSubmit$, ...rest }: FormProps<O, I>, key: string | null) => JSXOutput_2;
+export declare const Form: <O, I>({ action, spaReset, reloadDocument, onSubmit$, ...rest }: FormProps<O, I>, key: string | null) => JSXOutput;
 
 /** @public */
 export declare interface FormProps<O, I> extends Omit<QwikJSX.IntrinsicElements['form'], 'action' | 'method'> {
@@ -322,8 +436,6 @@ export declare interface FormProps<O, I> extends Omit<QwikJSX.IntrinsicElements[
      * Defaults to `false`
      */
     spaReset?: boolean;
-    /** Event handler executed right when the form is submitted. */
-    onSubmit$?: QRLEventHandlerMulti<SubmitEvent, HTMLFormElement> | undefined;
     /** Event handler executed right after the action is executed successfully and returns some data. */
     onSubmitCompleted$?: QRLEventHandlerMulti<CustomEvent<FormSubmitSuccessDetail<O>>, HTMLFormElement> | undefined;
     key?: string | number | null;
@@ -336,15 +448,12 @@ export declare interface FormSubmitSuccessDetail<T> {
 }
 
 /**
- * Any function taking a props object that returns JSXOutput.
- *
- * The `key`, `flags` and `dev` parameters are for internal use.
+ * Returns the current RequestEvent if possible. Only usable on the server, and only during request
+ * processing.
  *
  * @public
  */
-declare type FunctionComponent<P = unknown> = {
-    renderFn(props: P, key: string | null, flags: number, dev?: DevJSX): JSXOutput;
-}['renderFn'];
+export declare const getRequestEvent: (thisArg?: unknown) => RequestEvent | undefined;
 
 /** @public */
 export declare type GetValidatorInputType<VALIDATOR extends TypedDataValidator> = VALIDATOR extends ValibotDataValidator<infer TYPE> ? v.InferInput<TYPE> : VALIDATOR extends ZodDataValidator<infer TYPE> ? z_2.input<TYPE> : never;
@@ -360,6 +469,16 @@ export declare const globalAction$: ActionConstructor;
 
 /* Excluded from this release type: globalActionQrl */
 
+/** @public */
+export declare type HttpErrorProps = {
+    /** The HTTP status code, e.g. 404 */
+    status: number;
+    /** The error message, e.g. "Not Found" */
+    message: string;
+};
+
+export { InternalRequest }
+
 declare type IsAny<Type> = 0 extends 1 & Type ? true : false;
 
 /** @public */
@@ -372,31 +491,9 @@ export declare type JSONValue = string | number | boolean | {
     [x: string]: JSONValue;
 } | Array<JSONValue>;
 
-/** @public */
-declare type JSXChildren = string | number | boolean | null | undefined | Function | RegExp | JSXChildren[] | Promise<JSXChildren> | Signal<JSXChildren> | JSXNode;
-
-/**
- * A JSX Node, an internal structure. You probably want to use `JSXOutput` instead.
- *
- * @public
- */
-declare interface JSXNode<T extends string | FunctionComponent | unknown = unknown> {
-    type: T;
-    props: T extends FunctionComponent<infer P> ? P : Record<any, unknown>;
-    children: JSXChildren | null;
-    key: string | null;
-    dev?: DevJSX;
-}
-
-/**
- * Any valid output for a component
- *
- * @public
- */
-declare type JSXOutput = JSXNode | string | number | boolean | null | undefined | JSXOutput[];
-
 declare interface LayoutModule extends RouteModule {
-    readonly default: unknown;
+    readonly default?: (props: Record<string, never>) => JSXOutput;
+    readonly routeConfig?: RouteConfig;
     readonly head?: ContentModuleHead;
 }
 
@@ -406,34 +503,73 @@ export declare const Link: Component<LinkProps>;
 /** @public */
 export declare interface LinkProps extends AnchorAttributes {
     /**
-     * **Defaults to _true_.**
+     * @deprecated Use `prefetchBundles` and `prefetchData` instead for more granular control over
+     *   what is prefetched and when. This prop will be removed in a future major version.
      *
-     * Whether Qwik should prefetch and cache the target page of this **`Link`**, this includes
-     * invoking any **`routeLoader$`**, **`onGet`**, etc.
+     *   Legacy prefetch control for this **`Link`**.
      *
-     * This **improves UX performance** for client-side (**SPA**) navigations.
+     *   Setting this value to **`"js"`** will prefetch only javascript bundles required to render this
+     *   page on the client when the link becomes visible. Setting this value to **`true`** will
+     *   prefetch both javascript bundles and route data when the link becomes visible. Setting this
+     *   value to **`false`** will disable prefetching altogether.
+     */
+    prefetch?: boolean | 'js';
+    /**
+     * Controls when Qwik should prefetch the javascript bundles required to render this **`Link`**
+     * target during client-side navigation.
      *
-     * Prefetching occurs when a the Link enters the viewport in production (**`on:qvisible`**), or
-     * with **`mouseover`/`focus`** during dev.
+     * Defaults to **`"visible"`**.
      *
      * Prefetching will not occur if the user has the **data saver** setting enabled.
+     */
+    prefetchBundles?: PrefetchStrategy;
+    /**
+     * Controls when Qwik should prefetch and cache route data for this **`Link`** target, including
+     * invoking any **`routeLoader$`**, **`onGet`**, etc.
+     *
+     * Defaults to **`"intent"`**. When using the deprecated **`prefetch="js"`** prop, route data
+     * prefetching defaults to **`"off"`**.
      *
-     * Setting this value to **`"js"`** will prefetch only javascript bundles required to render this
-     * page on the client, **`false`** will disable prefetching altogether.
+     * Prefetching route data can improve client-side navigation performance for pages that wait on
+     * loaders, server handlers, databases, or API calls.
+     *
+     * Prefetching will not occur if the user has the **data saver** setting enabled.
      */
-    prefetch?: boolean | 'js';
+    prefetchData?: PrefetchStrategy;
     reload?: boolean;
     replaceState?: boolean;
     scroll?: boolean;
 }
 
+/** The route to render */
+declare interface LoadedRoute {
+    /** The canonical path of the route, e.g. `/products/[id]` */
+    $routeName$: string;
+    /** The route parameters, e.g. `{ id: '123' }` */
+    $params$: PathParams;
+    /** The modules associated with this route (on 404, contains only the error component) */
+    $mods$: (RouteModule | ContentModule)[];
+    /** The menu associated with this route */
+    $menu$?: ContentMenu | undefined;
+    /** The bundle names for this route */
+    $routeBundleNames$?: string[] | undefined;
+    /** Whether this route is a not-found (404) route */
+    $notFound$?: boolean;
+    /** The nearest _E (error.tsx) boundary's chain to render on a thrown ServerError (in its layouts). */
+    $errorLoader$?: ModuleLoader[];
+    /** Merged array of routeLoader$ hashes from all matched nodes (layouts + page) */
+    $loaders$?: string[];
+    /** Runtime-only mapping of routeLoader$ hashes to the matched pathname used for q-loader fetches */
+    $loaderPaths$?: Record<string, string>;
+}
+
 /** @public */
 declare type Loader_2<RETURN> = {
     /**
      * Returns the `Signal` containing the data returned by the `loader$` function. Like all `use-`
      * functions and methods, it can only be invoked within a `component$()`.
      */
-    (): LoaderSignal<RETURN>;
+    (): LoaderSignal<ExcludeControlFlow<RETURN>>;
 };
 export { Loader_2 as Loader }
 
@@ -451,16 +587,91 @@ declare type LoaderConstructorQRL = {
 
 /** @public */
 declare type LoaderOptions = {
+    /**
+     * Explicit loader id, overriding the QRL hash. Pass a distinct value (e.g. `fn.getHash()`) when
+     * loaders share a wrapper QRL.
+     */
     readonly id?: string;
     readonly validation?: DataValidator[];
     readonly serializationStrategy?: SerializationStrategy;
+    /**
+     * Cache-Control for this loader's JSON responses. The browser HTTP cache is the single source of
+     * freshness for loader data: on every client navigation the loaders re-fetch, and this header
+     * decides whether the browser serves the fetch from cache, revalidates, or hits the server.
+     *
+     * Accepts any `cacheControl()` value (`'immutable'`, `'no-cache'`, a max-age number, an options
+     * object) or a function of the request event; the function may return `null` to skip the header.
+     * A `Cache-Control` header set inside the loader function wins over this option.
+     *
+     * Defaults to `no-cache` (always revalidate; combine with `eTag` for cheap 304s).
+     *
+     * The literal value `'immutable'` also marks the loader's data as static, so SSG writes a
+     * per-loader JSON file at build time.
+     */
+    readonly cacheControl?: CacheControl | ((ev: RequestEvent) => CacheControl | null);
+    /**
+     * Enable ETag-based caching for this loader's JSON responses.
+     *
+     * - `string` — static ETag value; if `If-None-Match` matches, the loader is skipped entirely
+     * - `(ev: RequestEvent) => string | null` — compute the ETag from the request context (params, URL,
+     *   headers, etc.); if `If-None-Match` matches, the loader is skipped entirely. Return null to
+     *   skip eTag for this request.
+     *
+     * Qwik normalizes eTag values by stripping weak-form `W/` prefixes, quotes, and forbidden chars,
+     * then sends a strong `ETag` header. Values that normalize to an empty string are treated as
+     * absent.
+     *
+     * When set, the server includes an `ETag` header on `q-loader-*.json` responses and returns `304`
+     * if the client sends a matching `If-None-Match` header.
+     *
+     * For auto-computed eTags, use `cacheKey` instead — on cache write the eTag is hashed from the
+     * serialized response and stored alongside it, so subsequent hits get the same eTag.
+     */
+    readonly eTag?: string | ((ev: RequestEvent) => string | null);
+    /**
+     * Enable in-memory server-side caching of this loader's serialized JSON response.
+     *
+     * - `true` — use the default key `${pathname}|${filteredSearch}|${loaderId}` (suffixed with
+     *   `|${eTag}` when an eTag is set).
+     * - Function `(requestEv, eTag) => string | null` — return a custom key, or `null` to skip caching
+     *   this request.
+     *
+     * On cache miss the loader runs, the serialized response is stored alongside its eTag (computed
+     * from the data when no `eTag` option is set), and the response is sent. On cache hit the stored
+     * `{ eTag, data }` pair is served directly — `If-None-Match` is checked against the stored eTag
+     * and a `304` is returned when it matches.
+     */
+    readonly cacheKey?: CacheKeyFn;
+    /**
+     * Allowlist of URL search parameter names that this loader depends on.
+     *
+     * When set, the loader only re-fetches when the listed search params change — other param changes
+     * are ignored. Only the listed params are sent in the loader JSON request URL. During SSR and
+     * loader JSON requests, the loader receives a request event with `url`, `query`, and
+     * `request.url` filtered to the same params.
+     *
+     * When not set, the `qwikRouter()` plugin option `strictLoaders` determines the behavior. If
+     * `strictLoaders` is `true` (this is the default), no search params are sent and changes do not
+     * trigger a re-fetch. If `strictLoaders` is `false`, all search params are sent and any change
+     * triggers a re-fetch.
+     */
+    readonly search?: string[];
+    /**
+     * When true (default), the loader is awaited before SSR renders, so its redirect or error can
+     * short-circuit the response and its value is ready for synchronous reads (e.g. in the head).
+     *
+     * When false, the loader runs in the background without blocking SSR: rendering starts
+     * immediately and reading its `.value` suspends until it resolves. A background loader cannot
+     * redirect or error the initial SSR response; treat it as a separate request.
+     *
+     * Setting `false` is experimental and requires adding `experimental: ["blockSSR"]` to your
+     * qwikVite plugin options.
+     */
+    readonly blockSSR?: boolean;
 };
 
 /** @public */
-export declare type LoaderSignal<TYPE> = TYPE extends () => ValueOrPromise<infer VALIDATOR> ? ReadonlySignal<ValueOrPromise<VALIDATOR>> : ReadonlySignal<TYPE>;
-
-/** @public */
-export declare type MenuData = [pathname: string, menuLoader: MenuModuleLoader];
+export declare type LoaderSignal<TYPE> = (TYPE extends () => ValueOrPromise<infer VALIDATOR> ? Signal<ValueOrPromise<VALIDATOR>> : Signal<TYPE>) & Pick<ComputedSignal<any>, 'promise' | 'pending' | 'error' | 'loading'>;
 
 declare interface MenuModule {
     readonly default: ContentMenu;
@@ -483,16 +694,42 @@ export { NavigationType_2 as NavigationType }
 export declare function omitProps<T, KEYS extends keyof T>(obj: T, keys: KEYS[]): Omit<T, KEYS>;
 
 /** @public */
-export declare interface PageModule extends RouteModule {
-    readonly default: unknown;
+export declare type PageModule = RouteModule & {
+    readonly default: (props: Record<string, never>) => JSXOutput;
+    readonly routeConfig?: RouteConfig;
     readonly head?: ContentModuleHead;
+    readonly eTag?: ContentModuleETag;
+    readonly cacheKey?: CacheKeyFn;
     readonly headings?: ContentHeading[];
     readonly onStaticGenerate?: StaticGenerateHandler;
-}
+};
 
 /** @public */
 export declare type PathParams = Record<string, string>;
 
+/**
+ * Defines when link prefetching should be triggered.
+ *
+ * @public
+ */
+export declare type PrefetchStrategy = 
+/**
+* Prefetch when the user commits to navigating.
+*
+* Triggered by `pointerdown` or the `Enter` key.
+*/
+'commit'
+/**
+* Prefetch when the user shows navigation intent.
+*
+* Triggered by `pointerenter`, hover, or focus.
+*/
+| 'intent'
+/** Prefetch when the link becomes visible in the viewport. */
+| 'visible'
+/** Disable link prefetching. */
+| 'off';
+
 declare type Prettify<T> = {} & {
     [K in keyof T]: T[K];
 };
@@ -510,6 +747,9 @@ declare type Prettify<T> = {} & {
  */
 export declare type PreventNavigateCallback = (url?: number | URL) => ValueOrPromise<boolean>;
 
+/** @public */
+export declare const Q_ROUTE = "q:route";
+
 /**
  * @deprecated Use `QWIK_ROUTER_SCROLLER` instead (will be removed in V3)
  * @public
@@ -520,13 +760,7 @@ export declare const QWIK_CITY_SCROLLER = "_qCityScroller";
 export declare const QWIK_ROUTER_SCROLLER = "_qRouterScroller";
 
 /**
- * @deprecated Use `QwikRouterMockProps` instead. will be removed in V3
- * @public
- */
-export declare type QwikCityMockProps = QwikRouterMockProps;
-
-/**
- * @deprecated Use `QwikRouterMockProvider` instead. Will be removed in V3
+ * @deprecated Use `useQwikMockRouter()` instead. Will be removed in V3
  * @public
  */
 export declare const QwikCityMockProvider: Component<QwikRouterMockProps>;
@@ -538,32 +772,95 @@ export declare const QwikCityMockProvider: Component<QwikRouterMockProps>;
 export declare type QwikCityPlan = QwikRouterConfig;
 
 /**
- * @deprecated Use `QwikRouterProps` instead. will be removed in V3
+ * @deprecated Use `QwikRouterProps` instead. Will be removed in v3.
  * @public
  */
 export declare type QwikCityProps = QwikRouterProps;
 
 /**
- * @deprecated Use `QwikRouterProvider` instead. will be removed in V3
+ * @deprecated Use `useQwikRouter()` instead. Will be removed in v3.
  * @public
  */
 export declare const QwikCityProvider: Component<QwikRouterProps>;
 
 /** @public */
 export declare interface QwikRouterConfig {
-    readonly routes: RouteData[];
+    readonly routes: RouteData;
     readonly serverPlugins?: RouteModule[];
     readonly basePathname?: string;
-    readonly menus?: MenuData[];
     readonly trailingSlash?: boolean;
     readonly cacheModules?: boolean;
+    /** When true, return null instead of rendering the 404 page, letting the adapter handle it */
+    readonly fallthrough?: boolean;
+}
+
+/** @public */
+export declare interface QwikRouterEnvData {
+    routeName: string;
+    ev: RequestEvent;
+    params: PathParams;
+    response: EndpointResponse;
+    loadedRoute: LoadedRoute;
+    routeLoaderCtx: RouteLoaderCtx;
+    loaderValues: Record<string, unknown>;
+}
+
+/** @public */
+export declare interface QwikRouterMockActionProp<T = any> {
+    /** The action function to mock. */
+    action: Action<T>;
+    /** The QRL function that will be called when the action is submitted. */
+    handler: QRL<(data: T) => ValueOrPromise_2<RouteActionResolver>>;
+}
+
+/** @public */
+export declare interface QwikRouterMockLoaderProp<T = any> {
+    /** The loader function to mock. */
+    loader: Loader_2<T>;
+    /** The data to return when the loader is called. */
+    data: T;
 }
 
 /** @public */
 export declare interface QwikRouterMockProps {
+    /**
+     * Allow mocking the url returned by `useLocation` hook.
+     *
+     * Default: `http://localhost/`
+     */
     url?: string;
+    /** Allow mocking the route params returned by `useLocation` hook. */
     params?: Record<string, string>;
+    /** Allow mocking the `goto` function returned by `useNavigate` hook. */
     goto?: RouteNavigate;
+    /**
+     * Allow mocking data for loaders defined with `routeLoader$` function.
+     *
+     * ```
+     * [
+     *   {
+     *     loader: useProductData,
+     *     data: { product: { name: 'Test Product' } },
+     *   },
+     * ];
+     * ```
+     */
+    loaders?: Array<QwikRouterMockLoaderProp<any>>;
+    /**
+     * Allow mocking actions defined with `routeAction$` function.
+     *
+     * ```
+     * [
+     *   {
+     *     action: useAddUser,
+     *     handler: $(async (data) => {
+     *       console.log('useAddUser action called with data:', data);
+     *     }),
+     *   },
+     * ];
+     * ```
+     */
+    actions?: Array<QwikRouterMockActionProp<any>>;
 }
 
 /** @public */
@@ -572,9 +869,9 @@ export declare const QwikRouterMockProvider: Component<QwikRouterMockProps>;
 /** @public */
 export declare interface QwikRouterProps {
     /**
-     * Enable the ViewTransition API
+     * Enable the ViewTransition API on SPA navigation. Opt-in: set to `true` to enable.
      *
-     * Default: `true`
+     * Default: `false`
      *
      * @see https://github.com/WICG/view-transitions/blob/main/explainer.md
      * @see https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API
@@ -583,13 +880,20 @@ export declare interface QwikRouterProps {
     viewTransition?: boolean;
 }
 
-/** @public */
+/** @public This is a wrapper around the `useQwikRouter()` hook. We recommend using the hook instead of this component, unless you have a good reason to make your root component reactive. */
 export declare const QwikRouterProvider: Component<QwikRouterProps>;
 
 /** @public */
-declare interface ReadonlySignal_2<T = unknown> {
-    readonly value: T;
-}
+export declare type RendererOptions = Omit<RenderToStreamOptions, 'serverData'> & {
+    serverData: ServerData;
+};
+
+/** @public */
+export declare type RendererOutputOptions = Omit<RenderToStreamOptions, 'serverData'> & {
+    serverData: ServerData & {
+        documentHead?: DocumentHeadValue;
+    } & Record<string, unknown>;
+};
 
 export { RequestEvent }
 
@@ -604,24 +908,163 @@ export { RequestEventLoader }
 export { RequestHandler }
 
 /** @public */
-export declare type ResolvedDocumentHead<FrontMatter extends Record<string, any> = Record<string, unknown>> = Required<DocumentHeadValue<FrontMatter>>;
+export declare type ResolvedDocumentHead<FrontMatter extends Record<string, any> = Record<string, unknown>> = Required<DocumentHeadValue<FrontMatter>> & {
+    /** The build's manifest hash, used for per-loader data URLs. Always defined (`'dev'` in dev). */
+    readonly manifestHash: string;
+};
 
-/** @public */
+/**
+ * Define a route action that handles form submissions or programmatic invocations.
+ *
+ * Actions run on the server when submitted from the client. The result is returned as an
+ * `ActionStore` with `.value` for success data and `.error` for errors (including validation errors
+ * from `zod$`/`valibot$` where `.fieldErrors` etc. are accessible directly on `.error`).
+ *
+ * By default, after an action completes, ALL current route loaders are invalidated on the client
+ * and re-fetched as needed (so that the browser cache is correct). This can be controlled with:
+ *
+ * - `invalidate: [loader1, loader2]`: Only invalidate specific loaders. The client re-fetches them
+ *   individually. Other loaders keep their current data.
+ * - `invalidate: []`: No loaders are invalidated. The action response only contains the action
+ *   result. Use this when the action doesn't affect any loader data.
+ *
+ * The `strictLoaders` Vite plugin option applies `invalidate: []` globally for all actions that
+ * don't specify an explicit `invalidate` option.
+ *
+ * @public
+ */
 export declare const routeAction$: ActionConstructor;
 
-/* Excluded from this release type: routeActionQrl */
-
 /** @public */
-export declare type RouteData = [routeName: string, loaders: ModuleLoader[]] | [
-routeName: string,
-loaders: ModuleLoader[],
-originalPathname: string,
-routeBundleNames: string[]
-];
+export declare const routeActionQrl: ActionConstructorQRL;
 
-/** @public */
+declare type RouteActionResolver = {
+    status: number;
+    result: unknown;
+};
+
+/**
+ * Unified route configuration export. Groups head, eTag, and cacheKey with the same resolution
+ * rules as DocumentHead: can be a static object or a function receiving DocumentHeadProps.
+ *
+ * When a module exports `routeConfig`, the separate `head`, `eTag`, and `cacheKey` exports are
+ * ignored for that module.
+ *
+ * @public
+ */
+export declare type RouteConfig = RouteConfigValue | ((props: DocumentHeadProps) => RouteConfigValue);
+
+/**
+ * The value shape returned by a routeConfig export (object form or function return).
+ *
+ * @public
+ */
+export declare interface RouteConfigValue {
+    readonly head?: DocumentHeadValue;
+    readonly eTag?: ContentModuleETag;
+    readonly cacheKey?: CacheKeyFn;
+}
+
+/**
+ * A nested route trie structure. The root represents `/` and each level represents a URL segment.
+ *
+ * Keys starting with `_` are metadata; all other keys are child route segments.
+ *
+ * - Use `_W` as the key for a single dynamic segment (param); `_P` on that node names the param.
+ * - Use `_A` as the key for a rest/catch-all segment; `_P` on that node names the param.
+ * - For infix params like `pre[slug]post`, use `_W` with `_0` (prefix) and `_9` (suffix).
+ * - Use `_M` for an array of group (pathless layout) nodes, sorted by group name.
+ *
+ * When matching, exact segments are tried first (case-insensitive), then `_W` (with optional
+ * prefix/suffix), then `_A`. When no route matches, the closest `_E` (error.tsx) or `_4` (404.tsx)
+ * loader in the ancestor chain is used to render the error page.
+ *
+ * @public
+ */
+export declare interface RouteData {
+    /** This node's layout loader (single). Runtime accumulates these during trie traversal. */
+    _L?: ContentModuleLoader;
+    /**
+     * This node's index/page loader. Single = normal (runtime prepends gathered _L). Array = override
+     * (layout stop / named layout — IS the complete chain).
+     */
+    _I?: ContentModuleLoader | ModuleLoader[];
+    /** Rewrite/goto target path. Matcher re-walks trie from root using this path's keys. */
+    _G?: string;
+    /** The JS bundle names for this route (SSR only) */
+    _B?: string[];
+    /**
+     * Not-found (404) boundary: single loader (runtime prepends layouts) or override chain
+     * (`404@layout`/`!`).
+     */
+    _4?: ContentModuleLoader | ModuleLoader[];
+    /** Error (error.tsx) boundary, same single-or-override-chain shape as `_4`. */
+    _E?: ContentModuleLoader | ModuleLoader[];
+    /** The parameter name when this node is reached via `_W` or `_A` from the parent */
+    _P?: string;
+    /** Prefix for infix params (e.g. "pre" for `pre[slug]post`) — only on `_W` nodes */
+    _0?: string;
+    /** Suffix for infix params (e.g. "post" for `pre[slug]post`) — only on `_W` nodes */
+    _9?: string;
+    /** Group (pathless layout) nodes merged into this level, sorted by group name */
+    _M?: RouteData[];
+    /** Menu loader for this subtree (from menu.md). Runtime uses nearest ancestor during traversal. */
+    _N?: MenuModuleLoader;
+    /** Array of routeLoader$ hashes for this node's loaders */
+    _R?: string[];
+    /** Child route segments (any key not starting with `_`) */
+    [part: string]: RouteData | RouteData[] | ModuleLoader[] | ContentModuleLoader | MenuModuleLoader | string[] | string | undefined;
+}
+
+/**
+ * Define a route loader that fetches data before the route renders.
+ *
+ * Route loaders run on the server during SSR and return data as a `ComputedSignal`. On the client,
+ * loaders automatically re-fetch when the route changes (SPA navigation). Each loader gets its own
+ * JSON endpoint (`q-loader-{id}.{hash}.json`), so only the loaders present on the target route are
+ * fetched.
+ *
+ * **Important:** Route loader data uses Qwik's custom serialization format, not standard JSON. This
+ * means the data supports features like circular references, Dates, and other non-JSON types, but
+ * it cannot be consumed by external clients expecting plain JSON.
+ *
+ * ## Options
+ *
+ * - `search: string[]`: Allowlist of URL search params the loader depends on. Only listed params are
+ *   sent in the request and changes to other params are ignored. During SSR and loader JSON
+ *   requests, the loader's request event is filtered to those params too. `search: []` means no
+ *   search params are sent and only route path changes trigger a re-fetch.
+ * - `eTag`: Enable ETag-based caching. Can be `true` (auto-hash), a string, or a function.
+ * - `cacheControl`: Cache-Control for loader JSON responses; the browser HTTP cache controls
+ *   client-side freshness. `'immutable'` additionally lets SSG write the loader file.
+ *
+ * The `strictLoaders` Vite plugin option applies `search: []` globally for all loaders that don't
+ * specify an explicit `search` option.
+ *
+ * @public
+ */
 export declare const routeLoader$: LoaderConstructor;
 
+/**
+ * Reactive context for route loaders. On the server this is stored in sharedMap, on the client it's
+ * a store that gets updated on navigation.
+ *
+ * - `loaderPaths`: loader ID → fetch path (the longest route path for that loader)
+ * - `pagePathname` / `pageSearch`: client-only navigation state used for loader invalidation and
+ *   q-loader fetches. They are intentionally omitted from SSR state and fall back to `location`
+ *   until the first SPA navigation.
+ */
+declare type RouteLoaderCtx = {
+    loaderPaths: Record<string, string | undefined>;
+    pagePathname?: string;
+    pageSearch?: string;
+    /** SPA navigation function. Client-only and intentionally omitted from SSR state. */
+    goto?: NoSerialize<RouteNavigate>;
+    /** Client manifest hash for q-loader fetch URLs. */
+    manifestHash?: string;
+    routeLoaderCandidates?: Record<string, string>;
+};
+
 /* Excluded from this release type: routeLoaderQrl */
 
 /** @public */
@@ -665,6 +1108,19 @@ declare interface ServerConfig {
     fetchOptions?: any;
 }
 
+/** @public The server data that is provided by Qwik Router during SSR rendering. It can be retrieved with `useServerData(key)` in the server, but it is not available in the client. */
+export declare type ServerData = {
+    url: string;
+    requestHeaders: Record<string, string>;
+    renderMode: 'static' | 'server';
+    locale: string | undefined;
+    nonce: string | undefined;
+    containerAttributes: Record<string, string> & {
+        [Q_ROUTE]: string;
+    };
+    qwikrouter: QwikRouterEnvData;
+};
+
 /** @public */
 export declare type ServerFunction = {
     (this: RequestEventBase, ...args: any[]): any;
@@ -686,28 +1142,18 @@ export declare type ServerQRL<T extends ServerFunction> = QRL<((abort: AbortSign
  * JS extensions are allowed) will be picked up, bundled into a separate file, and registered as a
  * service worker.
  *
+ * Qwik 1.14.0 and above now use `<link rel="modulepreload">` by default. If you didn't add custom
+ * service-worker logic, you should remove your service-worker.ts file(s) for the
+ * `ServiceWorkerRegister` Component to actually unregister the service-worker.js and delete its
+ * related cache. Make sure to keep the `ServiceWorkerRegister` Component in your app (without any
+ * service-worker.ts file) as long as you want to unregister the service-worker.js for your users.
+ *
  * @public
  */
 export declare const ServiceWorkerRegister: (props: {
     nonce?: string;
 }) => JSXOutput;
 
-/**
- * A signal is a reactive value which can be read and written. When the signal is written, all tasks
- * which are tracking the signal will be re-run and all components that read the signal will be
- * re-rendered.
- *
- * Furthermore, when a signal value is passed as a prop to a component, the optimizer will
- * automatically forward the signal. This means that `return <div title={signal.value}>hi</div>`
- * will update the `title` attribute when the signal changes without having to re-render the
- * component.
- *
- * @public
- */
-declare interface Signal<T = any> extends ReadonlySignal_2<T> {
-    value: T;
-}
-
 /** @public */
 export declare interface StaticGenerate {
     params?: PathParams[];
@@ -744,6 +1190,9 @@ export declare const useContent: () => ContentState;
  */
 export declare const useDocumentHead: <FrontMatter extends Record<string, unknown> = Record<string, any>>() => Required<ResolvedDocumentHead<FrontMatter>>;
 
+/** @public */
+export declare const useHttpStatus: () => HttpErrorProps;
+
 /** @public */
 export declare const useLocation: () => RouteLocation;
 
@@ -788,6 +1237,14 @@ export declare const usePreventNavigate$: (qrl: PreventNavigateCallback) => void
 
 /* Excluded from this release type: usePreventNavigateQrl */
 
+/**
+ * @public
+ * This hook initializes Qwik Router, providing the necessary context for it to work.
+ *
+ * This hook should be used once, at the root of your application.
+ */
+export declare const useQwikRouter: (props?: QwikRouterProps) => void;
+
 /** @beta */
 export declare const valibot$: ValibotConstructor;
 
@@ -860,16 +1317,16 @@ export declare const zod$: ZodConstructor;
 export declare type ZodConstructor = {
     <T extends z_2.ZodRawShape>(schema: T): ZodDataValidator<z_2.ZodObject<T>>;
     <T extends z_2.ZodRawShape>(schema: (zod: typeof z_2.z, ev: RequestEvent) => T): ZodDataValidator<z_2.ZodObject<T>>;
-    <T extends z_2.Schema>(schema: T): ZodDataValidator<T>;
-    <T extends z_2.Schema>(schema: (zod: typeof z_2.z, ev: RequestEvent) => T): ZodDataValidator<T>;
+    <T extends z_2.ZodType>(schema: T): ZodDataValidator<T>;
+    <T extends z_2.ZodType>(schema: (zod: typeof z_2.z, ev: RequestEvent) => T): ZodDataValidator<T>;
 };
 
 /** @public */
 declare type ZodConstructorQRL = {
     <T extends z_2.ZodRawShape>(schema: QRL<T>): ZodDataValidator<z_2.ZodObject<T>>;
     <T extends z_2.ZodRawShape>(schema: QRL<(zod: typeof z_2.z, ev: RequestEvent) => T>): ZodDataValidator<z_2.ZodObject<T>>;
-    <T extends z_2.Schema>(schema: QRL<T>): ZodDataValidator<T>;
-    <T extends z_2.Schema>(schema: QRL<(zod: typeof z_2.z, ev: RequestEvent) => T>): ZodDataValidator<T>;
+    <T extends z_2.ZodType>(schema: QRL<T>): ZodDataValidator<T>;
+    <T extends z_2.ZodType>(schema: QRL<(zod: typeof z_2.z, ev: RequestEvent) => T>): ZodDataValidator<T>;
 };
 
 /** @public */