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

package/fesm2022/routes.mjs

@@ -1,301 +1,28 @@
-import { NavigationEnd, Router, UrlSegment } from "@angular/router";
+import { n as ANALOG_ROUTE_FILES, r as createRoutes$1 } from "./route-files.mjs";
 import { InjectionToken, inject } from "@angular/core";
-import { HttpClient } from "@angular/common/http";
-import { firstValueFrom } from "rxjs";
-import { injectAPIPrefix, injectBaseURL, injectInternalServerFetch } from "@analogjs/router/tokens";
-import { Meta } from "@angular/platform-browser";
-import { filter } from "rxjs/operators";
-//#region packages/router/src/lib/meta-tags.ts
-var ROUTE_META_TAGS_KEY = Symbol("@analogjs/router Route Meta Tags Key");
-var CHARSET_KEY = "charset";
-var HTTP_EQUIV_SELECTOR_KEY = "http-equiv";
-var NAME_KEY = "name";
-var PROPERTY_KEY = "property";
-var ITEMPROP_KEY = "itemprop";
-function updateMetaTagsOnRouteChange() {
-	const router = inject(Router);
-	const metaService = inject(Meta);
-	router.events.pipe(filter((event) => event instanceof NavigationEnd)).subscribe(() => {
-		const metaTagMap = getMetaTagMap(router.routerState.snapshot.root);
-		for (const metaTagSelector in metaTagMap) {
-			const metaTag = metaTagMap[metaTagSelector];
-			metaService.updateTag(metaTag, metaTagSelector);
-		}
-	});
-}
-function getMetaTagMap(route) {
-	const metaTagMap = {};
-	let currentRoute = route;
-	while (currentRoute) {
-		const metaTags = currentRoute.data[ROUTE_META_TAGS_KEY] ?? [];
-		for (const metaTag of metaTags) metaTagMap[getMetaTagSelector(metaTag)] = metaTag;
-		currentRoute = currentRoute.firstChild;
-	}
-	return metaTagMap;
-}
-function getMetaTagSelector(metaTag) {
-	if (metaTag.name) return `${NAME_KEY}="${metaTag.name}"`;
-	if (metaTag.property) return `${PROPERTY_KEY}="${metaTag.property}"`;
-	if (metaTag.httpEquiv) return `${HTTP_EQUIV_SELECTOR_KEY}="${metaTag.httpEquiv}"`;
-	if (metaTag.itemprop) return `${ITEMPROP_KEY}="${metaTag.itemprop}"`;
-	return CHARSET_KEY;
-}
-//#endregion
-//#region packages/router/src/lib/endpoints.ts
-var ANALOG_META_KEY = Symbol("@analogjs/router Analog Route Metadata Key");
-/**
-* This variable reference is replaced with a glob of all route endpoints.
-*/
-var ANALOG_PAGE_ENDPOINTS = {};
-//#endregion
-//#region packages/router/src/lib/inject-route-endpoint-url.ts
-function injectRouteEndpointURL(route) {
-	const routeConfig = route.routeConfig;
-	const apiPrefix = injectAPIPrefix();
-	const baseUrl = injectBaseURL();
-	const { queryParams, fragment: hash, params, parent } = route;
-	const segment = parent?.url.map((segment) => segment.path).join("/") || "";
-	const url = new URL("", {
-		"BASE_URL": "/",
-		"DEV": false,
-		"MODE": "production",
-		"PROD": true,
-		"SSR": false
-	}["VITE_ANALOG_PUBLIC_BASE_URL"] || baseUrl || (typeof window !== "undefined" && window.location.origin ? window.location.origin : ""));
-	url.pathname = `${url.pathname.endsWith("/") ? url.pathname : url.pathname + "/"}${apiPrefix}/_analog${routeConfig[ANALOG_META_KEY].endpoint}`;
-	url.search = `${new URLSearchParams(queryParams).toString()}`;
-	url.hash = hash ?? "";
-	Object.keys(params).forEach((param) => {
-		url.pathname = url.pathname.replace(`[${param}]`, params[param]);
-	});
-	url.pathname = url.pathname.replace("**", segment);
-	return url;
-}
-//#endregion
-//#region packages/router/src/lib/route-config.ts
-function toRouteConfig(routeMeta) {
-	if (routeMeta && isRedirectRouteMeta(routeMeta)) return routeMeta;
-	const { meta, ...routeConfig } = routeMeta ?? {};
-	if (Array.isArray(meta)) routeConfig.data = {
-		...routeConfig.data,
-		[ROUTE_META_TAGS_KEY]: meta
-	};
-	else if (typeof meta === "function") routeConfig.resolve = {
-		...routeConfig.resolve,
-		[ROUTE_META_TAGS_KEY]: meta
-	};
-	routeConfig.runGuardsAndResolvers = routeConfig.runGuardsAndResolvers ?? "paramsOrQueryParamsChange";
-	routeConfig.resolve = {
-		...routeConfig.resolve,
-		load: async (route) => {
-			if (ANALOG_PAGE_ENDPOINTS[route.routeConfig[ANALOG_META_KEY].endpointKey]) {
-				const http = inject(HttpClient);
-				const url = injectRouteEndpointURL(route);
-				const internalFetch = injectInternalServerFetch();
-				if (internalFetch) return internalFetch(url.pathname);
-				if (!!{
-					"BASE_URL": "/",
-					"DEV": false,
-					"MODE": "production",
-					"PROD": true,
-					"SSR": false
-				}["VITE_ANALOG_PUBLIC_BASE_URL"] && globalThis.$fetch) return globalThis.$fetch(url.pathname);
-				return firstValueFrom(http.get(`${url.href}`));
-			}
-			return {};
-		}
-	};
-	return routeConfig;
-}
-function isRedirectRouteMeta(routeMeta) {
-	return !!routeMeta.redirectTo;
-}
-//#endregion
-//#region packages/router/src/lib/markdown-helpers.ts
-var isNgZoneEnabled = typeof Zone !== "undefined" && !!Zone.root;
-function toMarkdownModule(markdownFileFactory) {
-	return async () => {
-		const createLoader = () => Promise.all([import("@analogjs/content"), markdownFileFactory()]);
-		const [{ parseRawContentFile, MarkdownRouteComponent, ContentRenderer }, markdownFile] = await (isNgZoneEnabled ? Zone.root.run(createLoader) : createLoader());
-		const { content, attributes } = parseRawContentFile(markdownFile);
-		const { title, meta } = attributes;
-		return {
-			default: MarkdownRouteComponent,
-			routeMeta: {
-				data: { _analogContent: content },
-				title,
-				meta,
-				resolve: { renderedAnalogContent: async () => {
-					const rendered = await inject(ContentRenderer).render(content);
-					return typeof rendered === "string" ? rendered : rendered.content;
-				} }
-			}
-		};
-	};
-}
-//#endregion
-//#region packages/router/src/lib/constants.ts
-var ENDPOINT_EXTENSION = ".server.ts";
-//#endregion
 //#region packages/router/src/lib/routes.ts
 /**
-* This variable reference is replaced with a glob of all page routes.
-*/
-var ANALOG_ROUTE_FILES = {};
-/**
-* This variable reference is replaced with a glob of all content routes.
-*/
-var ANALOG_CONTENT_ROUTE_FILES = {};
-/**
 * A function used to parse list of files and create configuration of routes.
 *
 * @param files
 * @returns Array of routes
 */
 function createRoutes(files, debug = false) {
-	const filenames = Object.keys(files);
-	if (filenames.length === 0) return [];
-	const rawRoutesByLevelMap = filenames.reduce((acc, filename) => {
-		const rawPath = toRawPath(filename);
-		const rawSegments = rawPath.split("/");
-		const level = rawSegments.length - 1;
-		const rawSegment = rawSegments[level];
-		const ancestorRawSegments = rawSegments.slice(0, level);
-		return {
-			...acc,
-			[level]: {
-				...acc[level],
-				[rawPath]: {
-					filename,
-					rawSegment,
-					ancestorRawSegments,
-					segment: toSegment(rawSegment),
-					level,
-					children: []
-				}
-			}
-		};
-	}, {});
-	const allLevels = Object.keys(rawRoutesByLevelMap).map(Number);
-	const maxLevel = Math.max(...allLevels);
-	for (let level = maxLevel; level > 0; level--) {
-		const rawRoutesMap = rawRoutesByLevelMap[level];
-		const rawPaths = Object.keys(rawRoutesMap);
-		for (const rawPath of rawPaths) {
-			const rawRoute = rawRoutesMap[rawPath];
-			const parentRawPath = rawRoute.ancestorRawSegments.join("/");
-			const parentRawSegmentIndex = rawRoute.ancestorRawSegments.length - 1;
-			const parentRawSegment = rawRoute.ancestorRawSegments[parentRawSegmentIndex];
-			rawRoutesByLevelMap[level - 1] ||= {};
-			rawRoutesByLevelMap[level - 1][parentRawPath] ||= {
-				filename: null,
-				rawSegment: parentRawSegment,
-				ancestorRawSegments: rawRoute.ancestorRawSegments.slice(0, parentRawSegmentIndex),
-				segment: toSegment(parentRawSegment),
-				level: level - 1,
-				children: []
-			};
-			rawRoutesByLevelMap[level - 1][parentRawPath].children.push(rawRoute);
-		}
-	}
-	const rootRawRoutesMap = rawRoutesByLevelMap[0];
-	const rawRoutes = Object.keys(rootRawRoutesMap).map((segment) => rootRawRoutesMap[segment]);
-	sortRawRoutes(rawRoutes);
-	return toRoutes(rawRoutes, files, debug);
-}
-function toRawPath(filename) {
-	return filename.replace(/^(?:[a-zA-Z]:[\\/])?(.*?)[\\/](?:routes|pages)[\\/]|(?:[\\/](?:app[\\/](?:routes|pages)|src[\\/]content)[\\/])|(\.page\.(js|ts|analog|ag)$)|(\.(ts|md|analog|ag)$)/g, "").replace(/\[\[\.\.\.([^\]]+)\]\]/g, "(opt-$1)").replace(/\[\.{3}.+\]/, "**").replace(/\[([^\]]+)\]/g, ":$1");
+	return createRoutes$1(files, (_filename, fileLoader) => fileLoader, debug);
 }
-function toSegment(rawSegment) {
-	return rawSegment.replace(/index|\(.*?\)/g, "").replace(/\.|\/+/g, "/").replace(/^\/+|\/+$/g, "");
-}
-function createOptionalCatchAllMatcher(paramName) {
-	return (segments) => {
-		if (segments.length === 0) return null;
-		const joined = segments.map((s) => s.path).join("/");
-		return {
-			consumed: segments,
-			posParams: { [paramName]: new UrlSegment(joined, {}) }
-		};
-	};
-}
-function toRoutes(rawRoutes, files, debug = false) {
-	const routes = [];
-	for (const rawRoute of rawRoutes) {
-		const children = rawRoute.children.length > 0 ? toRoutes(rawRoute.children, files, debug) : void 0;
-		let module = void 0;
-		let analogMeta = void 0;
-		if (rawRoute.filename) {
-			const isMarkdownFile = rawRoute.filename.endsWith(".md");
-			if (!debug) module = isMarkdownFile ? toMarkdownModule(files[rawRoute.filename]) : files[rawRoute.filename];
-			const endpointKey = rawRoute.filename.replace(/\.page\.(ts|analog|ag)$/, ENDPOINT_EXTENSION);
-			analogMeta = {
-				endpoint: (rawRoute.filename.replace(/\.page\.(ts|analog|ag)$/, "").replace(/\[\[\.\.\..+\]\]/, "**").replace(/\[\.{3}.+\]/, "**").replace(/^(.*?)\/pages/, "/pages") || "").replace(/\./g, "/").replace(/\/\((.*?)\)$/, "/-$1-"),
-				endpointKey
-			};
-		}
-		const optCatchAllMatch = rawRoute.filename?.match(/\[\[\.\.\.([^\]]+)\]\]/);
-		const optCatchAllParam = optCatchAllMatch ? optCatchAllMatch[1] : null;
-		const route = module ? {
-			path: rawRoute.segment,
-			loadChildren: () => module().then((m) => {
-				return [{
-					path: "",
-					component: m.default,
-					...toRouteConfig(m.routeMeta),
-					children,
-					[ANALOG_META_KEY]: analogMeta
-				}, ...optCatchAllParam ? [{
-					matcher: createOptionalCatchAllMatcher(optCatchAllParam),
-					component: m.default,
-					...toRouteConfig(m.routeMeta),
-					[ANALOG_META_KEY]: analogMeta
-				}] : []];
-			})
-		} : {
-			path: rawRoute.segment,
-			...debug ? {
-				filename: rawRoute.filename ? rawRoute.filename : void 0,
-				isLayout: children && children.length > 0 ? true : false
-			} : {},
-			children
-		};
-		routes.push(route);
-	}
-	return routes;
-}
-function sortRawRoutes(rawRoutes) {
-	rawRoutes.sort((a, b) => {
-		let segmentA = deprioritizeSegment(a.segment);
-		let segmentB = deprioritizeSegment(b.segment);
-		if (a.children.length > b.children.length) segmentA = `~${segmentA}`;
-		else if (a.children.length < b.children.length) segmentB = `~${segmentB}`;
-		return segmentA > segmentB ? 1 : -1;
-	});
-	for (const rawRoute of rawRoutes) sortRawRoutes(rawRoute.children);
-}
-function deprioritizeSegment(segment) {
-	return segment.replace(":", "~~").replace("**", "~~~~");
-}
-var routes = createRoutes({
-	...ANALOG_ROUTE_FILES,
-	...ANALOG_CONTENT_ROUTE_FILES
-});
+var routes = createRoutes(ANALOG_ROUTE_FILES);
 //#endregion
 //#region packages/router/src/lib/debug/routes.ts
 var DEBUG_ROUTES = new InjectionToken("@analogjs/router debug routes", {
 	providedIn: "root",
 	factory() {
-		return createRoutes({
-			...ANALOG_ROUTE_FILES,
-			...ANALOG_CONTENT_ROUTE_FILES
-		}, true);
+		return createRoutes(ANALOG_ROUTE_FILES, true);
 	}
 });
 function injectDebugRoutes() {
 	return inject(DEBUG_ROUTES);
 }
 //#endregion
-export { updateMetaTagsOnRouteChange as a, injectRouteEndpointURL as i, createRoutes as n, routes as r, injectDebugRoutes as t };
+export { createRoutes as n, routes as r, injectDebugRoutes as t };
 
 //# sourceMappingURL=routes.mjs.map

package/fesm2022/routes.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.mjs","names":[],"sources":["../../src/lib/routes.ts","../../src/lib/debug/routes.ts"],"sourcesContent":["import type { Route } from '@angular/router';\n\nimport type { RouteExport } from './models';\nimport { createRoutes as createBaseRoutes } from './route-builder';\nimport { ANALOG_ROUTE_FILES, type Files } from './route-files';\n\n/**\n * A function used to parse list of files and create configuration of routes.\n *\n * @param files\n * @returns Array of routes\n */\nexport function createRoutes(files: Files, debug = false): Route[] {\n  return createBaseRoutes(\n    files,\n    (_filename, fileLoader) => fileLoader as () => Promise<RouteExport>,\n    debug,\n  );\n}\n\nexport { ANALOG_ROUTE_FILES } from './route-files';\n\nexport const routes: Route[] = createRoutes(ANALOG_ROUTE_FILES);\n","import { inject, InjectionToken } from '@angular/core';\nimport { Route } from '@angular/router';\n\nimport { ANALOG_ROUTE_FILES, createRoutes } from '../routes';\n\nexport const DEBUG_ROUTES: InjectionToken<(Route & DebugRoute)[]> =\n  new InjectionToken<(Route & DebugRoute)[]>('@analogjs/router debug routes', {\n    providedIn: 'root',\n    factory() {\n      const debugRoutes = createRoutes(ANALOG_ROUTE_FILES, true);\n\n      return debugRoutes as (Route & DebugRoute)[];\n    },\n  });\n\nexport type DebugRoute = {\n  path: string;\n  filename: string;\n  isLayout: boolean;\n  children?: DebugRoute[];\n};\n\nexport function injectDebugRoutes(): (Route & DebugRoute)[] {\n  return inject(DEBUG_ROUTES);\n}\n"],"mappings":";;;;;;;;;AAYA,SAAgB,aAAa,OAAc,QAAQ,OAAgB;AACjE,QAAO,eACL,QACC,WAAW,eAAe,YAC3B,MACD;;AAKH,IAAa,SAAkB,aAAa,mBAAmB;;;ACjB/D,IAAa,eACX,IAAI,eAAuC,iCAAiC;CAC1E,YAAY;CACZ,UAAU;AAGR,SAFoB,aAAa,oBAAyB,KAAA;;CAI7D,CAAC;AASJ,SAAgB,oBAA4C;AAC1D,QAAO,OAAO,aAAa"}

package/package.json

@@ -1,9 +1,49 @@
 {
   "name": "@analogjs/router",
-  "version": "3.0.0-alpha.3",
+  "version": "3.0.0-alpha.30",
   "description": "Filesystem-based routing for Angular",
   "type": "module",
   "author": "Brandon Roberts <robertsbt@gmail.com>",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/src/index.d.ts",
+      "import": "./fesm2022/analogjs-router.mjs",
+      "default": "./fesm2022/analogjs-router.mjs"
+    },
+    "./content": {
+      "types": "./types/content/src/index.d.ts",
+      "import": "./fesm2022/analogjs-router-content.mjs",
+      "default": "./fesm2022/analogjs-router-content.mjs"
+    },
+    "./server": {
+      "types": "./types/server/src/index.d.ts",
+      "import": "./fesm2022/analogjs-router-server.mjs",
+      "default": "./fesm2022/analogjs-router-server.mjs"
+    },
+    "./server/actions": {
+      "types": "./types/server/actions/src/index.d.ts",
+      "import": "./fesm2022/analogjs-router-server-actions.mjs",
+      "default": "./fesm2022/analogjs-router-server-actions.mjs"
+    },
+    "./tanstack-query": {
+      "types": "./types/tanstack-query/src/index.d.ts",
+      "import": "./fesm2022/analogjs-router-tanstack-query.mjs",
+      "default": "./fesm2022/analogjs-router-tanstack-query.mjs"
+    },
+    "./tanstack-query/server": {
+      "types": "./types/tanstack-query/server/src/index.d.ts",
+      "import": "./fesm2022/analogjs-router-tanstack-query-server.mjs",
+      "default": "./fesm2022/analogjs-router-tanstack-query-server.mjs"
+    },
+    "./tokens": {
+      "types": "./types/tokens/src/index.d.ts",
+      "import": "./fesm2022/analogjs-router-tokens.mjs",
+      "default": "./fesm2022/analogjs-router-tokens.mjs"
+    }
+  },
   "keywords": [
     "angular",
     "router",
@@ -24,12 +64,39 @@
     "url": "https://github.com/sponsors/brandonroberts"
   },
   "peerDependencies": {
-    "@analogjs/content": "^3.0.0-alpha.3",
+    "@analogjs/content": "3.0.0-alpha.30",
+    "@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/router": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0"
+    "@angular/platform-server": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0",
+    "@angular/router": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0",
+    "@tanstack/angular-query-experimental": ">=5.95.0",
+    "schema-dts": "^2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@analogjs/content": {
+      "optional": true
+    },
+    "@standard-schema/spec": {
+      "optional": true
+    },
+    "@angular/platform-server": {
+      "optional": true
+    },
+    "@tanstack/angular-query-experimental": {
+      "optional": true
+    },
+    "schema-dts": {
+      "optional": true
+    }
   },
   "dependencies": {
-    "tslib": "^2.0.0"
+    "@standard-schema/spec": "^1.1.0",
+    "es-toolkit": "^1.45.1",
+    "tslib": "^2.3.0"
+  },
+  "devDependencies": {
+    "@analogjs/vite-plugin-angular": "3.0.0-alpha.30",
+    "@analogjs/vitest-angular": "3.0.0-alpha.30"
   },
   "ng-update": {
     "packageGroup": [
@@ -49,26 +116,5 @@
   },
   "module": "fesm2022/analogjs-router.mjs",
   "typings": "types/src/index.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./types/src/index.d.ts",
-      "default": "./fesm2022/analogjs-router.mjs"
-    },
-    "./server": {
-      "types": "./types/server/src/index.d.ts",
-      "default": "./fesm2022/analogjs-router-server.mjs"
-    },
-    "./server/actions": {
-      "types": "./types/server/actions/src/index.d.ts",
-      "default": "./fesm2022/analogjs-router-server-actions.mjs"
-    },
-    "./tokens": {
-      "types": "./types/tokens/src/index.d.ts",
-      "default": "./fesm2022/analogjs-router-tokens.mjs"
-    }
-  },
   "sideEffects": false
 }

package/tanstack-query/package.json

@@ -0,0 +1,4 @@
+{
+  "module": "../fesm2022/analogjs-router-tanstack-query.mjs",
+  "typings": "../types/tanstack-query/src/index.d.ts"
+}

package/tanstack-query/server/package.json

@@ -0,0 +1,4 @@
+{
+  "module": "../../fesm2022/analogjs-router-tanstack-query-server.mjs",
+  "typings": "../../types/tanstack-query/server/src/index.d.ts"
+}

package/types/content/src/index.d.ts

@@ -0,0 +1,4 @@
+export { withContentRoutes } from './lib/with-content-routes';
+export { ANALOG_CONTENT_ROUTE_FILES, createContentRoutes } from './lib/routes';
+export type { Files } from './lib/routes';
+export { injectDebugContentRoutes } from './lib/debug/routes';

package/types/content/src/lib/debug/routes.d.ts

@@ -0,0 +1,10 @@
+import { InjectionToken } from '@angular/core';
+import { Route } from '@angular/router';
+export declare const DEBUG_CONTENT_ROUTES: InjectionToken<(Route & DebugRoute)[]>;
+export type DebugRoute = {
+    path: string;
+    filename: string;
+    isLayout: boolean;
+    children?: DebugRoute[];
+};
+export declare function injectDebugContentRoutes(): (Route & DebugRoute)[];

package/types/{src → content/src}/lib/markdown-helpers.d.ts

@@ -1,2 +1,2 @@
-import { RouteExport } from './models';
+import type { RouteExport } from '../../../src/lib/models';
 export declare function toMarkdownModule(markdownFileFactory: () => Promise<string>): () => Promise<RouteExport>;

package/types/content/src/lib/routes.d.ts

@@ -0,0 +1,8 @@
+import type { Route } from '@angular/router';
+import type { RouteExport } from '../../../src/lib/models';
+/**
+ * This variable reference is replaced with a glob of all content routes.
+ */
+export declare const ANALOG_CONTENT_ROUTE_FILES: {};
+export type Files = Record<string, () => Promise<RouteExport | string>>;
+export declare function createContentRoutes(files: Files, debug?: boolean): Route[];

package/types/content/src/lib/with-content-routes.d.ts

@@ -0,0 +1,2 @@
+import { type RouterFeatures } from '@angular/router';
+export declare function withContentRoutes(): RouterFeatures;

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

@@ -0,0 +1,54 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { H3Event, H3EventContext } from 'nitro/h3';
+import type { $Fetch } from 'nitro/types';
+type NodeContext = NonNullable<H3Event['node']>;
+type OptionalSchema = StandardSchemaV1 | undefined;
+type InferSchema<TSchema extends OptionalSchema, TFallback> = TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TFallback;
+export interface DefineActionContext<TSchema extends OptionalSchema = undefined, TParamsSchema extends OptionalSchema = undefined> {
+    data: InferSchema<TSchema, Record<string, unknown>>;
+    params: InferSchema<TParamsSchema, H3EventContext['params']>;
+    req: NodeContext['req'];
+    res: NonNullable<NodeContext['res']>;
+    fetch: $Fetch;
+    event: H3Event;
+}
+export interface DefineActionOptions<TSchema extends OptionalSchema = undefined, TParamsSchema extends OptionalSchema = undefined> {
+    schema?: TSchema;
+    params?: TParamsSchema;
+    handler: (context: DefineActionContext<TSchema, TParamsSchema>) => Promise<Response> | Response;
+}
+/**
+ * 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 });
+ *   },
+ * });
+ * ```
+ */
+export declare function defineAction<TSchema extends OptionalSchema = undefined, TParamsSchema extends OptionalSchema = undefined>(options: DefineActionOptions<TSchema, TParamsSchema>): (ctx: {
+    params: H3EventContext["params"];
+    req: NodeContext["req"];
+    res: NonNullable<NodeContext["res"]>;
+    fetch: $Fetch;
+    event: H3Event;
+}) => Promise<Response>;
+export {};

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

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

package/types/server/actions/src/define-page-load.d.ts

@@ -0,0 +1,55 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { H3Event, H3EventContext } from 'nitro/h3';
+import type { $Fetch } from 'nitro/types';
+type NodeContext = NonNullable<H3Event['node']>;
+type OptionalSchema = StandardSchemaV1 | undefined;
+type InferSchema<TSchema extends OptionalSchema, TFallback> = TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TFallback;
+export interface PageLoadContext<TParamsSchema extends OptionalSchema = undefined, TQuerySchema extends OptionalSchema = undefined> {
+    params: InferSchema<TParamsSchema, H3EventContext['params']>;
+    query: InferSchema<TQuerySchema, Record<string, string | string[] | undefined>>;
+    req: NodeContext['req'];
+    res: NonNullable<NodeContext['res']>;
+    fetch: $Fetch;
+    event: H3Event;
+}
+export interface DefinePageLoadOptions<TParamsSchema extends OptionalSchema = undefined, TQuerySchema extends OptionalSchema = undefined, TResult = unknown> {
+    params?: TParamsSchema;
+    query?: TQuerySchema;
+    handler: (context: PageLoadContext<TParamsSchema, TQuerySchema>) => Promise<TResult> | TResult;
+}
+/**
+ * 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;
+ *   },
+ * });
+ * ```
+ */
+export declare function definePageLoad<TParamsSchema extends OptionalSchema = undefined, TQuerySchema extends OptionalSchema = undefined, TResult = unknown>(options: DefinePageLoadOptions<TParamsSchema, TQuerySchema, TResult>): (ctx: {
+    params: H3EventContext['params'];
+    req: NodeContext['req'];
+    res: NonNullable<NodeContext['res']>;
+    fetch: $Fetch;
+    event: H3Event;
+}) => Promise<TResult | Response>;
+export {};