@torpor/build 0.4.14 → 1.0.0

package/src/types/PageData.test-d.ts

@@ -0,0 +1,136 @@
+import found from "../response/found";
+import ok from "../response/ok";
+import type TypedResponse from "../response/TypedResponse";
+import type { MergePageData, PageData } from "./PageData";
+import type PageEndPoint from "./PageEndPoint";
+import type PageLoadEvent from "./PageLoadEvent";
+import type PageProps from "./PageProps";
+import type PageServerEndPoint from "./PageServerEndPoint";
+
+type Equals<A, B> =
+	(<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
+type Expect<T extends true> = T;
+
+interface Post {
+	title: string;
+}
+
+// A server endpoint whose load returns typed data
+interface PostsServer {
+	load: () => Promise<TypedResponse<{ posts: { title: string }[] }>>;
+}
+
+export const server: PostsServer = {
+	load: async () => ok({ posts: [{ title: "Hello" }] }),
+};
+
+// The shape above is a valid +page.server endpoint
+export const serverCompat: PageServerEndPoint<"/posts"> = server;
+
+// PageData extracts the Jsonify'd body of the load's typed responses
+export type D01 = Expect<Equals<PageData<PostsServer>, { posts: { title: string }[] }>>;
+
+// Dates are Jsonify'd to strings through ok()
+interface ClockServer {
+	load: () => Promise<TypedResponse<{ now: string }>>;
+}
+
+export const clockServer: ClockServer = {
+	load: async () => ok({ now: new Date() }),
+};
+
+export type D02 = Expect<Equals<PageData<ClockServer>, { now: string }>>;
+
+// Endpoints without a load fall back to a loose record
+export const actionsOnly: PageServerEndPoint<"/posts"> = {
+	actions: { default: async () => ok({}) },
+};
+export type D03 = Expect<Equals<PageData<typeof actionsOnly>, Record<string, any>>>;
+
+// Untyped loads (redirects etc) fall back to a loose record
+export const untypedLoad: PageServerEndPoint<"/posts"> = {
+	load: async () => found("/elsewhere"),
+};
+export type D04 = Expect<Equals<PageData<typeof untypedLoad>, Record<string, any>>>;
+
+// The page endpoint: data keys are checked against Data
+export const page: PageEndPoint<"/posts", PageData<PostsServer>> = {
+	load: async () => ok({ posts: [{ title: "Hello" }] }),
+};
+
+export const badPage: PageEndPoint<"/posts", PageData<PostsServer>> = {
+	// @ts-expect-error 'comments' is not part of the page's data
+	load: async () => ok({ comments: [] }),
+};
+
+// Untyped responses (redirects etc) are always allowed
+export const redirecting: PageEndPoint<"/posts", PageData<PostsServer>> = {
+	load: async () => found("/elsewhere"),
+};
+
+// Loads with no return are allowed
+export const silent: PageEndPoint<"/posts", PageData<PostsServer>> = {
+	load: async () => {},
+};
+
+// Server endpoints are checked the same way
+export const checkedServer: PageServerEndPoint<"/posts", { posts: Post[] }> = {
+	load: async () => ok({ posts: [{ title: "Hello" }] }),
+};
+
+export const badServer: PageServerEndPoint<"/posts", { posts: Post[] }> = {
+	// @ts-expect-error wrong data shape is flagged on the server endpoint too
+	load: async () => ok({ posts: "not an array" }),
+};
+
+// PageProps: the shape page components receive
+const props: PageProps<PageData<PostsServer>> = null as never;
+export const posts: { title: string }[] = props.data.posts;
+export const form: Record<string, any> | undefined = props.form;
+
+// --- Layout data ---
+
+// A layout endpoint with its own typed load
+interface LayoutServer {
+	load: () => Promise<TypedResponse<{ user: { name: string } }>>;
+}
+
+export const layoutServer: LayoutServer = {
+	load: async () => ok({ user: { name: "Andrew" } }),
+};
+
+// MergePageData intersects layout and page data, in order
+export type M01 = Expect<
+	Equals<
+		MergePageData<[typeof layoutServer, PostsServer]>,
+		{ user: { name: string } } & { posts: { title: string }[] }
+	>
+>;
+
+// A single endpoint merges to its own data
+export type M02 = Expect<Equals<MergePageData<[PostsServer]>, { posts: { title: string }[] }>>;
+
+// The merged shape is what the page component receives as $props.data
+const mergedProps: PageProps<MergePageData<[typeof layoutServer, PostsServer]>> = null as never;
+export const userName: string = mergedProps.data.user.name;
+export const mergedPosts: { title: string }[] = mergedProps.data.posts;
+
+// Endpoints without a typed load contribute only looseness
+const looseProps: PageProps<MergePageData<[typeof actionsOnly, PostsServer]>> = null as never;
+export const loosePosts: { title: string }[] = looseProps.data.posts;
+
+// --- Client load events ---
+
+// event.data is typed by the second annotation, e.g. the layout's data
+export const clientLoad = (event: PageLoadEvent<"/posts", PageData<typeof layoutServer>>): void =>
+	void event.data.user.name;
+
+// 'nope' is not part of the accumulated layout data
+export const badClientLoad = (
+	event: PageLoadEvent<"/posts", PageData<typeof layoutServer>>,
+): void =>
+	// @ts-expect-error 'nope' is not part of the accumulated layout data
+	void event.data.nope;
+
+// Without a data annotation it stays loose
+export const looseClientLoad = (event: PageLoadEvent<"/posts">): void => void event.data.whatever;

package/src/types/PageData.ts

@@ -0,0 +1,35 @@
+import type TypedResponse from "../response/TypedResponse";
+
+/**
+ * The page data produced by an endpoint's `load` function, e.g.
+ *
+ * ```ts
+ * import type server from "./+page.server";
+ * type Data = PageData<typeof server>;
+ * ```
+ *
+ * Falls back to a loose record when the endpoint has no load or its load
+ * returns untyped responses.
+ */
+export type PageData<EndPoint> = EndPoint extends { load?: (event: any) => infer Return }
+	? NonNullable<Awaited<Return>> extends TypedResponse<infer Body>
+		? Body
+		: Record<string, any>
+	: Record<string, any>;
+
+/**
+ * The merged page data for a page that sits under one or more layouts: pass
+ * the layout endpoints first and the page endpoint last, e.g.
+ *
+ * ```ts
+ * import type layoutServer from "../_layout.server";
+ * import type server from "./+page.server";
+ * type Data = MergePageData<typeof layoutServer, typeof server>;
+ * ```
+ *
+ * Each endpoint's data is intersected in order; endpoints without a typed
+ * `load` contribute nothing but looseness.
+ */
+export type MergePageData<EndPoints extends any[]> = EndPoints extends [infer First, ...infer Rest]
+	? PageData<First> & MergePageData<Rest>
+	: unknown;

package/src/types/PageEndPoint.ts

@@ -1,21 +1,37 @@
 import { type Component } from "@torpor/view";
+import type { ExactRouteParams, ParseRouteParams, RouteParamsOf } from "./ParseRouteParams";
 import type PageLoadEvent from "./PageLoadEvent";
+import type { PageLoadReturn } from "./PageLoadReturn";
 
 /**
- * For +page.
+ * For +page. Annotate with a route path to get typed params, and with a data
+ * shape to flag loads that return keys the page doesn't expect, e.g.
+ * `PageEndPoint<"/posts/[id]", PageData<typeof server>>`.
  */
-export default interface PageEndPoint {
+export default interface PageEndPoint<
+	Route extends string | undefined = undefined,
+	Data = Record<string, any>,
+> {
 	/**
-	 * Builds the route path for the page in a type-safe manner.
-	 * TODO: Not sure this is actually the best way to do it...
+	 * Builds the route path for the page in a type-safe manner. The params
+	 * object is checked for exact keys when `Route` is annotated.
+	 *
+	 * NOTE: The rest args conditional must stay INLINE — routing it through a
+	 * type alias defeats `Params` inference, and excess keys stop being checked
 	 */
-	route?: (...args: any[]) => string;
+	route?: <Params extends RouteParamsOf<Route>>(
+		...args: Route extends string
+			? string extends Route
+				? [params?: Record<string, string>]
+				: keyof ParseRouteParams<Route> extends never
+					? []
+					: [params: Params & ExactRouteParams<Params, ParseRouteParams<Route>>]
+			: [params?: Record<string, string>]
+	) => string;
 	/**
 	 * Loads data for the page.
 	 */
-	load?: (
-		event: PageLoadEvent,
-	) => Response | undefined | void | Promise<Response | undefined | void>;
+	load?: (event: PageLoadEvent<Route>) => PageLoadReturn<Data> | Promise<PageLoadReturn<Data>>;
 	/**
 	 * The component that is displayed for the page.
 	 */
@@ -24,7 +40,7 @@ export default interface PageEndPoint {
 	/**
 	 * The head element data for the page, which may include a <title> and <meta> elements.
 	 */
-	head?: HeadElement[] | ((event: PageLoadEvent) => HeadElement[]);
+	head?: HeadElement[] | ((event: PageLoadEvent<Route>) => HeadElement[]);
 }
 
 type HeadElement = TitleElement | MetaElement;

package/src/types/PageForm.test-d.ts

@@ -0,0 +1,78 @@
+import badRequest from "../response/badRequest";
+import ok from "../response/ok";
+import type TypedResponse from "../response/TypedResponse";
+import type { PageData } from "./PageData";
+import type { PageForm } from "./PageForm";
+import type PageProps from "./PageProps";
+import type PageServerEndPoint from "./PageServerEndPoint";
+
+type Equals<A, B> =
+	(<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
+type Expect<T extends true> = T;
+
+// The docs-site form pattern: ok for success, badRequest for validation errors
+interface FormServer {
+	actions: {
+		default: () => Promise<TypedResponse<{ ok: true } | { ok: false; message: string }>>;
+	};
+}
+
+export const formServer: FormServer = {
+	actions: {
+		default: async () =>
+			Math.random() > 0.5
+				? ok({ ok: true as const })
+				: badRequest({ ok: false as const, message: "bad text" }),
+	},
+};
+
+// The shape above is a valid +page.server endpoint
+export const formServerCompat: PageServerEndPoint<"/form"> = formServer;
+
+// PageForm extracts the union of action result bodies
+export type F01 = Expect<
+	Equals<PageForm<FormServer>, { ok: true } | { ok: false; message: string }>
+>;
+
+// PageProps carries data and form together
+const props: PageProps<PageData<FormServer>, PageForm<FormServer>> = null as never;
+const form = props.form;
+export const okValue: boolean | undefined = form?.ok;
+export const message: string = form && form.ok === false ? form.message : "";
+
+// badRequest bodies are typed and Jsonify'd
+export const bad: TypedResponse<{ ok: false; message: string }> = badRequest({
+	ok: false,
+	message: "bad text",
+});
+export const untypedBad: Response = badRequest("plain");
+
+// Endpoints without actions fall back to a loose record
+interface LoadOnly {
+	load: () => Promise<TypedResponse<{ posts: { title: string }[] }>>;
+}
+export type F02 = Expect<Equals<PageForm<LoadOnly>, Record<string, any>>>;
+
+// Annotated (widened) endpoints fall back to a loose record
+export const widened: PageServerEndPoint<"/form"> = {
+	actions: { default: async () => ok({ ok: true }) },
+};
+export type F03 = Expect<Equals<PageForm<typeof widened>, Record<string, any>>>;
+
+// Multiple actions union their bodies
+interface MultiServer {
+	actions: {
+		save: () => Promise<TypedResponse<{ saved: true }>>;
+		remove: () => Promise<TypedResponse<{ removed: true }>>;
+	};
+}
+export type F04 = Expect<Equals<PageForm<MultiServer>, { saved: true } | { removed: true }>>;
+
+// Mixed typed and untyped action returns fall back to a loose record
+interface MixedServer {
+	actions: {
+		save: () => Promise<TypedResponse<{ saved: true }>>;
+		other: () => Promise<Response>;
+	};
+}
+export type F05 = Expect<Equals<PageForm<MixedServer>, Record<string, any>>>;

package/src/types/PageForm.ts

@@ -0,0 +1,29 @@
+import type TypedResponse from "../response/TypedResponse";
+
+/** The non-undefined return values of an endpoint's actions. */
+type ActionReturns<Actions> = {
+	[K in keyof Actions]: Actions[K] extends (event: any) => infer Return
+		? NonNullable<Awaited<Return>>
+		: never;
+}[keyof Actions];
+
+/**
+ * The form result an endpoint's actions produce, i.e. what becomes the page's
+ * `$props.form` after a submit, e.g.
+ *
+ * ```ts
+ * import type server from "./+page.server";
+ * type Form = PageForm<typeof server>;
+ * ```
+ *
+ * Actions returning typed responses (e.g. `ok({ ... })`, `badRequest({ ... })`)
+ * contribute their JSON bodies as a union. Falls back to a loose record when
+ * there are no actions or their responses are untyped.
+ */
+export type PageForm<EndPoint> = EndPoint extends { actions?: infer Actions }
+	? [NonNullable<Actions>] extends [never]
+		? Record<string, any>
+		: ActionReturns<NonNullable<Actions>> extends TypedResponse<infer Body>
+			? Body
+			: Record<string, any>
+	: Record<string, any>;

package/src/types/PageLoadEvent.ts

@@ -1,4 +1,15 @@
-export default interface PageLoadEvent {
+import type { RouteParamsOf } from "./ParseRouteParams";
+
+/**
+ * The event passed to client load functions. Annotate with a route path to
+ * get typed params, e.g. `PageLoadEvent<"/posts/[id]">`, and with a data type
+ * to type the data accumulated from the layouts above, e.g.
+ * `PageLoadEvent<"/posts/[id]", PageData<typeof layoutServer>>`.
+ */
+export default interface PageLoadEvent<
+	Route extends string | undefined = undefined,
+	Data = Record<string, any>,
+> {
 	/**
 	 * The URL for the server function.
 	 */
@@ -6,9 +17,10 @@ export default interface PageLoadEvent {
 	/**
 	 * Route params from the URL and route path.
 	 */
-	params: Record<string, string>;
+	params: RouteParamsOf<Route>;
 	/**
-	 * Data that is (optionally) loaded from the load function and passed into the page as $props.data.
+	 * Data loaded by the layouts above, accumulated top down. Loads may add to
+	 * it, and the merged result is passed into the page as `$props.data`.
 	 */
-	data: Record<string, any>;
+	data: Data;
 }

package/src/types/PageLoadReturn.ts

@@ -0,0 +1,13 @@
+import type TypedResponse from "../response/TypedResponse";
+import type { UntypedResponse } from "../response/TypedResponse";
+
+/**
+ * What a load function may return. When `Data` is provided, a typed response
+ * (e.g. `ok({ ... })`) must only contain keys the page expects; untyped
+ * responses (redirects, errors, plain text) are always allowed.
+ */
+export type PageLoadReturn<Data> =
+	| TypedResponse<Partial<Data>>
+	| UntypedResponse
+	| undefined
+	| void;

package/src/types/PageProps.ts

@@ -0,0 +1,14 @@
+/**
+ * The props passed to a page (or layout) component: the data accumulated from
+ * load functions, plus the result of the last form action if any.
+ */
+export default interface PageProps<Data = Record<string, any>, Form = Record<string, any>> {
+	/**
+	 * Data loaded by the page's (and its layouts') load functions.
+	 */
+	data: Data;
+	/**
+	 * The JSON result of the last form action, if a form was submitted.
+	 */
+	form: Form | undefined;
+}

package/src/types/PageServerAction.ts

@@ -1,7 +1,13 @@
+import type { RouteParamsOf } from "./ParseRouteParams";
+import type { FormDataRecord, QueryRecord } from "./ServerLoadEvent";
 import type ServerLoadEvent from "./ServerLoadEvent";
 
-type PageServerAction = (
-	event: ServerLoadEvent,
+type PageServerAction<
+	Route extends string | undefined = undefined,
+	FormBody = FormDataRecord,
+	Params = RouteParamsOf<Route>,
+> = (
+	event: ServerLoadEvent<Route, unknown, FormBody, QueryRecord, Params>,
 ) => Response | undefined | void | Promise<Response | undefined | void>;
 
 export default PageServerAction;

package/src/types/PageServerEndPoint.test-d.ts

@@ -0,0 +1,105 @@
+import ok from "../response/ok";
+import type {
+	ActionBody,
+	LoadParams,
+	LoadQuery,
+	PageServerActionSchemas,
+} from "./PageServerEndPoint";
+import type PageServerEndPoint from "./PageServerEndPoint";
+import type { StandardSchemaV1 } from "./StandardSchema";
+
+type Equals<A, B> =
+	(<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
+type Expect<T extends true> = T;
+
+// A mock schema library's schema, with input and output types
+declare const postSchema: StandardSchemaV1<{ title: string }, { title: string; upper: string }>;
+declare const querySchema: StandardSchemaV1<{ page: string }, { page: number }>;
+declare const paramsSchema: StandardSchemaV1<{ id: string }, { id: number }>;
+
+const schemas: { default: typeof postSchema } = { default: postSchema };
+
+// An endpoint declaring a schema for its default action. The `.upper` access
+// below compiles only when form() is contextually typed from the schema's
+// output, since actions map their body to their schema's key
+export const endPoint: PageServerEndPoint<"/form", Record<string, any>, typeof schemas> = {
+	schema: schemas,
+	actions: {
+		default: async ({ form }) => ok({ title: (await form()).upper }),
+	},
+};
+
+// The type helpers behind the load/action signatures
+export type A01 = Expect<
+	Equals<ActionBody<typeof schemas, "default">, { title: string; upper: string }>
+>;
+export type A02 = Expect<
+	Equals<
+		ActionBody<typeof schemas, "missing">,
+		Record<string, FormDataEntryValue | FormDataEntryValue[]>
+	>
+>;
+export type A03 = Expect<
+	Equals<
+		ActionBody<PageServerActionSchemas, "default">,
+		Record<string, FormDataEntryValue | FormDataEntryValue[]>
+	>
+>;
+
+// The load function's schema (the `load` key) types the query string
+const querySchemas: { load: typeof querySchema } = { load: querySchema };
+export type A04 = Expect<Equals<LoadQuery<typeof querySchemas>, { page: number }>>;
+export type A05 = Expect<
+	Equals<LoadQuery<PageServerActionSchemas>, Record<string, string | string[]>>
+>;
+
+// The `params` key types the params of the load function and actions
+const paramSchemas: { params: typeof paramsSchema } = { params: paramsSchema };
+export type A06 = Expect<Equals<LoadParams<typeof paramSchemas, "/posts/[id]">, { id: number }>>;
+export type A07 = Expect<
+	Equals<LoadParams<PageServerActionSchemas, "/posts/[id]">, { id: string }>
+>;
+
+// An endpoint using all of them: the `page` access below compiles only when
+// the load's query is typed from its schema
+export const fullEndPoint: PageServerEndPoint<
+	"/posts/[id]",
+	Record<string, any>,
+	{ params: typeof paramsSchema; load: typeof querySchema; default: typeof postSchema }
+> = {
+	schema: {
+		params: paramsSchema,
+		load: querySchema,
+		default: postSchema,
+	},
+	load: async ({ params, query }) => ok({ id: params.id, page: (await query()).page }),
+	actions: {
+		default: async ({ params, form }) => ok({ id: params.id, title: (await form()).upper }),
+	},
+};
+
+// An untyped action keeps the loose form record and string params
+type PlainAction = NonNullable<NonNullable<typeof plainEndPoint.actions>["default"]>;
+const plainEndPoint: PageServerEndPoint<"/form"> = {
+	actions: {
+		default: async ({ form }) => ok({ title: (await form()).title }),
+	},
+};
+type PlainEvent = Parameters<PlainAction>[0];
+export type A08 = Expect<
+	Equals<
+		Awaited<ReturnType<PlainEvent["form"]>>,
+		Record<string, FormDataEntryValue | FormDataEntryValue[]>
+	>
+>;
+
+// Typed ok() bodies still flow through actions (PageForm's source)
+type DefaultReturn = Awaited<
+	ReturnType<NonNullable<NonNullable<typeof endPoint.actions>["default"]>>
+>;
+export type A09 = Expect<Equals<DefaultReturn, Response | undefined | void>>;
+
+// The schema property is optional, as before
+export type A10 = Expect<
+	Equals<PageServerEndPoint extends { schema?: unknown } ? true : false, true>
+>;

package/src/types/PageServerEndPoint.ts

@@ -1,16 +1,110 @@
+import type { RouteParamsOf } from "./ParseRouteParams";
 import type PageServerAction from "./PageServerAction";
 import type PageServerLoad from "./PageServerLoad";
+import type { FormDataRecord, QueryRecord } from "./ServerLoadEvent";
+import type { StandardSchemaV1 } from "./StandardSchema";
 
 /**
- * For +page.server.
+ * Optional standard schemas for +page.server endpoints, keyed by name. Any
+ * schema implementing the Standard Schema interface (zod, valibot, arktype,
+ * etc) can be used.
+ *
+ * - action name schemas validate the submitted form data, surfaced through
+ *   `event.form()` in the action
+ * - the `load` key validates the URL's query string, surfaced through
+ *   `event.query()` in the load function
+ * - a `params` key validates (and generally coerces) the route params,
+ *   surfaced through `event.params` in the load function and actions
+ *
+ * When a submitted form or query string fails validation, the action or load
+ * function is not called and a 422 response with the schema's issues is
+ * returned (which becomes the page's `$props.form` for actions). When route
+ * params fail validation, a 404 response is returned, since the URL can't
+ * refer to an existing resource.
  */
-export default interface PageServerEndPoint {
+export type PageServerActionSchemas = {
+	params?: StandardSchemaV1;
+	load?: StandardSchemaV1;
+	[action: string]: StandardSchemaV1 | undefined;
+};
+
+/**
+ * The form values type for an action, inferred from its schema. Falls back
+ * to a loose record for actions without a declared schema.
+ */
+export type ActionBody<Schemas extends PageServerActionSchemas, Name extends string> = [
+	Name,
+] extends [keyof Schemas & string]
+	? Schemas[Name] extends StandardSchemaV1
+		? StandardSchemaV1.InferOutput<Schemas[Name]>
+		: FormDataRecord
+	: FormDataRecord;
+
+/**
+ * The query type for the load function, inferred from its schema.
+ */
+export type LoadQuery<Schemas extends PageServerActionSchemas> = Schemas extends {
+	load: StandardSchemaV1;
+}
+	? StandardSchemaV1.InferOutput<Schemas["load"]>
+	: QueryRecord;
+
+/**
+ * The route params type, inferred from the `params` schema.
+ */
+export type LoadParams<
+	Schemas extends PageServerActionSchemas,
+	Route extends string | undefined,
+> = Schemas extends { params: StandardSchemaV1 }
+	? StandardSchemaV1.InferOutput<Schemas["params"]>
+	: RouteParamsOf<Route>;
+
+/**
+ * For +page.server. Annotate with a route path to get typed params, and with
+ * a data shape to flag loads that return keys the page doesn't expect, e.g.
+ * `PageServerEndPoint<"/posts/[id]", { posts: Post[] }>`. Annotate with a
+ * schemas object to get typed (and validated) form values, query strings and
+ * params, e.g. `PageServerEndPoint<"/posts", Record<string, any>, typeof schema>`.
+ */
+export default interface PageServerEndPoint<
+	Route extends string | undefined = undefined,
+	Data = Record<string, any>,
+	Schemas extends PageServerActionSchemas = PageServerActionSchemas,
+> {
 	/**
-	 * Loads data from the server for a page.
+	 * Loads data from the server for a page. Its schema (the `load` key)
+	 * validates the URL's query string.
 	 */
-	load?: PageServerLoad;
+	load?: PageServerLoad<Route, Data, LoadQuery<Schemas>, LoadParams<Schemas, Route>>;
 	/**
 	 * A map of actions that can be performed on the server for a page, generally from a form submit.
 	 */
-	actions?: Record<string, PageServerAction>;
+	actions?: {
+		[Name in string]: PageServerAction<
+			Route,
+			ActionBody<Schemas, Name>,
+			LoadParams<Schemas, Route>
+		>;
+	};
+	/**
+	 * Optional standard schemas for validating requests, keyed by action name
+	 * (plus `load` for the query string and `params` for the route params),
+	 * e.g.
+	 *
+	 * ```ts
+	 * const schema = {
+	 *   params: z.object({ id: z.coerce.number() }),
+	 *   load: z.object({ page: z.coerce.number() }),
+	 *   default: z.object({ title: z.string() }),
+	 * };
+	 * export default {
+	 *   schema,
+	 *   load: async ({ query }) => ok(await query()),
+	 *   actions: {
+	 *     default: async ({ form }) => ok((await form()).title),
+	 *   },
+	 * } satisfies PageServerEndPoint<"/posts/[id]", Record<string, any>, typeof schema>;
+	 * ```
+	 */
+	schema?: Schemas | undefined;
 }

package/src/types/PageServerLoad.ts

@@ -1,7 +1,15 @@
+import type { RouteParamsOf } from "./ParseRouteParams";
+import type { PageLoadReturn } from "./PageLoadReturn";
+import type { FormDataRecord, QueryRecord } from "./ServerLoadEvent";
 import type ServerLoadEvent from "./ServerLoadEvent";
 
-type PageServerLoad = (
-	event: ServerLoadEvent,
-) => Response | undefined | void | Promise<Response | undefined | void>;
+type PageServerLoad<
+	Route extends string | undefined = undefined,
+	Data = Record<string, any>,
+	QueryBody = QueryRecord,
+	Params = RouteParamsOf<Route>,
+> = (
+	event: ServerLoadEvent<Route, unknown, FormDataRecord, QueryBody, Params>,
+) => PageLoadReturn<Data> | Promise<PageLoadReturn<Data>>;
 
 export default PageServerLoad;