@analogjs/router 3.0.0-alpha.56 → 3.0.0-alpha.57

package/fesm2022/analogjs-router-server-actions.mjs

@@ -1,335 +1,2 @@
-import { getRequestURL, readBody, readFormData, toRequest } from "nitro/h3";
-//#region packages/router/server/actions/src/actions.ts
-function fail(status, errors) {
-	return new Response(JSON.stringify(errors), {
-		status,
-		headers: { "X-Analog-Errors": "true" }
-	});
-}
-function json(data, config) {
-	return new Response(JSON.stringify(data), {
-		headers: { "Content-Type": "application/json; charset=utf-8" },
-		...config
-	});
-}
-function redirect(url, config = 302) {
-	if (typeof config === "number") return new Response(null, {
-		status: config,
-		headers: { Location: `${url}` }
-	});
-	return new Response(null, {
-		headers: { Location: `${url}` },
-		...config
-	});
-}
-//#endregion
-//#region packages/router/server/actions/src/parse-request-data.ts
-function appendEntry(target, key, value) {
-	const existingValue = target[key];
-	if (existingValue === void 0) {
-		target[key] = value;
-		return;
-	}
-	if (Array.isArray(existingValue)) {
-		existingValue.push(value);
-		return;
-	}
-	target[key] = [existingValue, value];
-}
-function getRequest(event) {
-	const maybeRequest = event.request;
-	if (maybeRequest) return maybeRequest;
-	return toRequest(event);
-}
-function getContentType(event) {
-	return getRequest(event).headers.get("content-type") ?? event.headers.get("content-type") ?? event.headers.get("Content-Type") ?? "";
-}
-function isJsonContentType(contentType) {
-	const mimeType = contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
-	return mimeType === "application/json" || mimeType.endsWith("+json");
-}
-function isFormContentType(contentType) {
-	return contentType.includes("multipart/form-data") || contentType.includes("application/x-www-form-urlencoded");
-}
-function parseSearchParams(searchParams) {
-	const result = {};
-	searchParams.forEach((value, key) => {
-		appendEntry(result, key, value);
-	});
-	return result;
-}
-function parseFormData(formData) {
-	const result = {};
-	formData.forEach((value, key) => {
-		appendEntry(result, key, value);
-	});
-	return result;
-}
-async function parseRequestData(event) {
-	const request = getRequest(event);
-	const httpEvent = event;
-	const h3Event = event;
-	const method = event.method.toUpperCase();
-	if (method === "GET" || method === "HEAD") return parseSearchParams(new URL(request.url, "http://localhost").searchParams);
-	const contentType = getContentType(event);
-	if (isJsonContentType(contentType)) try {
-		return await readBody(httpEvent) ?? {};
-	} catch {
-		try {
-			return await request.json();
-		} catch {
-			return {};
-		}
-	}
-	if (isFormContentType(contentType)) try {
-		return parseFormData(await readFormData(h3Event));
-	} catch {
-		if (typeof request.formData === "function") return parseFormData(await request.formData());
-		return {};
-	}
-	try {
-		return await readBody(httpEvent) ?? {};
-	} catch {
-		try {
-			return await request.json();
-		} catch {
-			return {};
-		}
-	}
-}
-//#endregion
-//#region packages/router/server/actions/src/validate.ts
-/**
-* Validates unknown input against a Standard Schema.
-*
-* Handles both sync and async `validate` implementations — the Standard
-* Schema spec allows either return shape.
-*/
-async function validateWithSchema(schema, data) {
-	return schema["~standard"].validate(data);
-}
-//#endregion
-//#region packages/router/server/actions/src/define-action.ts
-/**
-* Creates a server action handler with Standard Schema input validation.
-*
-* Parses the request body (JSON or FormData) and validates it against the
-* provided schema before invoking the handler. On validation failure,
-* returns `fail(422, issues)` with `StandardSchemaV1.Issue[]`.
-* Repeated form fields are preserved as arrays instead of being collapsed
-* to the last value.
-*
-* @example
-* ```typescript
-* import { defineAction, json } from '@analogjs/router/server/actions';
-* import * as v from 'valibot';
-*
-* const Schema = v.object({
-*   email: v.pipe(v.string(), v.email()),
-* });
-*
-* export const action = defineAction({
-*   schema: Schema,
-*   handler: async ({ data }) => {
-*     // data is typed as { email: string }
-*     return json({ ok: true });
-*   },
-* });
-* ```
-*/
-function defineAction(options) {
-	function getParams(params) {
-		return params ?? {};
-	}
-	return async (ctx) => {
-		const rawParams = getParams(ctx.params);
-		if (options.params) {
-			const paramsResult = await validateWithSchema(options.params, rawParams);
-			if (paramsResult.issues) return fail(422, paramsResult.issues);
-			return handleValidatedRequest(ctx, options, paramsResult.value);
-		}
-		return handleValidatedRequest(ctx, options, rawParams);
-	};
-}
-async function handleValidatedRequest(ctx, options, params) {
-	const body = await parseRequestData(ctx.event);
-	let data = body;
-	if (options.schema) {
-		const result = await validateWithSchema(options.schema, body);
-		if (result.issues) return fail(422, result.issues);
-		data = result.value;
-	}
-	return options.handler({
-		data,
-		params,
-		req: ctx.req,
-		res: ctx.res,
-		fetch: ctx.fetch,
-		event: ctx.event
-	});
-}
-//#endregion
-//#region packages/router/server/actions/src/define-server-route.ts
-function isDevEnvironment() {
-	return typeof process !== "undefined" && (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test");
-}
-function warnOnOutputIssues(issues) {
-	console.warn(`[analog] Server route output validation failed:\n` + issues.map((i) => {
-		const path = i.path ? ` at "${i.path.map((p) => typeof p === "object" ? p.key : p).join(".")}"` : "";
-		return `  - ${i.message}${path}`;
-	}).join("\n"));
-}
-function getRequestUrl(event) {
-	try {
-		return getRequestURL(event).href;
-	} catch {
-		return event.request.url;
-	}
-}
-/**
-* 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;
-*   },
-* });
-* ```
-*/
-function defineServerRoute(options) {
-	return (async (event) => {
-		const method = event.method.toUpperCase();
-		let data;
-		let query;
-		let body;
-		let params = event.context?.params ?? {};
-		if (options.params) {
-			const paramsResult = await validateWithSchema(options.params, params);
-			if (paramsResult.issues) return fail(422, paramsResult.issues);
-			params = paramsResult.value;
-		}
-		if (options.input) {
-			data = await parseRequestData(event);
-			const inputResult = await validateWithSchema(options.input, data);
-			if (inputResult.issues) return fail(422, inputResult.issues);
-			data = inputResult.value;
-		} else {
-			if (options.query) {
-				const url = new URL(getRequestUrl(event), "http://localhost");
-				const queryResult = await validateWithSchema(options.query, parseSearchParams(url.searchParams));
-				if (queryResult.issues) return fail(422, queryResult.issues);
-				query = queryResult.value;
-			}
-			if (options.body && method !== "GET" && method !== "HEAD") {
-				body = await parseRequestData(event);
-				const bodyResult = await validateWithSchema(options.body, body);
-				if (bodyResult.issues) return fail(422, bodyResult.issues);
-				body = bodyResult.value;
-			}
-			if (method === "GET" || method === "HEAD") data = query;
-			else if (body !== void 0) data = body;
-			else data = query;
-		}
-		const result = await options.handler({
-			data,
-			query,
-			body,
-			params,
-			event
-		});
-		if (result instanceof Response) return result;
-		if (options.output && isDevEnvironment()) {
-			const outputResult = await validateWithSchema(options.output, result);
-			if (outputResult.issues) warnOnOutputIssues(outputResult.issues);
-		}
-		return json(result);
-	});
-}
-//#endregion
-//#region packages/router/server/actions/src/define-page-load.ts
-/**
-* Creates a typed page server load function with optional
-* Standard Schema validation for route params and query.
-*
-* Follows the same validation patterns as `defineAction` and
-* `defineServerRoute`: validates before invoking the handler,
-* returns `fail(422, issues)` on validation failure.
-*
-* @example
-* ```typescript
-* // src/app/pages/users/[id].server.ts
-* import { definePageLoad } from '@analogjs/router/server/actions';
-* import * as v from 'valibot';
-*
-* export const routeParamsSchema = v.object({
-*   id: v.pipe(v.string(), v.regex(/^\d+$/)),
-* });
-*
-* export const load = definePageLoad({
-*   params: routeParamsSchema,
-*   handler: async ({ params, fetch }) => {
-*     // params.id is typed as string (validated)
-*     const user = await fetch(`/api/users/${params.id}`);
-*     return user;
-*   },
-* });
-* ```
-*/
-function definePageLoad(options) {
-	return async (ctx) => {
-		let params = ctx.params ?? {};
-		let requestUrl;
-		try {
-			requestUrl = getRequestURL(ctx.event).href;
-		} catch {
-			requestUrl = ctx.event.request.url;
-		}
-		let query = parseSearchParams(new URL(requestUrl, "http://localhost").searchParams);
-		if (options.params) {
-			const result = await validateWithSchema(options.params, params);
-			if (result.issues) return fail(422, result.issues);
-			params = result.value;
-		}
-		if (options.query) {
-			const result = await validateWithSchema(options.query, query);
-			if (result.issues) return fail(422, result.issues);
-			query = result.value;
-		}
-		return options.handler({
-			params,
-			query,
-			req: ctx.req,
-			res: ctx.res,
-			fetch: ctx.fetch,
-			event: ctx.event
-		});
-	};
-}
-//#endregion
+import { a as fail, i as validateWithSchema, n as defineServerRoute, o as json, r as defineAction, s as redirect, t as definePageLoad } from "./src.mjs";
 export { defineAction, definePageLoad, defineServerRoute, fail, json, redirect, validateWithSchema };
-
-//# sourceMappingURL=analogjs-router-server-actions.mjs.map

package/fesm2022/analogjs-router-tanstack-query-server.mjs

@@ -1,22 +1,71 @@
-import { t as ANALOG_QUERY_STATE_KEY } from "./provide-analog-query.mjs";
-import { TransferState, makeEnvironmentProviders } from "@angular/core";
+import { r as ANALOG_QUERIES_KEY, t as ANALOG_QUERY_STATE_KEY } from "./provide-analog-query.mjs";
+import { t as definePageLoad } from "./src.mjs";
+import { ApplicationRef, ENVIRONMENT_INITIALIZER, TransferState, inject, makeEnvironmentProviders } from "@angular/core";
+import { filter, skipWhile, take } from "rxjs/operators";
 import { QueryClient, dehydrate } from "@tanstack/angular-query-experimental";
-import { BEFORE_APP_SERIALIZED } from "@angular/platform-server";
 //#region packages/router/tanstack-query/src/provide-server-analog-query.ts
-var SERVER_ANALOG_QUERY_PROVIDER = {
-	provide: BEFORE_APP_SERIALIZED,
-	multi: true,
-	useFactory: (queryClient, transferState) => {
-		return () => {
-			transferState.set(ANALOG_QUERY_STATE_KEY, dehydrate(queryClient));
-		};
-	},
-	deps: [QueryClient, TransferState]
-};
 function provideServerAnalogQuery() {
-	return makeEnvironmentProviders([SERVER_ANALOG_QUERY_PROVIDER]);
+	return makeEnvironmentProviders([{
+		provide: ENVIRONMENT_INITIALIZER,
+		multi: true,
+		useValue() {
+			const appRef = inject(ApplicationRef);
+			const queryClient = inject(QueryClient);
+			const transferState = inject(TransferState);
+			const subscription = appRef.isStable.pipe(skipWhile((stable) => stable), filter((stable) => stable), take(1)).subscribe(() => {
+				transferState.set(ANALOG_QUERY_STATE_KEY, dehydrate(queryClient));
+			});
+			appRef.onDestroy(() => subscription.unsubscribe());
+		}
+	}]);
 }
 //#endregion
-export { provideServerAnalogQuery };
+//#region packages/router/tanstack-query/server/src/define-page-load-queries.ts
+/**
+* Page load helper that prefetches TanStack Query queries inside the
+* `.server.ts` handler and ships the dehydrated cache alongside any
+* additional data. The router-side hydrator in `provideAnalogQuery()`
+* merges the dehydrated payload into the active `QueryClient` on
+* `ResolveEnd`, so components reading the same query options see a
+* warm cache on first render.
+*
+* @example
+* ```ts
+* // src/app/pages/posts.server.ts
+* import { definePageLoadQueries } from '@analogjs/router/tanstack-query/server';
+* import { queryOptions } from '@tanstack/angular-query-experimental';
+*
+* export const postsQuery = queryOptions({
+*   queryKey: ['posts'],
+*   queryFn: async ({ signal }) =>
+*     fetch('https://api.example.com/posts', { signal }).then((r) => r.json()),
+* });
+*
+* export const load = definePageLoadQueries({
+*   handler: async ({ client }) => {
+*     await client.prefetchQuery(postsQuery);
+*   },
+* });
+* ```
+*/
+function definePageLoadQueries(options) {
+	return definePageLoad({
+		params: options.params,
+		query: options.query,
+		handler: async (ctx) => {
+			const client = options.client?.() ?? new QueryClient();
+			const data = await options.handler({
+				...ctx,
+				client
+			});
+			return {
+				[ANALOG_QUERIES_KEY]: dehydrate(client),
+				data
+			};
+		}
+	});
+}
+//#endregion
+export { ANALOG_QUERIES_KEY, definePageLoadQueries, provideServerAnalogQuery };
 
 //# sourceMappingURL=analogjs-router-tanstack-query-server.mjs.map

package/fesm2022/analogjs-router-tanstack-query-server.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"analogjs-router-tanstack-query-server.mjs","names":[],"sources":["../../tanstack-query/src/provide-server-analog-query.ts"],"sourcesContent":["import { TransferState, makeEnvironmentProviders } from '@angular/core';\nimport type { EnvironmentProviders, Provider } from '@angular/core';\nimport { BEFORE_APP_SERIALIZED } from '@angular/platform-server';\nimport { QueryClient, dehydrate } from '@tanstack/angular-query-experimental';\n\nimport { ANALOG_QUERY_STATE_KEY } from './provide-analog-query';\n\nconst SERVER_ANALOG_QUERY_PROVIDER: Provider = {\n  provide: BEFORE_APP_SERIALIZED,\n  multi: true,\n  useFactory: (queryClient: QueryClient, transferState: TransferState) => {\n    return () => {\n      transferState.set(ANALOG_QUERY_STATE_KEY, dehydrate(queryClient));\n    };\n  },\n  deps: [QueryClient, TransferState],\n};\n\nexport function provideServerAnalogQuery(): EnvironmentProviders {\n  return makeEnvironmentProviders([SERVER_ANALOG_QUERY_PROVIDER]);\n}\n"],"mappings":";;;;;AAOA,IAAM,+BAAyC;CAC7C,SAAS;CACT,OAAO;CACP,aAAa,aAA0B,kBAAiC;AACtE,eAAa;AACX,iBAAkB,IAAA,wBAAwB,UAAU,YAAa,CAAA;;;CAGrE,MAAO,CAAA,aAAa,cAAA;CACrB;AAED,SAAgB,2BAAiD;AAC/D,QAAO,yBAA0B,CAAA,6BAA8B,CAAA"}
+{"version":3,"file":"analogjs-router-tanstack-query-server.mjs","names":[],"sources":["../../tanstack-query/src/provide-server-analog-query.ts","../../tanstack-query/server/src/define-page-load-queries.ts"],"sourcesContent":["import {\n  ApplicationRef,\n  ENVIRONMENT_INITIALIZER,\n  TransferState,\n  inject,\n  makeEnvironmentProviders,\n} from '@angular/core';\nimport type { EnvironmentProviders } from '@angular/core';\nimport { filter, skipWhile, take } from 'rxjs/operators';\nimport { QueryClient, dehydrate } from '@tanstack/angular-query-experimental';\n\nimport { ANALOG_QUERY_STATE_KEY } from './provide-analog-query';\n\nexport function provideServerAnalogQuery(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {\n      provide: ENVIRONMENT_INITIALIZER,\n      multi: true,\n      useValue() {\n        // Dehydrate the QueryClient into `TransferState` once the app\n        // becomes stable POST-RENDER on the server. `renderApplication`\n        // awaits `whenStable()` itself before invoking\n        // `BEFORE_APP_SERIALIZED` (which is where Angular's\n        // `TRANSFER_STATE_SERIALIZATION_PROVIDERS` reads the store and\n        // writes the `ng-state` script). Settling our write at the same\n        // point — but ahead of Angular's own subscriber — lets the\n        // dehydrated cache land in `TransferState` before the serializer\n        // snapshots it, so component-issued queries make it to the client\n        // without depending on provider declaration order.\n        //\n        // `skipWhile(stable => stable)` waits past the initial \"no\n        // pending tasks yet\" emission `BehaviorSubject` semantics give\n        // us at subscribe time; the next stable transition is the\n        // post-render one with all queries settled.\n        const appRef = inject(ApplicationRef);\n        const queryClient = inject(QueryClient);\n        const transferState = inject(TransferState);\n\n        const subscription = appRef.isStable\n          .pipe(\n            skipWhile((stable) => stable),\n            filter((stable) => stable),\n            take(1),\n          )\n          .subscribe(() => {\n            transferState.set(ANALOG_QUERY_STATE_KEY, dehydrate(queryClient));\n          });\n\n        appRef.onDestroy(() => subscription.unsubscribe());\n      },\n    },\n  ]);\n}\n","import type { StandardSchemaV1 } from '@standard-schema/spec';\nimport { QueryClient, dehydrate } from '@tanstack/angular-query-experimental';\nimport type { DehydratedState } from '@tanstack/angular-query-experimental';\nimport type { H3Event, H3EventContext } from 'nitro/h3';\nimport type { $Fetch } from 'nitro/types';\n\nimport {\n  definePageLoad,\n  type PageLoadContext,\n} from '../../../server/actions/src/index.js';\nimport { ANALOG_QUERIES_KEY } from '../../src/constants.js';\n\nexport { ANALOG_QUERIES_KEY } from '../../src/constants.js';\n\ntype NodeContext = NonNullable<H3Event['node']>;\ntype OptionalSchema = StandardSchemaV1 | undefined;\n\nexport interface PageLoadQueriesResult<TData> {\n  __analogQueries: DehydratedState;\n  data: TData;\n}\n\nexport interface DefinePageLoadQueriesOptions<\n  TParamsSchema extends OptionalSchema,\n  TQuerySchema extends OptionalSchema,\n  TData,\n> {\n  params?: TParamsSchema;\n  query?: TQuerySchema;\n  /**\n   * Optional QueryClient factory. Defaults to `new QueryClient()`.\n   * Override to set `defaultOptions` (e.g. `queries: { staleTime: Infinity }`).\n   */\n  client?: () => QueryClient;\n  /**\n   * Handler receives the standard PageLoadContext plus a per-request\n   * QueryClient. Use `client.prefetchQuery` / `ensureQueryData` /\n   * `prefetchInfiniteQuery` to warm the cache; the dehydrated client\n   * is returned as `__analogQueries` on the load result. Anything you\n   * return from the handler becomes `data` on the same result.\n   */\n  handler: (\n    ctx: PageLoadContext<TParamsSchema, TQuerySchema> & { client: QueryClient },\n  ) => Promise<TData> | TData;\n}\n\n/**\n * Page load helper that prefetches TanStack Query queries inside the\n * `.server.ts` handler and ships the dehydrated cache alongside any\n * additional data. The router-side hydrator in `provideAnalogQuery()`\n * merges the dehydrated payload into the active `QueryClient` on\n * `ResolveEnd`, so components reading the same query options see a\n * warm cache on first render.\n *\n * @example\n * ```ts\n * // src/app/pages/posts.server.ts\n * import { definePageLoadQueries } from '@analogjs/router/tanstack-query/server';\n * import { queryOptions } from '@tanstack/angular-query-experimental';\n *\n * export const postsQuery = queryOptions({\n *   queryKey: ['posts'],\n *   queryFn: async ({ signal }) =>\n *     fetch('https://api.example.com/posts', { signal }).then((r) => r.json()),\n * });\n *\n * export const load = definePageLoadQueries({\n *   handler: async ({ client }) => {\n *     await client.prefetchQuery(postsQuery);\n *   },\n * });\n * ```\n */\nexport function definePageLoadQueries<\n  TParamsSchema extends OptionalSchema = undefined,\n  TQuerySchema extends OptionalSchema = undefined,\n  TData = void,\n>(\n  options: DefinePageLoadQueriesOptions<TParamsSchema, TQuerySchema, TData>,\n): (ctx: {\n  params: H3EventContext['params'];\n  req: NodeContext['req'];\n  res: NonNullable<NodeContext['res']>;\n  fetch: $Fetch;\n  event: H3Event;\n}) => Promise<PageLoadQueriesResult<TData> | Response> {\n  return definePageLoad({\n    params: options.params,\n    query: options.query,\n    handler: async (ctx): Promise<PageLoadQueriesResult<TData>> => {\n      const client = options.client?.() ?? new QueryClient();\n      const data = await options.handler({ ...ctx, client });\n      return {\n        [ANALOG_QUERIES_KEY]: dehydrate(client),\n        data,\n      };\n    },\n  });\n}\n"],"mappings":";;;;;;AAaA,SAAgB,2BAAiD;AAC/D,QAAO,yBACL,CACE;EACO,SAAA;EACP,OAAW;EAgBH,WAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACuCvB,SAAgB,sBAKd,SAOqD;AACrD,QAAO,eAAe;EACpB,QAAQ,QAAQ;EAChB,OAAO,QAAQ;EACf,SAAS,OAAO,QAA+C;GACvD,MAAS,SAAQ,QAAA,UAAkB,IAAA,IAAA,aAAa;GAChD,MAAO,OAAM,MAAQ,QAAQ,QAAA;IAAA,GAAA;IAAA;IAAA,CAAA;AAAK,UAAA;KAAK,qBAAA,UAAA,OAAA;IAAS;IAC/C;;EAEL,CAAA"}

package/fesm2022/provide-analog-query.mjs

@@ -1,5 +1,18 @@
-import { ENVIRONMENT_INITIALIZER, TransferState, inject, makeEnvironmentProviders, makeStateKey } from "@angular/core";
+import { ResolveEnd, Router } from "@angular/router";
+import { DestroyRef, ENVIRONMENT_INITIALIZER, PLATFORM_ID, TransferState, inject, makeEnvironmentProviders, makeStateKey } from "@angular/core";
+import { isPlatformServer } from "@angular/common";
 import { QueryClient, hydrate } from "@tanstack/angular-query-experimental";
+//#region packages/router/tanstack-query/src/constants.ts
+/**
+* Route-data key under `ActivatedRoute.data['load']` that holds the
+* `DehydratedState` produced by `definePageLoadQueries`. The Router-
+* events hydrator in `provideAnalogQuery()` looks for this key on
+* `ResolveEnd` and merges the dehydrated payload into the active
+* `QueryClient`, so component-issued queries hit a warm cache on
+* first render.
+*/
+var ANALOG_QUERIES_KEY = "__analogQueries";
+//#endregion
 //#region packages/router/tanstack-query/src/provide-analog-query.ts
 var ANALOG_QUERY_STATE_KEY = makeStateKey("analog_query_state");
 function provideAnalogQuery() {
@@ -15,9 +28,45 @@ function provideAnalogQuery() {
 				transferState.remove(ANALOG_QUERY_STATE_KEY);
 			}
 		}
+	}, {
+		provide: ENVIRONMENT_INITIALIZER,
+		multi: true,
+		useValue() {
+			const router = inject(Router, { optional: true });
+			if (!router) return;
+			const client = inject(QueryClient);
+			const destroyRef = inject(DestroyRef);
+			const transferState = isPlatformServer(inject(PLATFORM_ID)) ? inject(TransferState) : null;
+			const subscription = router.events.subscribe((event) => {
+				if (event instanceof ResolveEnd) mergeRouteSnapshot(event.state.root, client, transferState);
+			});
+			destroyRef.onDestroy(() => subscription.unsubscribe());
+		}
 	}]);
 }
+function mergeRouteSnapshot(snapshot, client, transferState) {
+	const load = snapshot.data?.["load"];
+	if (load && typeof load === "object" && "__analogQueries" in load) {
+		const dehydrated = load[ANALOG_QUERIES_KEY];
+		if (dehydrated) {
+			hydrate(client, dehydrated);
+			if (transferState) {
+				const existing = transferState.get(ANALOG_QUERY_STATE_KEY, null);
+				transferState.set(ANALOG_QUERY_STATE_KEY, existing ? mergeDehydrated(existing, dehydrated) : dehydrated);
+			}
+		}
+	}
+	for (const child of snapshot.children) mergeRouteSnapshot(child, client, transferState);
+}
+function mergeDehydrated(base, next) {
+	const queriesByHash = new Map(base.queries.map((query) => [query.queryHash, query]));
+	for (const query of next.queries) queriesByHash.set(query.queryHash, query);
+	return {
+		mutations: [...base.mutations, ...next.mutations],
+		queries: [...queriesByHash.values()]
+	};
+}
 //#endregion
-export { provideAnalogQuery as n, ANALOG_QUERY_STATE_KEY as t };
+export { provideAnalogQuery as n, ANALOG_QUERIES_KEY as r, ANALOG_QUERY_STATE_KEY as t };
 
 //# sourceMappingURL=provide-analog-query.mjs.map

package/fesm2022/provide-analog-query.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"provide-analog-query.mjs","names":[],"sources":["../../tanstack-query/src/provide-analog-query.ts"],"sourcesContent":["import {\n  ENVIRONMENT_INITIALIZER,\n  TransferState,\n  inject,\n  makeEnvironmentProviders,\n  makeStateKey,\n} from '@angular/core';\nimport type { EnvironmentProviders, StateKey } from '@angular/core';\nimport { QueryClient, hydrate } from '@tanstack/angular-query-experimental';\nimport type { DehydratedState } from '@tanstack/angular-query-experimental';\n\nexport const ANALOG_QUERY_STATE_KEY: StateKey<DehydratedState> =\n  makeStateKey<DehydratedState>('analog_query_state');\n\nexport function provideAnalogQuery(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {\n      provide: ENVIRONMENT_INITIALIZER,\n      multi: true,\n      useValue() {\n        if (import.meta.env.SSR) {\n          return;\n        }\n\n        const transferState = inject(TransferState);\n        const client = inject(QueryClient);\n        const dehydratedState = transferState.get<DehydratedState | null>(\n          ANALOG_QUERY_STATE_KEY,\n          null,\n        );\n\n        if (dehydratedState) {\n          hydrate(client, dehydratedState);\n          transferState.remove(ANALOG_QUERY_STATE_KEY);\n        }\n      },\n    },\n  ]);\n}\n"],"mappings":";;;AAWA,IAAa,yBACX,aAA8B,qBAAqB;AAErD,SAAgB,qBAA2C;AACzD,QAAO,yBACL,CACE;EACO,SAAA;EACP,OAAW;EACL,WAAgB;GAKd,MAAS,gBAAmB,OAAA,cAAA;GAC5B,MAAA,SAAkB,OAAA,YACtB;GAIE,MAAA,kBAAiB,cAAA,IAAA,wBAAA,KAAA;AACX,OAAQ,iBAAgB;AAClB,YAAO,QAAA,gBAAuB"}
+{"version":3,"file":"provide-analog-query.mjs","names":[],"sources":["../../tanstack-query/src/constants.ts","../../tanstack-query/src/provide-analog-query.ts"],"sourcesContent":["/**\n * Route-data key under `ActivatedRoute.data['load']` that holds the\n * `DehydratedState` produced by `definePageLoadQueries`. The Router-\n * events hydrator in `provideAnalogQuery()` looks for this key on\n * `ResolveEnd` and merges the dehydrated payload into the active\n * `QueryClient`, so component-issued queries hit a warm cache on\n * first render.\n */\nexport const ANALOG_QUERIES_KEY: '__analogQueries' = '__analogQueries';\n","import {\n  DestroyRef,\n  ENVIRONMENT_INITIALIZER,\n  PLATFORM_ID,\n  TransferState,\n  inject,\n  makeEnvironmentProviders,\n  makeStateKey,\n} from '@angular/core';\nimport type { EnvironmentProviders, StateKey } from '@angular/core';\nimport { isPlatformServer } from '@angular/common';\nimport { ResolveEnd, Router } from '@angular/router';\nimport type { ActivatedRouteSnapshot } from '@angular/router';\nimport { QueryClient, hydrate } from '@tanstack/angular-query-experimental';\nimport type { DehydratedState } from '@tanstack/angular-query-experimental';\n\nimport { ANALOG_QUERIES_KEY } from './constants.js';\n\nexport const ANALOG_QUERY_STATE_KEY: StateKey<DehydratedState> =\n  makeStateKey<DehydratedState>('analog_query_state');\n\nexport function provideAnalogQuery(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {\n      provide: ENVIRONMENT_INITIALIZER,\n      multi: true,\n      useValue() {\n        if (import.meta.env.SSR) {\n          return;\n        }\n\n        const transferState = inject(TransferState);\n        const client = inject(QueryClient);\n        const dehydratedState = transferState.get<DehydratedState | null>(\n          ANALOG_QUERY_STATE_KEY,\n          null,\n        );\n\n        if (dehydratedState) {\n          hydrate(client, dehydratedState);\n          transferState.remove(ANALOG_QUERY_STATE_KEY);\n        }\n      },\n    },\n    {\n      provide: ENVIRONMENT_INITIALIZER,\n      multi: true,\n      useValue() {\n        const router = inject(Router, { optional: true });\n        if (!router) {\n          return;\n        }\n\n        const client = inject(QueryClient);\n        const destroyRef = inject(DestroyRef);\n        // On the server, also mirror any dehydrated load payloads into\n        // `TransferState` so Angular's own serializer can include them in\n        // the `ng-state` script — we can't rely on\n        // `provideServerAnalogQuery()`'s `BEFORE_APP_SERIALIZED` running\n        // before Angular's `TRANSFER_STATE_SERIALIZATION_PROVIDERS`.\n        const transferState = isPlatformServer(inject(PLATFORM_ID))\n          ? inject(TransferState)\n          : null;\n\n        const subscription = router.events.subscribe((event) => {\n          if (event instanceof ResolveEnd) {\n            mergeRouteSnapshot(event.state.root, client, transferState);\n          }\n        });\n\n        destroyRef.onDestroy(() => subscription.unsubscribe());\n      },\n    },\n  ]);\n}\n\nfunction mergeRouteSnapshot(\n  snapshot: ActivatedRouteSnapshot,\n  client: QueryClient,\n  transferState: TransferState | null,\n): void {\n  const load = snapshot.data?.['load'];\n  if (load && typeof load === 'object' && ANALOG_QUERIES_KEY in load) {\n    const dehydrated = (load as Record<string, unknown>)[ANALOG_QUERIES_KEY] as\n      | DehydratedState\n      | undefined;\n    if (dehydrated) {\n      hydrate(client, dehydrated);\n      if (transferState) {\n        const existing = transferState.get<DehydratedState | null>(\n          ANALOG_QUERY_STATE_KEY,\n          null,\n        );\n        transferState.set(\n          ANALOG_QUERY_STATE_KEY,\n          existing ? mergeDehydrated(existing, dehydrated) : dehydrated,\n        );\n      }\n    }\n  }\n  for (const child of snapshot.children) {\n    mergeRouteSnapshot(child, client, transferState);\n  }\n}\n\nfunction mergeDehydrated(\n  base: DehydratedState,\n  next: DehydratedState,\n): DehydratedState {\n  // Last-writer-wins on duplicate `queryHash`: child route resolves run\n  // after parent resolves, so the later entry is the fresher one and\n  // matches `hydrate()`'s own newer-wins semantics for the QueryClient.\n  const queriesByHash = new Map(\n    base.queries.map((query) => [query.queryHash, query]),\n  );\n  for (const query of next.queries) {\n    queriesByHash.set(query.queryHash, query);\n  }\n  return {\n    mutations: [...base.mutations, ...next.mutations],\n    queries: [...queriesByHash.values()],\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAQA,IAAa,qBAAwC;;;ACUrD,IAAa,yBACX,aAA8B,qBAAqB;AAErD,SAAgB,qBAA2C;AACzD,QAAO,yBACL,CACE;EACO,SAAA;EACP,OAAW;EACL,WAAgB;GAKd,MAAS,gBAAmB,OAAA,cAAA;GAC5B,MAAA,SAAkB,OAAA,YACtB;GAIE,MAAA,kBAAiB,cAAA,IAAA,wBAAA,KAAA;AACX,OAAQ,iBAAgB;AAClB,YAAO,QAAA,gBAAuB;;;;EAKhD,EACA;EACA,SAAW;EACH,OAAS;EACV,WAAQ;GACX,MAAA,SAAA,OAAA,QAAA,EAAA,UAAA,MAAA,CAAA;eAGa;GAOT,MAAA,SAAgB,OAAA,YAAwB;GAIxC,MAAA,aAAsB,OAAO,WAAW;iEASlD,OAAA,cAAA,GAAA;GAGK,MAAA,eACP,OACA,OACA,WACM,UAAA;AACO,QAAS,iBAAO,WACV,oBAAqB,MAAA,MAAA,MAAA,QAA4B,cAAA;KAIlD;AACN,cAAQ,gBAAW,aAAA,aAAA,CAAA;;EAEzB,CAIA,CAAA;;;;AAON,KAAK,QAAM,OAAS,SAAS,YAAA,qBAAU,MAAA;EACrC,MAAA,aAAmB,KAAO;;;AAIrB,OAAA,eAEP;IAKM,MAAA,WACJ,cAAa,IAAK,wBAAiB,KAAW;AAErC,kBAAc,IAAA,wBAAS,WAAA,gBAAA,UAAA,WAAA,GAAA,WAAA;;;;AAIhC,MAAA,MAAY,SAAQ,SAAW,SAC/B,oBAAa,OAAc,QAAQ,cAAA"}

package/fesm2022/src.mjs

@@ -0,0 +1,335 @@
+import { getRequestURL, readBody, readFormData, toRequest } from "nitro/h3";
+//#region packages/router/server/actions/src/actions.ts
+function fail(status, errors) {
+	return new Response(JSON.stringify(errors), {
+		status,
+		headers: { "X-Analog-Errors": "true" }
+	});
+}
+function json(data, config) {
+	return new Response(JSON.stringify(data), {
+		headers: { "Content-Type": "application/json; charset=utf-8" },
+		...config
+	});
+}
+function redirect(url, config = 302) {
+	if (typeof config === "number") return new Response(null, {
+		status: config,
+		headers: { Location: `${url}` }
+	});
+	return new Response(null, {
+		headers: { Location: `${url}` },
+		...config
+	});
+}
+//#endregion
+//#region packages/router/server/actions/src/parse-request-data.ts
+function appendEntry(target, key, value) {
+	const existingValue = target[key];
+	if (existingValue === void 0) {
+		target[key] = value;
+		return;
+	}
+	if (Array.isArray(existingValue)) {
+		existingValue.push(value);
+		return;
+	}
+	target[key] = [existingValue, value];
+}
+function getRequest(event) {
+	const maybeRequest = event.request;
+	if (maybeRequest) return maybeRequest;
+	return toRequest(event);
+}
+function getContentType(event) {
+	return getRequest(event).headers.get("content-type") ?? event.headers.get("content-type") ?? event.headers.get("Content-Type") ?? "";
+}
+function isJsonContentType(contentType) {
+	const mimeType = contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+	return mimeType === "application/json" || mimeType.endsWith("+json");
+}
+function isFormContentType(contentType) {
+	return contentType.includes("multipart/form-data") || contentType.includes("application/x-www-form-urlencoded");
+}
+function parseSearchParams(searchParams) {
+	const result = {};
+	searchParams.forEach((value, key) => {
+		appendEntry(result, key, value);
+	});
+	return result;
+}
+function parseFormData(formData) {
+	const result = {};
+	formData.forEach((value, key) => {
+		appendEntry(result, key, value);
+	});
+	return result;
+}
+async function parseRequestData(event) {
+	const request = getRequest(event);
+	const httpEvent = event;
+	const h3Event = event;
+	const method = event.method.toUpperCase();
+	if (method === "GET" || method === "HEAD") return parseSearchParams(new URL(request.url, "http://localhost").searchParams);
+	const contentType = getContentType(event);
+	if (isJsonContentType(contentType)) try {
+		return await readBody(httpEvent) ?? {};
+	} catch {
+		try {
+			return await request.json();
+		} catch {
+			return {};
+		}
+	}
+	if (isFormContentType(contentType)) try {
+		return parseFormData(await readFormData(h3Event));
+	} catch {
+		if (typeof request.formData === "function") return parseFormData(await request.formData());
+		return {};
+	}
+	try {
+		return await readBody(httpEvent) ?? {};
+	} catch {
+		try {
+			return await request.json();
+		} catch {
+			return {};
+		}
+	}
+}
+//#endregion
+//#region packages/router/server/actions/src/validate.ts
+/**
+* Validates unknown input against a Standard Schema.
+*
+* Handles both sync and async `validate` implementations — the Standard
+* Schema spec allows either return shape.
+*/
+async function validateWithSchema(schema, data) {
+	return schema["~standard"].validate(data);
+}
+//#endregion
+//#region packages/router/server/actions/src/define-action.ts
+/**
+* Creates a server action handler with Standard Schema input validation.
+*
+* Parses the request body (JSON or FormData) and validates it against the
+* provided schema before invoking the handler. On validation failure,
+* returns `fail(422, issues)` with `StandardSchemaV1.Issue[]`.
+* Repeated form fields are preserved as arrays instead of being collapsed
+* to the last value.
+*
+* @example
+* ```typescript
+* import { defineAction, json } from '@analogjs/router/server/actions';
+* import * as v from 'valibot';
+*
+* const Schema = v.object({
+*   email: v.pipe(v.string(), v.email()),
+* });
+*
+* export const action = defineAction({
+*   schema: Schema,
+*   handler: async ({ data }) => {
+*     // data is typed as { email: string }
+*     return json({ ok: true });
+*   },
+* });
+* ```
+*/
+function defineAction(options) {
+	function getParams(params) {
+		return params ?? {};
+	}
+	return async (ctx) => {
+		const rawParams = getParams(ctx.params);
+		if (options.params) {
+			const paramsResult = await validateWithSchema(options.params, rawParams);
+			if (paramsResult.issues) return fail(422, paramsResult.issues);
+			return handleValidatedRequest(ctx, options, paramsResult.value);
+		}
+		return handleValidatedRequest(ctx, options, rawParams);
+	};
+}
+async function handleValidatedRequest(ctx, options, params) {
+	const body = await parseRequestData(ctx.event);
+	let data = body;
+	if (options.schema) {
+		const result = await validateWithSchema(options.schema, body);
+		if (result.issues) return fail(422, result.issues);
+		data = result.value;
+	}
+	return options.handler({
+		data,
+		params,
+		req: ctx.req,
+		res: ctx.res,
+		fetch: ctx.fetch,
+		event: ctx.event
+	});
+}
+//#endregion
+//#region packages/router/server/actions/src/define-server-route.ts
+function isDevEnvironment() {
+	return typeof process !== "undefined" && (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test");
+}
+function warnOnOutputIssues(issues) {
+	console.warn(`[analog] Server route output validation failed:\n` + issues.map((i) => {
+		const path = i.path ? ` at "${i.path.map((p) => typeof p === "object" ? p.key : p).join(".")}"` : "";
+		return `  - ${i.message}${path}`;
+	}).join("\n"));
+}
+function getRequestUrl(event) {
+	try {
+		return getRequestURL(event).href;
+	} catch {
+		return event.request.url;
+	}
+}
+/**
+* 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;
+*   },
+* });
+* ```
+*/
+function defineServerRoute(options) {
+	return (async (event) => {
+		const method = event.method.toUpperCase();
+		let data;
+		let query;
+		let body;
+		let params = event.context?.params ?? {};
+		if (options.params) {
+			const paramsResult = await validateWithSchema(options.params, params);
+			if (paramsResult.issues) return fail(422, paramsResult.issues);
+			params = paramsResult.value;
+		}
+		if (options.input) {
+			data = await parseRequestData(event);
+			const inputResult = await validateWithSchema(options.input, data);
+			if (inputResult.issues) return fail(422, inputResult.issues);
+			data = inputResult.value;
+		} else {
+			if (options.query) {
+				const url = new URL(getRequestUrl(event), "http://localhost");
+				const queryResult = await validateWithSchema(options.query, parseSearchParams(url.searchParams));
+				if (queryResult.issues) return fail(422, queryResult.issues);
+				query = queryResult.value;
+			}
+			if (options.body && method !== "GET" && method !== "HEAD") {
+				body = await parseRequestData(event);
+				const bodyResult = await validateWithSchema(options.body, body);
+				if (bodyResult.issues) return fail(422, bodyResult.issues);
+				body = bodyResult.value;
+			}
+			if (method === "GET" || method === "HEAD") data = query;
+			else if (body !== void 0) data = body;
+			else data = query;
+		}
+		const result = await options.handler({
+			data,
+			query,
+			body,
+			params,
+			event
+		});
+		if (result instanceof Response) return result;
+		if (options.output && isDevEnvironment()) {
+			const outputResult = await validateWithSchema(options.output, result);
+			if (outputResult.issues) warnOnOutputIssues(outputResult.issues);
+		}
+		return json(result);
+	});
+}
+//#endregion
+//#region packages/router/server/actions/src/define-page-load.ts
+/**
+* Creates a typed page server load function with optional
+* Standard Schema validation for route params and query.
+*
+* Follows the same validation patterns as `defineAction` and
+* `defineServerRoute`: validates before invoking the handler,
+* returns `fail(422, issues)` on validation failure.
+*
+* @example
+* ```typescript
+* // src/app/pages/users/[id].server.ts
+* import { definePageLoad } from '@analogjs/router/server/actions';
+* import * as v from 'valibot';
+*
+* export const routeParamsSchema = v.object({
+*   id: v.pipe(v.string(), v.regex(/^\d+$/)),
+* });
+*
+* export const load = definePageLoad({
+*   params: routeParamsSchema,
+*   handler: async ({ params, fetch }) => {
+*     // params.id is typed as string (validated)
+*     const user = await fetch(`/api/users/${params.id}`);
+*     return user;
+*   },
+* });
+* ```
+*/
+function definePageLoad(options) {
+	return async (ctx) => {
+		let params = ctx.params ?? {};
+		let requestUrl;
+		try {
+			requestUrl = getRequestURL(ctx.event).href;
+		} catch {
+			requestUrl = ctx.event.request.url;
+		}
+		let query = parseSearchParams(new URL(requestUrl, "http://localhost").searchParams);
+		if (options.params) {
+			const result = await validateWithSchema(options.params, params);
+			if (result.issues) return fail(422, result.issues);
+			params = result.value;
+		}
+		if (options.query) {
+			const result = await validateWithSchema(options.query, query);
+			if (result.issues) return fail(422, result.issues);
+			query = result.value;
+		}
+		return options.handler({
+			params,
+			query,
+			req: ctx.req,
+			res: ctx.res,
+			fetch: ctx.fetch,
+			event: ctx.event
+		});
+	};
+}
+//#endregion
+export { fail as a, validateWithSchema as i, defineServerRoute as n, json as o, defineAction as r, redirect as s, definePageLoad as t };
+
+//# sourceMappingURL=src.mjs.map

package/fesm2022/src.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"src.mjs","names":[],"sources":["../../server/actions/src/actions.ts","../../server/actions/src/parse-request-data.ts","../../server/actions/src/validate.ts","../../server/actions/src/define-action.ts","../../server/actions/src/define-server-route.ts","../../server/actions/src/define-page-load.ts"],"sourcesContent":["import type { H3Event, H3EventContext } from 'nitro/h3';\nimport type { $Fetch } from 'nitro/types';\nimport type { NodeContext } from '../../../src/lib/route-types.js';\n\nexport type PageServerAction = {\n  params: H3EventContext['params'];\n  req: NodeContext['req'];\n  res: NonNullable<NodeContext['res']>;\n  fetch: $Fetch;\n  event: H3Event;\n};\n\nexport function fail<T = object>(status: number, errors: T): Response {\n  return new Response(JSON.stringify(errors), {\n    status,\n    headers: {\n      'X-Analog-Errors': 'true',\n    },\n  });\n}\n\nexport function json<T = object>(data: T, config?: ResponseInit): Response {\n  return new Response(JSON.stringify(data), {\n    headers: {\n      'Content-Type': 'application/json; charset=utf-8',\n    },\n    ...config,\n  });\n}\n\nexport function redirect(\n  url: string,\n  config: number | ResponseInit = 302,\n): Response {\n  if (typeof config === 'number') {\n    return new Response(null, {\n      status: config,\n      headers: {\n        Location: `${url}`,\n      },\n    });\n  }\n\n  return new Response(null, {\n    headers: {\n      Location: `${url}`,\n    },\n    ...config,\n  });\n}\n","import { readBody, readFormData, toRequest as h3ToRequest } from 'nitro/h3';\n\ntype RequestEntryValue = string | File;\ntype ParsedRequestValue = RequestEntryValue | RequestEntryValue[];\n\nfunction appendEntry(\n  target: Record<string, ParsedRequestValue>,\n  key: string,\n  value: RequestEntryValue,\n) {\n  const existingValue = target[key];\n\n  if (existingValue === undefined) {\n    target[key] = value;\n    return;\n  }\n\n  if (Array.isArray(existingValue)) {\n    existingValue.push(value);\n    return;\n  }\n\n  target[key] = [existingValue, value];\n}\n\nfunction getRequest(event: { method: string; headers: Headers }): Request {\n  const maybeRequest = (event as unknown as { request?: Request }).request;\n  if (maybeRequest) {\n    return maybeRequest;\n  }\n  return h3ToRequest(event as Parameters<typeof h3ToRequest>[0]);\n}\n\nfunction getContentType(event: { method: string; headers: Headers }): string {\n  const request = getRequest(event);\n\n  return (\n    request.headers.get('content-type') ??\n    event.headers.get('content-type') ??\n    event.headers.get('Content-Type') ??\n    ''\n  );\n}\n\nfunction isJsonContentType(contentType: string): boolean {\n  const mimeType = contentType.split(';', 1)[0]?.trim().toLowerCase() ?? '';\n  return mimeType === 'application/json' || mimeType.endsWith('+json');\n}\n\nfunction isFormContentType(contentType: string): boolean {\n  return (\n    contentType.includes('multipart/form-data') ||\n    contentType.includes('application/x-www-form-urlencoded')\n  );\n}\n\nexport function parseSearchParams(\n  searchParams: URLSearchParams,\n): Record<string, ParsedRequestValue> {\n  const result: Record<string, ParsedRequestValue> = {};\n  searchParams.forEach((value, key) => {\n    appendEntry(result, key, value);\n  });\n  return result;\n}\n\nexport function parseFormData(\n  formData: FormData,\n): Record<string, ParsedRequestValue> {\n  const result: Record<string, ParsedRequestValue> = {};\n  formData.forEach((value, key) => {\n    appendEntry(result, key, value as RequestEntryValue);\n  });\n  return result;\n}\n\nexport async function parseRequestData(event: {\n  method: string;\n  headers: Headers;\n}): Promise<unknown> {\n  const request = getRequest(event);\n  const httpEvent = event as unknown as Parameters<typeof readBody>[0];\n  const h3Event = event as unknown as Parameters<typeof readFormData>[0];\n  const method = event.method.toUpperCase();\n\n  if (method === 'GET' || method === 'HEAD') {\n    const url = new URL(request.url, 'http://localhost');\n    return parseSearchParams(url.searchParams);\n  }\n\n  const contentType = getContentType(event);\n\n  if (isJsonContentType(contentType)) {\n    try {\n      return (await readBody(httpEvent)) ?? {};\n    } catch {\n      try {\n        return await request.json();\n      } catch {\n        return {};\n      }\n    }\n  }\n\n  if (isFormContentType(contentType)) {\n    try {\n      return parseFormData(await readFormData(h3Event));\n    } catch {\n      if (typeof request.formData === 'function') {\n        return parseFormData(await request.formData());\n      }\n\n      return {};\n    }\n  }\n\n  try {\n    return (await readBody(httpEvent)) ?? {};\n  } catch {\n    try {\n      return await request.json();\n    } catch {\n      return {};\n    }\n  }\n}\n","import type { StandardSchemaV1 } from '@standard-schema/spec';\n\n/**\n * Validates unknown input against a Standard Schema.\n *\n * Handles both sync and async `validate` implementations — the Standard\n * Schema spec allows either return shape.\n */\nexport async function validateWithSchema<T extends StandardSchemaV1>(\n  schema: T,\n  data: unknown,\n): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<T>>> {\n  return schema['~standard'].validate(data);\n}\n","import type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { H3Event, H3EventContext } from 'nitro/h3';\nimport type { $Fetch } from 'nitro/types';\nimport { fail } from './actions';\nimport { parseRequestData } from './parse-request-data';\nimport { validateWithSchema } from './validate';\n\ntype NodeContext = NonNullable<H3Event['node']>;\ntype OptionalSchema = StandardSchemaV1 | undefined;\ntype InferSchema<\n  TSchema extends OptionalSchema,\n  TFallback,\n> = TSchema extends StandardSchemaV1\n  ? StandardSchemaV1.InferOutput<TSchema>\n  : TFallback;\n\nexport interface DefineActionContext<\n  TSchema extends OptionalSchema = undefined,\n  TParamsSchema extends OptionalSchema = undefined,\n> {\n  data: InferSchema<TSchema, Record<string, unknown>>;\n  params: InferSchema<TParamsSchema, H3EventContext['params']>;\n  req: NodeContext['req'];\n  res: NonNullable<NodeContext['res']>;\n  fetch: $Fetch;\n  event: H3Event;\n}\n\nexport interface DefineActionOptions<\n  TSchema extends OptionalSchema = undefined,\n  TParamsSchema extends OptionalSchema = undefined,\n> {\n  schema?: TSchema;\n  params?: TParamsSchema;\n  handler: (\n    context: DefineActionContext<TSchema, TParamsSchema>,\n  ) => Promise<Response> | Response;\n}\n\n/**\n * Creates a server action handler with Standard Schema input validation.\n *\n * Parses the request body (JSON or FormData) and validates it against the\n * provided schema before invoking the handler. On validation failure,\n * returns `fail(422, issues)` with `StandardSchemaV1.Issue[]`.\n * Repeated form fields are preserved as arrays instead of being collapsed\n * to the last value.\n *\n * @example\n * ```typescript\n * import { defineAction, json } from '@analogjs/router/server/actions';\n * import * as v from 'valibot';\n *\n * const Schema = v.object({\n *   email: v.pipe(v.string(), v.email()),\n * });\n *\n * export const action = defineAction({\n *   schema: Schema,\n *   handler: async ({ data }) => {\n *     // data is typed as { email: string }\n *     return json({ ok: true });\n *   },\n * });\n * ```\n */\nexport function defineAction<\n  TSchema extends OptionalSchema = undefined,\n  TParamsSchema extends OptionalSchema = undefined,\n>(options: DefineActionOptions<TSchema, TParamsSchema>) {\n  type Params = InferSchema<TParamsSchema, H3EventContext['params']>;\n\n  function getParams(\n    params: H3EventContext['params'],\n  ): Params | Record<string, never> {\n    return (params ?? {}) as Params | Record<string, never>;\n  }\n\n  return async (ctx: {\n    params: H3EventContext['params'];\n    req: NodeContext['req'];\n    res: NonNullable<NodeContext['res']>;\n    fetch: $Fetch;\n    event: H3Event;\n  }): Promise<Response> => {\n    const rawParams = getParams(ctx.params);\n\n    if (options.params) {\n      const paramsResult = await validateWithSchema(options.params, rawParams);\n      if (paramsResult.issues) {\n        return fail(422, paramsResult.issues);\n      }\n      return handleValidatedRequest(ctx, options, paramsResult.value as Params);\n    }\n\n    return handleValidatedRequest(ctx, options, rawParams as Params);\n  };\n}\n\nasync function handleValidatedRequest<\n  TSchema extends OptionalSchema = undefined,\n  TParamsSchema extends OptionalSchema = undefined,\n>(\n  ctx: {\n    params: H3EventContext['params'];\n    req: NodeContext['req'];\n    res: NonNullable<NodeContext['res']>;\n    fetch: $Fetch;\n    event: H3Event;\n  },\n  options: DefineActionOptions<TSchema, TParamsSchema>,\n  params: InferSchema<TParamsSchema, H3EventContext['params']>,\n) {\n  type Data = InferSchema<TSchema, Record<string, unknown>>;\n  const body = await parseRequestData(ctx.event);\n\n  let data: unknown = body;\n\n  if (options.schema) {\n    const result = await validateWithSchema(options.schema, body);\n    if (result.issues) {\n      return fail(422, result.issues);\n    }\n    data = result.value;\n  }\n\n  return options.handler({\n    data: data as Data,\n    params,\n    req: ctx.req,\n    res: ctx.res,\n    fetch: ctx.fetch,\n    event: ctx.event,\n  });\n}\n","import type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { H3Event } from 'nitro/h3';\nimport { getRequestURL } from 'nitro/h3';\nimport { fail, json } from './actions';\nimport { parseRequestData, parseSearchParams } from './parse-request-data';\nimport { validateWithSchema } from './validate';\n\nexport type DefineServerRouteResult = Response | unknown;\n\nexport interface ServerRouteHandler<\n  TQuery = unknown,\n  TBody = unknown,\n  TResult = unknown,\n> {\n  (event: H3Event): Promise<Response>;\n  readonly _types: {\n    readonly query: TQuery;\n    readonly body: TBody;\n    readonly result: TResult;\n  };\n}\n\nexport type InferRouteQuery<T> =\n  T extends ServerRouteHandler<infer Q, any, any> ? Q : never;\nexport type InferRouteBody<T> =\n  T extends ServerRouteHandler<any, infer B, any> ? B : never;\nexport type InferRouteResult<T> =\n  T extends ServerRouteHandler<any, any, infer R>\n    ? Exclude<R, Response>\n    : never;\n\ntype OptionalSchema = StandardSchemaV1 | undefined;\ntype InferSchema<\n  TSchema extends OptionalSchema,\n  TFallback = unknown,\n> = TSchema extends StandardSchemaV1\n  ? StandardSchemaV1.InferOutput<TSchema>\n  : TFallback;\ntype ResolveDataSchema<\n  TInput extends OptionalSchema,\n  TQuery extends OptionalSchema,\n  TBody extends OptionalSchema,\n> = TInput extends StandardSchemaV1\n  ? StandardSchemaV1.InferOutput<TInput>\n  : TQuery extends StandardSchemaV1\n    ? TBody extends StandardSchemaV1\n      ?\n          | StandardSchemaV1.InferOutput<TQuery>\n          | StandardSchemaV1.InferOutput<TBody>\n      : StandardSchemaV1.InferOutput<TQuery>\n    : TBody extends StandardSchemaV1\n      ? StandardSchemaV1.InferOutput<TBody>\n      : unknown;\n\nexport interface DefineServerRouteContext<\n  TInput extends StandardSchemaV1 | undefined = undefined,\n  TQuery extends StandardSchemaV1 | undefined = undefined,\n  TBody extends StandardSchemaV1 | undefined = undefined,\n  TParams extends StandardSchemaV1 | undefined = undefined,\n> {\n  data: ResolveDataSchema<TInput, TQuery, TBody>;\n  query: InferSchema<TQuery, undefined>;\n  body: InferSchema<TBody, undefined>;\n  params: InferSchema<TParams, H3Event['context']['params']>;\n  event: H3Event;\n}\n\nexport interface DefineServerRouteOptions<\n  TInput extends StandardSchemaV1 | undefined = undefined,\n  TOutput extends StandardSchemaV1 | undefined = undefined,\n  TQuery extends StandardSchemaV1 | undefined = undefined,\n  TBody extends StandardSchemaV1 | undefined = undefined,\n  TParams extends StandardSchemaV1 | undefined = undefined,\n  TResult extends DefineServerRouteResult = DefineServerRouteResult,\n> {\n  input?: TInput;\n  query?: TQuery;\n  body?: TBody;\n  params?: TParams;\n  output?: TOutput;\n  handler: (\n    context: DefineServerRouteContext<TInput, TQuery, TBody, TParams>,\n  ) => Promise<TResult> | TResult;\n}\n\nfunction isDevEnvironment() {\n  return (\n    typeof process !== 'undefined' &&\n    (process.env['NODE_ENV'] === 'development' ||\n      process.env['NODE_ENV'] === 'test')\n  );\n}\n\nfunction warnOnOutputIssues(issues: ReadonlyArray<StandardSchemaV1.Issue>) {\n  console.warn(\n    `[analog] Server route output validation failed:\\n` +\n      issues\n        .map((i) => {\n          const path = i.path\n            ? ` at \"${i.path.map((p) => (typeof p === 'object' ? (p as { key: string }).key : p)).join('.')}\"`\n            : '';\n          return `  - ${i.message}${path}`;\n        })\n        .join('\\n'),\n  );\n}\n\nfunction getRequestUrl(event: H3Event): string {\n  try {\n    return getRequestURL(event).href;\n  } catch {\n    return (event as H3Event & { request: Request }).request.url;\n  }\n}\n\n/**\n * Creates an h3-compatible event handler with Standard Schema validation.\n *\n * - `input` schema validates the request body (POST/PUT/PATCH) or query\n *   params (GET). Returns 422 with `StandardSchemaV1.Issue[]` on failure.\n * - `output` schema validates the response in development only (stripped\n *   in production for zero overhead). Logs a warning on mismatch.\n * - Plain return values are serialized with `json(...)`; raw `Response`\n *   objects are returned unchanged.\n *\n * @example\n * ```typescript\n * import { defineServerRoute } from '@analogjs/router/server/actions';\n * import * as v from 'valibot';\n *\n * const Input = v.object({\n *   name: v.pipe(v.string(), v.minLength(1)),\n *   email: v.pipe(v.string(), v.email()),\n * });\n * const Output = v.object({\n *   id: v.string(),\n *   name: v.string(),\n * });\n *\n * export default defineServerRoute({\n *   input: Input,\n *   output: Output,\n *   handler: async ({ data }) => {\n *     const user = await db.users.create(data);\n *     return user;\n *   },\n * });\n * ```\n */\nexport function defineServerRoute<\n  TInput extends StandardSchemaV1 | undefined = undefined,\n  TOutput extends StandardSchemaV1 | undefined = undefined,\n  TQuery extends StandardSchemaV1 | undefined = undefined,\n  TBody extends StandardSchemaV1 | undefined = undefined,\n  TParams extends StandardSchemaV1 | undefined = undefined,\n  TResult extends DefineServerRouteResult = DefineServerRouteResult,\n>(\n  options: DefineServerRouteOptions<\n    TInput,\n    TOutput,\n    TQuery,\n    TBody,\n    TParams,\n    TResult\n  >,\n): ServerRouteHandler<\n  InferSchema<TQuery, undefined>,\n  InferSchema<TBody, undefined>,\n  TResult\n> {\n  return (async (event: H3Event): Promise<Response> => {\n    const method = event.method.toUpperCase();\n    let data: unknown;\n    let query: unknown;\n    let body: unknown;\n    let params: unknown = event.context?.params ?? {};\n\n    if (options.params) {\n      const paramsResult = await validateWithSchema(options.params, params);\n      if (paramsResult.issues) {\n        return fail(422, paramsResult.issues);\n      }\n      params = paramsResult.value;\n    }\n\n    if (options.input) {\n      data = await parseRequestData(event);\n\n      const inputResult = await validateWithSchema(options.input, data);\n      if (inputResult.issues) {\n        return fail(422, inputResult.issues);\n      }\n      data = inputResult.value;\n    } else {\n      if (options.query) {\n        const url = new URL(getRequestUrl(event), 'http://localhost');\n        const queryResult = await validateWithSchema(\n          options.query,\n          parseSearchParams(url.searchParams),\n        );\n        if (queryResult.issues) {\n          return fail(422, queryResult.issues);\n        }\n        query = queryResult.value;\n      }\n\n      if (options.body && method !== 'GET' && method !== 'HEAD') {\n        body = await parseRequestData(event);\n        const bodyResult = await validateWithSchema(options.body, body);\n        if (bodyResult.issues) {\n          return fail(422, bodyResult.issues);\n        }\n        body = bodyResult.value;\n      }\n\n      if (method === 'GET' || method === 'HEAD') {\n        data = query;\n      } else if (body !== undefined) {\n        data = body;\n      } else {\n        data = query;\n      }\n    }\n\n    const result = await options.handler({\n      data: data as ResolveDataSchema<TInput, TQuery, TBody>,\n      query: query as InferSchema<TQuery, undefined>,\n      body: body as InferSchema<TBody, undefined>,\n      params: params as InferSchema<TParams, H3Event['context']['params']>,\n      event,\n    });\n\n    if (result instanceof Response) {\n      return result;\n    }\n\n    if (options.output && isDevEnvironment()) {\n      const outputResult = await validateWithSchema(options.output, result);\n      if (outputResult.issues) {\n        warnOnOutputIssues(outputResult.issues);\n      }\n    }\n\n    return json(result);\n  }) as ServerRouteHandler<\n    InferSchema<TQuery, undefined>,\n    InferSchema<TBody, undefined>,\n    TResult\n  >;\n}\n","import type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { H3Event, H3EventContext } from 'nitro/h3';\nimport { getRequestURL } from 'nitro/h3';\nimport type { $Fetch } from 'nitro/types';\nimport { fail } from './actions';\nimport { parseSearchParams } from './parse-request-data';\nimport { validateWithSchema } from './validate';\n\ntype NodeContext = NonNullable<H3Event['node']>;\ntype OptionalSchema = StandardSchemaV1 | undefined;\ntype InferSchema<\n  TSchema extends OptionalSchema,\n  TFallback,\n> = TSchema extends StandardSchemaV1\n  ? StandardSchemaV1.InferOutput<TSchema>\n  : TFallback;\n\nexport interface PageLoadContext<\n  TParamsSchema extends OptionalSchema = undefined,\n  TQuerySchema extends OptionalSchema = undefined,\n> {\n  params: InferSchema<TParamsSchema, H3EventContext['params']>;\n  query: InferSchema<\n    TQuerySchema,\n    Record<string, string | string[] | undefined>\n  >;\n  req: NodeContext['req'];\n  res: NonNullable<NodeContext['res']>;\n  fetch: $Fetch;\n  event: H3Event;\n}\n\nexport interface DefinePageLoadOptions<\n  TParamsSchema extends OptionalSchema = undefined,\n  TQuerySchema extends OptionalSchema = undefined,\n  TResult = unknown,\n> {\n  params?: TParamsSchema;\n  query?: TQuerySchema;\n  handler: (\n    context: PageLoadContext<TParamsSchema, TQuerySchema>,\n  ) => Promise<TResult> | TResult;\n}\n\n/**\n * Creates a typed page server load function with optional\n * Standard Schema validation for route params and query.\n *\n * Follows the same validation patterns as `defineAction` and\n * `defineServerRoute`: validates before invoking the handler,\n * returns `fail(422, issues)` on validation failure.\n *\n * @example\n * ```typescript\n * // src/app/pages/users/[id].server.ts\n * import { definePageLoad } from '@analogjs/router/server/actions';\n * import * as v from 'valibot';\n *\n * export const routeParamsSchema = v.object({\n *   id: v.pipe(v.string(), v.regex(/^\\d+$/)),\n * });\n *\n * export const load = definePageLoad({\n *   params: routeParamsSchema,\n *   handler: async ({ params, fetch }) => {\n *     // params.id is typed as string (validated)\n *     const user = await fetch(`/api/users/${params.id}`);\n *     return user;\n *   },\n * });\n * ```\n */\nexport function definePageLoad<\n  TParamsSchema extends OptionalSchema = undefined,\n  TQuerySchema extends OptionalSchema = undefined,\n  TResult = unknown,\n>(\n  options: DefinePageLoadOptions<TParamsSchema, TQuerySchema, TResult>,\n): (ctx: {\n  params: H3EventContext['params'];\n  req: NodeContext['req'];\n  res: NonNullable<NodeContext['res']>;\n  fetch: $Fetch;\n  event: H3Event;\n}) => Promise<TResult | Response> {\n  type Params = InferSchema<TParamsSchema, H3EventContext['params']>;\n  type Query = InferSchema<\n    TQuerySchema,\n    Record<string, string | string[] | undefined>\n  >;\n\n  return async (ctx: {\n    params: H3EventContext['params'];\n    req: NodeContext['req'];\n    res: NonNullable<NodeContext['res']>;\n    fetch: $Fetch;\n    event: H3Event;\n  }) => {\n    let params: unknown = ctx.params ?? {};\n\n    let requestUrl: string;\n    try {\n      requestUrl = getRequestURL(ctx.event).href;\n    } catch {\n      requestUrl = (ctx.event as H3Event & { request: Request }).request.url;\n    }\n    const url = new URL(requestUrl, 'http://localhost');\n    let query: unknown = parseSearchParams(url.searchParams);\n\n    // Validate params\n    if (options.params) {\n      const result = await validateWithSchema(options.params, params);\n      if (result.issues) {\n        return fail(422, result.issues);\n      }\n      params = result.value;\n    }\n\n    // Validate query\n    if (options.query) {\n      const result = await validateWithSchema(options.query, query);\n      if (result.issues) {\n        return fail(422, result.issues);\n      }\n      query = result.value;\n    }\n\n    return options.handler({\n      params: params as Params,\n      query: query as Query,\n      req: ctx.req,\n      res: ctx.res,\n      fetch: ctx.fetch,\n      event: ctx.event,\n    });\n  };\n}\n"],"mappings":";;AAYA,SAAgB,KAAiB,QAAgB,QAAqB;AACpE,QAAO,IAAI,SAAS,KAAK,UAAU,OAAS,EAAA;EAC1C;EACA,SACE,EAEF,mBAAA,QAAA;EAGJ,CAAA;;SAGM,KAAA,MAAA,QAAgB;AAElB,QAAG,IAAA,SAAA,KAAA,UAAA,KAAA,EAAA;EACH,SAAA,EAAA,gBAAA,mCAGG;EAID,GAAA;EACF,CAAA;;SAGI,SAAU,KAAG,SAAA,KAAA;AAEf,KAAA,OAAA,WAAA,SAAA,QAAA,IAAA,SAAA,MAAA;EAGO,QAAA;EACA,SACP,EAEC,UAAA,GAAA,OACH;;;;;;;;;AC3CJ,SAAS,YACP,QACA,KACA,OACA;CACA,MAAM,gBAAgB,OAAO;AAE7B,KAAI,kBAAkB,KAAA,GAAW;AAC/B,SAAO,OAAO;AACd;;AAGF,KAAI,MAAM,QAAQ,cAAgB,EAAA;AAChC,gBAAmB,KAAM,MAAA;AACzB;;AAGF,QAAO,OAAQ,CAAA,eAAe,MAAM;;AAGtC,SAAS,WAAW,OAAsD;CACxE,MAAM,eAAgB,MAA2C;AACjE,KAAI,aACF,QAAO;AAET,QAAO,UAAY,MAA2C;;AAGhE,SAAS,eAAe,OAAqD;AAG3E,QAFgB,WAAW,MAAM,CAGvB,QAAY,IAAA,eACpB,IAAA,MAAA,QAAA,IAAA,eAAA,IAMJ,MAAS,QAAA,IAAA,eAAgD,IACjD;;;CAIR,MAAS,WAAA,YAAkB,MAAA,KAA8B,EAAA,CAAA,IAAA,MAAA,CAAA,aAAA,IAAA;AACvD,QACE,aAAY,sBAAS,SACrB,SAAA,QAAY;;AAIhB,SAAO,kBAAS,aACd;AAEA,QAAM,YAA+C,SAAA,sBAAA,IACrD,YAAa,SAAS,oCAAe;;SAEnC,kBAAA,cAAA;CACF,MAAO,SAAA,EAAA;;AAGF,cAAS,QAAA,KACd,MAAA;GAEA;AACA,QAAS;;SAEP,cAAA,UAAA;CACF,MAAO,SAAA,EAAA;;AAGF,cAAA,QAAe,KAAA,MAAiB;GAIrC;AACA,QAAM;;eAEe,iBAAO,OAAa;CAEzC,MAAI,UAAW,WAAS,MAAW;CACjC,MAAM,YAAc;CACpB,MAAO,UAAA;;AAGT,KAAM,WAAA,SAAc,WAAe,OAG7B,QAAA,kBADF,IAAkB,IAAA,QAAY,KAAE,mBAAA,CAC9B,aAAA;OAEI,cAAA,eAAA,MAAA;AACN,KAAI,kBAAA,YAAA,CACF,KAAO;AACD,SAAA,MAAA,SAAA,UAAA,IAAA,EAAA;;;;UAON;AACK,UAAA,EAAc;;;oCAMrB,KAAS;;SAIT;AACM,MAAM,OAAA,QAAS,aAAiB,WAClC,QAAA,cAAA,MAAA,QAAA,UAAA,CAAA;AAEG,SAAM,EAAA;;;;;;;;;;;;;;;;;;;;AChHnB,eAAsB,mBACpB,QACA,MACmE;AACnE,QAAO,OAAO,aAAa,SAAS,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACsD3C,SAAgB,aAGd,SAAsD;CAGtD,SAAS,UACP,QACgC;AAChC,SAAQ,UAAY,EAAA;;AAGtB,QAAO,OAAO,QAMW;EACjB,MAAA,YAAY,UAAc,IAAA,OAAO;AAEnC,MAAA,QAAQ,QAAQ;GACZ,MAAA,eAAqB,MAAA,mBAA2B,QAAQ,QAAA,UAAU;AACpE,OAAA,aAAqB,OACX,QAAK,KAAA,KAAA,aAAoB,OAAA;AAEhC,UAAA,uBAA4B,KAAS,SAAA,aAA6B,MAAA;;AAG3E,SAAO,uBAA4B,KAAA,SAAS,UAAoB;;;AAIpE,eAAe,uBAIb,KAOA,SACA,QACA;CAEA,MAAM,OAAO,MAAM,iBAAiB,IAAI,MAAM;CAE9C,IAAI,OAAgB;AAEpB,KAAI,QAAQ,QAAQ;EACZ,MAAA,SAAe,MAAA,mBAAmB,QAAQ,QAAa,KAAA;AACzD,MAAA,OAAO,OACF,QAAK,KAAK,KAAO,OAAO,OAAA;AAEjC,SAAO,OAAO;;AAGhB,QAAO,QAAQ,QAAQ;EACf;EACN;EACK,KAAI,IAAA;EACJ,KAAI,IAAA;EACT,OAAW,IAAA;EACX,OAAW,IAAA;EACX,CAAA;;;;AChDJ,SAAS,mBAAmB;AAC1B,QACE,OAAO,YAAY,gBAAA,QAAA,IAAA,aAAA,iBAAA,QAAA,IAAA,aAMoD;;SAK3D,mBACF,QAAU;AAEd,SAAO,KAAO,sDAEf,OAAA,KAAA,MAAA;EAIA,MAAA,OAAc,EAAA,OACjB,QAAA,EAAA,KAAA,KAAA,MAAA,OAAA,MAAA,WAAA,EAAA,MAAA,EAAA,CAAA,KAAA,IAAA,CAAA,KACK;AACD,SAAA,OAAA,EAAA,UAAA;GACE,CAAA,KAAA,KAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAmEA,kBAAqB,SAAA;AAC3B,SAAI,OAAA,UAAqB;EACvB,MAAO,SAAU,MAAA,OAAa,aAAO;;EAEvC,IAAS;;EAGP,IAAA,SAAe,MAAA,SAAA,UAAA,EAAA;AACjB,MAAO,QAAM,QAAA;GAEP,MAAA,eAAoB,MAAA,mBAA2B,QAAO,QAAK,OAAA;AAC7D,OAAA,aAAoB,OACV,QAAK,KAAA,KAAY,aAAO,OAAA;AAE/B,YAAA,aAAY;;AAEf,MAAA,QAAQ,OAAO;AACX,UAAM,MAAQ,iBAAc,MAAQ;GACpC,MAAA,cAAoB,MAAA,mBAChB,QACR,OAAA,KAAA;AAEE,OAAA,YAAoB,OACf,QAAU,KAAA,KAAA,YAAmB,OAAA;AAE9B,UAAA,YAAY;SAGlB;AACK,OAAA,QAAM,OAAA;IACP,MAAA,MAAa,IAAM,IAAA,cAAmB,MAAQ,EAAA,mBAAW;IAC3D,MAAW,cAAQ,MAAA,mBAAA,QAAA,OAAA,kBAAA,IAAA,aAAA,CAAA;AACd,QAAK,YAAK,OAAA,QAAA,KAAA,KAAA,YAAA,OAAA;;;AAMZ,OAAA,QAAA,QAAA,WAAA,SAAA,WAAA,QAAA;AACE,WAAS,MAAA,iBAAW,MAAA;IACtB,MAAA,aAAA,MAAA,mBAAA,QAAA,MAAA,KAAA;AACF,QAAA,WAAA,OACE,QAAA,KAAA,KAAA,WAAA,OAAA;;;AAKH,OAAA,WAAA,SAAA,WAAA,OACC,QAAA;YAEC,SAAA,KAAA,EACR,QAAA;OAIO,QAAA;;EAIP,MAAM,SAAA,MAAe,QAAM,QAAA;GACvB;GACF;;;GAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC3KX,SAAgB,eAKd,SAOgC;AAOhC,QAAO,OAAO,QAMR;EACA,IAAA,SAAsB,IAAA,UAAY,EAAA;EAElC,IAAA;AACA,MAAA;AACF,gBAAa,cAAkB,IAAO,MAAA,CAAA;UAEtC;;;EAME,IAAA,QAAQ,kBAHS,IAAA,IAAA,YAAsB,mBAAa,CAGpC,aAAA;AAEd,MAAA,QAAO,QAAQ;GACV,MAAK,SAAK,MAAO,mBAAO,QAAA,QAAA,OAAA;qBAExB,QAAO,KAAA,KAAA,OAAA,OAAA;AAId,YAAe,OAAA;;AAGf,MAAO,QAAK,OAAK;;AAEX,OAAA,OAAO,OAAA,QAAA,KAAA,KAAA,OAAA,OAAA;AAIP,WAAA,OAAA;;AAEH,SAAI,QAAA,QAAA;GACA;GACE;GACJ,KAAI,IAAA;GACX,KAAA,IAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@analogjs/router",
-  "version": "3.0.0-alpha.56",
+  "version": "3.0.0-alpha.57",
   "description": "Filesystem-based routing for Angular",
   "type": "module",
   "author": "Brandon Roberts <robertsbt@gmail.com>",
@@ -69,7 +69,7 @@
     "url": "https://github.com/sponsors/brandonroberts"
   },
   "peerDependencies": {
-    "@analogjs/content": "3.0.0-alpha.56",
+    "@analogjs/content": "3.0.0-alpha.57",
     "@standard-schema/spec": "^1.1.0",
     "@angular/core": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0",
     "@angular/platform-server": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0",
@@ -100,8 +100,8 @@
     "tslib": "^2.3.0"
   },
   "devDependencies": {
-    "@analogjs/vite-plugin-angular": "3.0.0-alpha.56",
-    "@analogjs/vitest-angular": "3.0.0-alpha.56"
+    "@analogjs/vite-plugin-angular": "3.0.0-alpha.57",
+    "@analogjs/vitest-angular": "3.0.0-alpha.57"
   },
   "ng-update": {
     "packageGroup": [

package/types/tanstack-query/server/src/define-page-load-queries.d.ts

@@ -0,0 +1,66 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { QueryClient } from '@tanstack/angular-query-experimental';
+import type { DehydratedState } from '@tanstack/angular-query-experimental';
+import type { H3Event, H3EventContext } from 'nitro/h3';
+import type { $Fetch } from 'nitro/types';
+import { type PageLoadContext } from '../../../server/actions/src/index.js';
+export { ANALOG_QUERIES_KEY } from '../../src/constants.js';
+type NodeContext = NonNullable<H3Event['node']>;
+type OptionalSchema = StandardSchemaV1 | undefined;
+export interface PageLoadQueriesResult<TData> {
+    __analogQueries: DehydratedState;
+    data: TData;
+}
+export interface DefinePageLoadQueriesOptions<TParamsSchema extends OptionalSchema, TQuerySchema extends OptionalSchema, TData> {
+    params?: TParamsSchema;
+    query?: TQuerySchema;
+    /**
+     * Optional QueryClient factory. Defaults to `new QueryClient()`.
+     * Override to set `defaultOptions` (e.g. `queries: { staleTime: Infinity }`).
+     */
+    client?: () => QueryClient;
+    /**
+     * Handler receives the standard PageLoadContext plus a per-request
+     * QueryClient. Use `client.prefetchQuery` / `ensureQueryData` /
+     * `prefetchInfiniteQuery` to warm the cache; the dehydrated client
+     * is returned as `__analogQueries` on the load result. Anything you
+     * return from the handler becomes `data` on the same result.
+     */
+    handler: (ctx: PageLoadContext<TParamsSchema, TQuerySchema> & {
+        client: QueryClient;
+    }) => Promise<TData> | TData;
+}
+/**
+ * Page load helper that prefetches TanStack Query queries inside the
+ * `.server.ts` handler and ships the dehydrated cache alongside any
+ * additional data. The router-side hydrator in `provideAnalogQuery()`
+ * merges the dehydrated payload into the active `QueryClient` on
+ * `ResolveEnd`, so components reading the same query options see a
+ * warm cache on first render.
+ *
+ * @example
+ * ```ts
+ * // src/app/pages/posts.server.ts
+ * import { definePageLoadQueries } from '@analogjs/router/tanstack-query/server';
+ * import { queryOptions } from '@tanstack/angular-query-experimental';
+ *
+ * export const postsQuery = queryOptions({
+ *   queryKey: ['posts'],
+ *   queryFn: async ({ signal }) =>
+ *     fetch('https://api.example.com/posts', { signal }).then((r) => r.json()),
+ * });
+ *
+ * export const load = definePageLoadQueries({
+ *   handler: async ({ client }) => {
+ *     await client.prefetchQuery(postsQuery);
+ *   },
+ * });
+ * ```
+ */
+export declare function definePageLoadQueries<TParamsSchema extends OptionalSchema = undefined, TQuerySchema extends OptionalSchema = undefined, TData = void>(options: DefinePageLoadQueriesOptions<TParamsSchema, TQuerySchema, TData>): (ctx: {
+    params: H3EventContext['params'];
+    req: NodeContext['req'];
+    res: NonNullable<NodeContext['res']>;
+    fetch: $Fetch;
+    event: H3Event;
+}) => Promise<PageLoadQueriesResult<TData> | Response>;

package/types/tanstack-query/server/src/index.d.ts

@@ -1 +1,3 @@
 export { provideServerAnalogQuery } from '../../src/provide-server-analog-query';
+export { definePageLoadQueries, ANALOG_QUERIES_KEY, } from './define-page-load-queries';
+export type { PageLoadQueriesResult, DefinePageLoadQueriesOptions, } from './define-page-load-queries';

package/types/tanstack-query/src/constants.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Route-data key under `ActivatedRoute.data['load']` that holds the
+ * `DehydratedState` produced by `definePageLoadQueries`. The Router-
+ * events hydrator in `provideAnalogQuery()` looks for this key on
+ * `ResolveEnd` and merges the dehydrated payload into the active
+ * `QueryClient`, so component-issued queries hit a warm cache on
+ * first render.
+ */
+export declare const ANALOG_QUERIES_KEY: '__analogQueries';

package/fesm2022/analogjs-router-server-actions.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"analogjs-router-server-actions.mjs","names":[],"sources":["../../server/actions/src/actions.ts","../../server/actions/src/parse-request-data.ts","../../server/actions/src/validate.ts","../../server/actions/src/define-action.ts","../../server/actions/src/define-server-route.ts","../../server/actions/src/define-page-load.ts"],"sourcesContent":["import type { H3Event, H3EventContext } from 'nitro/h3';\nimport type { $Fetch } from 'nitro/types';\nimport type { NodeContext } from '../../../src/lib/route-types.js';\n\nexport type PageServerAction = {\n  params: H3EventContext['params'];\n  req: NodeContext['req'];\n  res: NonNullable<NodeContext['res']>;\n  fetch: $Fetch;\n  event: H3Event;\n};\n\nexport function fail<T = object>(status: number, errors: T): Response {\n  return new Response(JSON.stringify(errors), {\n    status,\n    headers: {\n      'X-Analog-Errors': 'true',\n    },\n  });\n}\n\nexport function json<T = object>(data: T, config?: ResponseInit): Response {\n  return new Response(JSON.stringify(data), {\n    headers: {\n      'Content-Type': 'application/json; charset=utf-8',\n    },\n    ...config,\n  });\n}\n\nexport function redirect(\n  url: string,\n  config: number | ResponseInit = 302,\n): Response {\n  if (typeof config === 'number') {\n    return new Response(null, {\n      status: config,\n      headers: {\n        Location: `${url}`,\n      },\n    });\n  }\n\n  return new Response(null, {\n    headers: {\n      Location: `${url}`,\n    },\n    ...config,\n  });\n}\n","import { readBody, readFormData, toRequest as h3ToRequest } from 'nitro/h3';\n\ntype RequestEntryValue = string | File;\ntype ParsedRequestValue = RequestEntryValue | RequestEntryValue[];\n\nfunction appendEntry(\n  target: Record<string, ParsedRequestValue>,\n  key: string,\n  value: RequestEntryValue,\n) {\n  const existingValue = target[key];\n\n  if (existingValue === undefined) {\n    target[key] = value;\n    return;\n  }\n\n  if (Array.isArray(existingValue)) {\n    existingValue.push(value);\n    return;\n  }\n\n  target[key] = [existingValue, value];\n}\n\nfunction getRequest(event: { method: string; headers: Headers }): Request {\n  const maybeRequest = (event as unknown as { request?: Request }).request;\n  if (maybeRequest) {\n    return maybeRequest;\n  }\n  return h3ToRequest(event as Parameters<typeof h3ToRequest>[0]);\n}\n\nfunction getContentType(event: { method: string; headers: Headers }): string {\n  const request = getRequest(event);\n\n  return (\n    request.headers.get('content-type') ??\n    event.headers.get('content-type') ??\n    event.headers.get('Content-Type') ??\n    ''\n  );\n}\n\nfunction isJsonContentType(contentType: string): boolean {\n  const mimeType = contentType.split(';', 1)[0]?.trim().toLowerCase() ?? '';\n  return mimeType === 'application/json' || mimeType.endsWith('+json');\n}\n\nfunction isFormContentType(contentType: string): boolean {\n  return (\n    contentType.includes('multipart/form-data') ||\n    contentType.includes('application/x-www-form-urlencoded')\n  );\n}\n\nexport function parseSearchParams(\n  searchParams: URLSearchParams,\n): Record<string, ParsedRequestValue> {\n  const result: Record<string, ParsedRequestValue> = {};\n  searchParams.forEach((value, key) => {\n    appendEntry(result, key, value);\n  });\n  return result;\n}\n\nexport function parseFormData(\n  formData: FormData,\n): Record<string, ParsedRequestValue> {\n  const result: Record<string, ParsedRequestValue> = {};\n  formData.forEach((value, key) => {\n    appendEntry(result, key, value as RequestEntryValue);\n  });\n  return result;\n}\n\nexport async function parseRequestData(event: {\n  method: string;\n  headers: Headers;\n}): Promise<unknown> {\n  const request = getRequest(event);\n  const httpEvent = event as unknown as Parameters<typeof readBody>[0];\n  const h3Event = event as unknown as Parameters<typeof readFormData>[0];\n  const method = event.method.toUpperCase();\n\n  if (method === 'GET' || method === 'HEAD') {\n    const url = new URL(request.url, 'http://localhost');\n    return parseSearchParams(url.searchParams);\n  }\n\n  const contentType = getContentType(event);\n\n  if (isJsonContentType(contentType)) {\n    try {\n      return (await readBody(httpEvent)) ?? {};\n    } catch {\n      try {\n        return await request.json();\n      } catch {\n        return {};\n      }\n    }\n  }\n\n  if (isFormContentType(contentType)) {\n    try {\n      return parseFormData(await readFormData(h3Event));\n    } catch {\n      if (typeof request.formData === 'function') {\n        return parseFormData(await request.formData());\n      }\n\n      return {};\n    }\n  }\n\n  try {\n    return (await readBody(httpEvent)) ?? {};\n  } catch {\n    try {\n      return await request.json();\n    } catch {\n      return {};\n    }\n  }\n}\n","import type { StandardSchemaV1 } from '@standard-schema/spec';\n\n/**\n * Validates unknown input against a Standard Schema.\n *\n * Handles both sync and async `validate` implementations — the Standard\n * Schema spec allows either return shape.\n */\nexport async function validateWithSchema<T extends StandardSchemaV1>(\n  schema: T,\n  data: unknown,\n): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<T>>> {\n  return schema['~standard'].validate(data);\n}\n","import type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { H3Event, H3EventContext } from 'nitro/h3';\nimport type { $Fetch } from 'nitro/types';\nimport { fail } from './actions';\nimport { parseRequestData } from './parse-request-data';\nimport { validateWithSchema } from './validate';\n\ntype NodeContext = NonNullable<H3Event['node']>;\ntype OptionalSchema = StandardSchemaV1 | undefined;\ntype InferSchema<\n  TSchema extends OptionalSchema,\n  TFallback,\n> = TSchema extends StandardSchemaV1\n  ? StandardSchemaV1.InferOutput<TSchema>\n  : TFallback;\n\nexport interface DefineActionContext<\n  TSchema extends OptionalSchema = undefined,\n  TParamsSchema extends OptionalSchema = undefined,\n> {\n  data: InferSchema<TSchema, Record<string, unknown>>;\n  params: InferSchema<TParamsSchema, H3EventContext['params']>;\n  req: NodeContext['req'];\n  res: NonNullable<NodeContext['res']>;\n  fetch: $Fetch;\n  event: H3Event;\n}\n\nexport interface DefineActionOptions<\n  TSchema extends OptionalSchema = undefined,\n  TParamsSchema extends OptionalSchema = undefined,\n> {\n  schema?: TSchema;\n  params?: TParamsSchema;\n  handler: (\n    context: DefineActionContext<TSchema, TParamsSchema>,\n  ) => Promise<Response> | Response;\n}\n\n/**\n * Creates a server action handler with Standard Schema input validation.\n *\n * Parses the request body (JSON or FormData) and validates it against the\n * provided schema before invoking the handler. On validation failure,\n * returns `fail(422, issues)` with `StandardSchemaV1.Issue[]`.\n * Repeated form fields are preserved as arrays instead of being collapsed\n * to the last value.\n *\n * @example\n * ```typescript\n * import { defineAction, json } from '@analogjs/router/server/actions';\n * import * as v from 'valibot';\n *\n * const Schema = v.object({\n *   email: v.pipe(v.string(), v.email()),\n * });\n *\n * export const action = defineAction({\n *   schema: Schema,\n *   handler: async ({ data }) => {\n *     // data is typed as { email: string }\n *     return json({ ok: true });\n *   },\n * });\n * ```\n */\nexport function defineAction<\n  TSchema extends OptionalSchema = undefined,\n  TParamsSchema extends OptionalSchema = undefined,\n>(options: DefineActionOptions<TSchema, TParamsSchema>) {\n  type Params = InferSchema<TParamsSchema, H3EventContext['params']>;\n\n  function getParams(\n    params: H3EventContext['params'],\n  ): Params | Record<string, never> {\n    return (params ?? {}) as Params | Record<string, never>;\n  }\n\n  return async (ctx: {\n    params: H3EventContext['params'];\n    req: NodeContext['req'];\n    res: NonNullable<NodeContext['res']>;\n    fetch: $Fetch;\n    event: H3Event;\n  }): Promise<Response> => {\n    const rawParams = getParams(ctx.params);\n\n    if (options.params) {\n      const paramsResult = await validateWithSchema(options.params, rawParams);\n      if (paramsResult.issues) {\n        return fail(422, paramsResult.issues);\n      }\n      return handleValidatedRequest(ctx, options, paramsResult.value as Params);\n    }\n\n    return handleValidatedRequest(ctx, options, rawParams as Params);\n  };\n}\n\nasync function handleValidatedRequest<\n  TSchema extends OptionalSchema = undefined,\n  TParamsSchema extends OptionalSchema = undefined,\n>(\n  ctx: {\n    params: H3EventContext['params'];\n    req: NodeContext['req'];\n    res: NonNullable<NodeContext['res']>;\n    fetch: $Fetch;\n    event: H3Event;\n  },\n  options: DefineActionOptions<TSchema, TParamsSchema>,\n  params: InferSchema<TParamsSchema, H3EventContext['params']>,\n) {\n  type Data = InferSchema<TSchema, Record<string, unknown>>;\n  const body = await parseRequestData(ctx.event);\n\n  let data: unknown = body;\n\n  if (options.schema) {\n    const result = await validateWithSchema(options.schema, body);\n    if (result.issues) {\n      return fail(422, result.issues);\n    }\n    data = result.value;\n  }\n\n  return options.handler({\n    data: data as Data,\n    params,\n    req: ctx.req,\n    res: ctx.res,\n    fetch: ctx.fetch,\n    event: ctx.event,\n  });\n}\n","import type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { H3Event } from 'nitro/h3';\nimport { getRequestURL } from 'nitro/h3';\nimport { fail, json } from './actions';\nimport { parseRequestData, parseSearchParams } from './parse-request-data';\nimport { validateWithSchema } from './validate';\n\nexport type DefineServerRouteResult = Response | unknown;\n\nexport interface ServerRouteHandler<\n  TQuery = unknown,\n  TBody = unknown,\n  TResult = unknown,\n> {\n  (event: H3Event): Promise<Response>;\n  readonly _types: {\n    readonly query: TQuery;\n    readonly body: TBody;\n    readonly result: TResult;\n  };\n}\n\nexport type InferRouteQuery<T> =\n  T extends ServerRouteHandler<infer Q, any, any> ? Q : never;\nexport type InferRouteBody<T> =\n  T extends ServerRouteHandler<any, infer B, any> ? B : never;\nexport type InferRouteResult<T> =\n  T extends ServerRouteHandler<any, any, infer R>\n    ? Exclude<R, Response>\n    : never;\n\ntype OptionalSchema = StandardSchemaV1 | undefined;\ntype InferSchema<\n  TSchema extends OptionalSchema,\n  TFallback = unknown,\n> = TSchema extends StandardSchemaV1\n  ? StandardSchemaV1.InferOutput<TSchema>\n  : TFallback;\ntype ResolveDataSchema<\n  TInput extends OptionalSchema,\n  TQuery extends OptionalSchema,\n  TBody extends OptionalSchema,\n> = TInput extends StandardSchemaV1\n  ? StandardSchemaV1.InferOutput<TInput>\n  : TQuery extends StandardSchemaV1\n    ? TBody extends StandardSchemaV1\n      ?\n          | StandardSchemaV1.InferOutput<TQuery>\n          | StandardSchemaV1.InferOutput<TBody>\n      : StandardSchemaV1.InferOutput<TQuery>\n    : TBody extends StandardSchemaV1\n      ? StandardSchemaV1.InferOutput<TBody>\n      : unknown;\n\nexport interface DefineServerRouteContext<\n  TInput extends StandardSchemaV1 | undefined = undefined,\n  TQuery extends StandardSchemaV1 | undefined = undefined,\n  TBody extends StandardSchemaV1 | undefined = undefined,\n  TParams extends StandardSchemaV1 | undefined = undefined,\n> {\n  data: ResolveDataSchema<TInput, TQuery, TBody>;\n  query: InferSchema<TQuery, undefined>;\n  body: InferSchema<TBody, undefined>;\n  params: InferSchema<TParams, H3Event['context']['params']>;\n  event: H3Event;\n}\n\nexport interface DefineServerRouteOptions<\n  TInput extends StandardSchemaV1 | undefined = undefined,\n  TOutput extends StandardSchemaV1 | undefined = undefined,\n  TQuery extends StandardSchemaV1 | undefined = undefined,\n  TBody extends StandardSchemaV1 | undefined = undefined,\n  TParams extends StandardSchemaV1 | undefined = undefined,\n  TResult extends DefineServerRouteResult = DefineServerRouteResult,\n> {\n  input?: TInput;\n  query?: TQuery;\n  body?: TBody;\n  params?: TParams;\n  output?: TOutput;\n  handler: (\n    context: DefineServerRouteContext<TInput, TQuery, TBody, TParams>,\n  ) => Promise<TResult> | TResult;\n}\n\nfunction isDevEnvironment() {\n  return (\n    typeof process !== 'undefined' &&\n    (process.env['NODE_ENV'] === 'development' ||\n      process.env['NODE_ENV'] === 'test')\n  );\n}\n\nfunction warnOnOutputIssues(issues: ReadonlyArray<StandardSchemaV1.Issue>) {\n  console.warn(\n    `[analog] Server route output validation failed:\\n` +\n      issues\n        .map((i) => {\n          const path = i.path\n            ? ` at \"${i.path.map((p) => (typeof p === 'object' ? (p as { key: string }).key : p)).join('.')}\"`\n            : '';\n          return `  - ${i.message}${path}`;\n        })\n        .join('\\n'),\n  );\n}\n\nfunction getRequestUrl(event: H3Event): string {\n  try {\n    return getRequestURL(event).href;\n  } catch {\n    return (event as H3Event & { request: Request }).request.url;\n  }\n}\n\n/**\n * Creates an h3-compatible event handler with Standard Schema validation.\n *\n * - `input` schema validates the request body (POST/PUT/PATCH) or query\n *   params (GET). Returns 422 with `StandardSchemaV1.Issue[]` on failure.\n * - `output` schema validates the response in development only (stripped\n *   in production for zero overhead). Logs a warning on mismatch.\n * - Plain return values are serialized with `json(...)`; raw `Response`\n *   objects are returned unchanged.\n *\n * @example\n * ```typescript\n * import { defineServerRoute } from '@analogjs/router/server/actions';\n * import * as v from 'valibot';\n *\n * const Input = v.object({\n *   name: v.pipe(v.string(), v.minLength(1)),\n *   email: v.pipe(v.string(), v.email()),\n * });\n * const Output = v.object({\n *   id: v.string(),\n *   name: v.string(),\n * });\n *\n * export default defineServerRoute({\n *   input: Input,\n *   output: Output,\n *   handler: async ({ data }) => {\n *     const user = await db.users.create(data);\n *     return user;\n *   },\n * });\n * ```\n */\nexport function defineServerRoute<\n  TInput extends StandardSchemaV1 | undefined = undefined,\n  TOutput extends StandardSchemaV1 | undefined = undefined,\n  TQuery extends StandardSchemaV1 | undefined = undefined,\n  TBody extends StandardSchemaV1 | undefined = undefined,\n  TParams extends StandardSchemaV1 | undefined = undefined,\n  TResult extends DefineServerRouteResult = DefineServerRouteResult,\n>(\n  options: DefineServerRouteOptions<\n    TInput,\n    TOutput,\n    TQuery,\n    TBody,\n    TParams,\n    TResult\n  >,\n): ServerRouteHandler<\n  InferSchema<TQuery, undefined>,\n  InferSchema<TBody, undefined>,\n  TResult\n> {\n  return (async (event: H3Event): Promise<Response> => {\n    const method = event.method.toUpperCase();\n    let data: unknown;\n    let query: unknown;\n    let body: unknown;\n    let params: unknown = event.context?.params ?? {};\n\n    if (options.params) {\n      const paramsResult = await validateWithSchema(options.params, params);\n      if (paramsResult.issues) {\n        return fail(422, paramsResult.issues);\n      }\n      params = paramsResult.value;\n    }\n\n    if (options.input) {\n      data = await parseRequestData(event);\n\n      const inputResult = await validateWithSchema(options.input, data);\n      if (inputResult.issues) {\n        return fail(422, inputResult.issues);\n      }\n      data = inputResult.value;\n    } else {\n      if (options.query) {\n        const url = new URL(getRequestUrl(event), 'http://localhost');\n        const queryResult = await validateWithSchema(\n          options.query,\n          parseSearchParams(url.searchParams),\n        );\n        if (queryResult.issues) {\n          return fail(422, queryResult.issues);\n        }\n        query = queryResult.value;\n      }\n\n      if (options.body && method !== 'GET' && method !== 'HEAD') {\n        body = await parseRequestData(event);\n        const bodyResult = await validateWithSchema(options.body, body);\n        if (bodyResult.issues) {\n          return fail(422, bodyResult.issues);\n        }\n        body = bodyResult.value;\n      }\n\n      if (method === 'GET' || method === 'HEAD') {\n        data = query;\n      } else if (body !== undefined) {\n        data = body;\n      } else {\n        data = query;\n      }\n    }\n\n    const result = await options.handler({\n      data: data as ResolveDataSchema<TInput, TQuery, TBody>,\n      query: query as InferSchema<TQuery, undefined>,\n      body: body as InferSchema<TBody, undefined>,\n      params: params as InferSchema<TParams, H3Event['context']['params']>,\n      event,\n    });\n\n    if (result instanceof Response) {\n      return result;\n    }\n\n    if (options.output && isDevEnvironment()) {\n      const outputResult = await validateWithSchema(options.output, result);\n      if (outputResult.issues) {\n        warnOnOutputIssues(outputResult.issues);\n      }\n    }\n\n    return json(result);\n  }) as ServerRouteHandler<\n    InferSchema<TQuery, undefined>,\n    InferSchema<TBody, undefined>,\n    TResult\n  >;\n}\n","import type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { H3Event, H3EventContext } from 'nitro/h3';\nimport { getRequestURL } from 'nitro/h3';\nimport type { $Fetch } from 'nitro/types';\nimport { fail } from './actions';\nimport { parseSearchParams } from './parse-request-data';\nimport { validateWithSchema } from './validate';\n\ntype NodeContext = NonNullable<H3Event['node']>;\ntype OptionalSchema = StandardSchemaV1 | undefined;\ntype InferSchema<\n  TSchema extends OptionalSchema,\n  TFallback,\n> = TSchema extends StandardSchemaV1\n  ? StandardSchemaV1.InferOutput<TSchema>\n  : TFallback;\n\nexport interface PageLoadContext<\n  TParamsSchema extends OptionalSchema = undefined,\n  TQuerySchema extends OptionalSchema = undefined,\n> {\n  params: InferSchema<TParamsSchema, H3EventContext['params']>;\n  query: InferSchema<\n    TQuerySchema,\n    Record<string, string | string[] | undefined>\n  >;\n  req: NodeContext['req'];\n  res: NonNullable<NodeContext['res']>;\n  fetch: $Fetch;\n  event: H3Event;\n}\n\nexport interface DefinePageLoadOptions<\n  TParamsSchema extends OptionalSchema = undefined,\n  TQuerySchema extends OptionalSchema = undefined,\n  TResult = unknown,\n> {\n  params?: TParamsSchema;\n  query?: TQuerySchema;\n  handler: (\n    context: PageLoadContext<TParamsSchema, TQuerySchema>,\n  ) => Promise<TResult> | TResult;\n}\n\n/**\n * Creates a typed page server load function with optional\n * Standard Schema validation for route params and query.\n *\n * Follows the same validation patterns as `defineAction` and\n * `defineServerRoute`: validates before invoking the handler,\n * returns `fail(422, issues)` on validation failure.\n *\n * @example\n * ```typescript\n * // src/app/pages/users/[id].server.ts\n * import { definePageLoad } from '@analogjs/router/server/actions';\n * import * as v from 'valibot';\n *\n * export const routeParamsSchema = v.object({\n *   id: v.pipe(v.string(), v.regex(/^\\d+$/)),\n * });\n *\n * export const load = definePageLoad({\n *   params: routeParamsSchema,\n *   handler: async ({ params, fetch }) => {\n *     // params.id is typed as string (validated)\n *     const user = await fetch(`/api/users/${params.id}`);\n *     return user;\n *   },\n * });\n * ```\n */\nexport function definePageLoad<\n  TParamsSchema extends OptionalSchema = undefined,\n  TQuerySchema extends OptionalSchema = undefined,\n  TResult = unknown,\n>(\n  options: DefinePageLoadOptions<TParamsSchema, TQuerySchema, TResult>,\n): (ctx: {\n  params: H3EventContext['params'];\n  req: NodeContext['req'];\n  res: NonNullable<NodeContext['res']>;\n  fetch: $Fetch;\n  event: H3Event;\n}) => Promise<TResult | Response> {\n  type Params = InferSchema<TParamsSchema, H3EventContext['params']>;\n  type Query = InferSchema<\n    TQuerySchema,\n    Record<string, string | string[] | undefined>\n  >;\n\n  return async (ctx: {\n    params: H3EventContext['params'];\n    req: NodeContext['req'];\n    res: NonNullable<NodeContext['res']>;\n    fetch: $Fetch;\n    event: H3Event;\n  }) => {\n    let params: unknown = ctx.params ?? {};\n\n    let requestUrl: string;\n    try {\n      requestUrl = getRequestURL(ctx.event).href;\n    } catch {\n      requestUrl = (ctx.event as H3Event & { request: Request }).request.url;\n    }\n    const url = new URL(requestUrl, 'http://localhost');\n    let query: unknown = parseSearchParams(url.searchParams);\n\n    // Validate params\n    if (options.params) {\n      const result = await validateWithSchema(options.params, params);\n      if (result.issues) {\n        return fail(422, result.issues);\n      }\n      params = result.value;\n    }\n\n    // Validate query\n    if (options.query) {\n      const result = await validateWithSchema(options.query, query);\n      if (result.issues) {\n        return fail(422, result.issues);\n      }\n      query = result.value;\n    }\n\n    return options.handler({\n      params: params as Params,\n      query: query as Query,\n      req: ctx.req,\n      res: ctx.res,\n      fetch: ctx.fetch,\n      event: ctx.event,\n    });\n  };\n}\n"],"mappings":"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"}