@torpor/build 0.4.13 → 1.0.0

package/dist/Site-CMa153FA.d.mts

@@ -0,0 +1,565 @@
+import { a as CookieHelper, i as HeaderHelper, t as Server } from "./Server-C_IKav_e.mjs";
+import { a as RouteParamsOf, n as ParseRouteParams, t as ExactRouteParams } from "./ParseRouteParams-DBmqlmLh.mjs";
+import { n as UntypedResponse, t as TypedResponse } from "./TypedResponse-6lznqN4U.mjs";
+import { t as StandardSchemaV1 } from "./StandardSchema-D28L8_zZ.mjs";
+import { Component } from "@torpor/view";
+import { Plugin, UserConfig } from "vite";
+//#region src/types/ServerLoadEvent.d.ts
+/**
+ * The values read from a form submission: one value per field, or an array
+ * when a field was submitted with multiple values (e.g. a multi select).
+ */
+type FormDataRecord = Record<string, FormDataEntryValue | FormDataEntryValue[]>;
+/**
+ * The values read from a URL's query string: one string per param, or an
+ * array when a param was repeated.
+ */
+type QueryRecord = Record<string, string | string[]>;
+/**
+ * The event passed to server functions. Annotate with a route path to get
+ * typed params, e.g. `ServerLoadEvent<"/posts/[id]">`, and with a body type
+ * to get typed request bodies in API endpoints, e.g.
+ * `ServerLoadEvent<"/api/posts", { title: string }>` — which also types the
+ * `body` param of client calls made with `makeApi`.
+ */
+interface ServerLoadEvent<Route extends string | undefined = undefined, Body = unknown, FormBody = FormDataRecord, QueryBody = QueryRecord, Params = RouteParamsOf<Route>> {
+  /**
+   * The URL for the server function.
+   */
+  url: URL;
+  /**
+   * Route params from the URL and route path. When the endpoint declares a
+   * `params` schema, the values are validated and typed by the schema's
+   * output.
+   */
+  params: Params;
+  /**
+   * Data that is available to functions in +server hooks, layouts, endpoints
+   * and pages. It flows down in that order.
+   */
+  appData: Record<string, any>;
+  /**
+   * The server request.
+   */
+  request: Request;
+  /**
+   * Reads the request body as JSON, typed by the event's `Body` annotation.
+   */
+  json: () => Promise<Body>;
+  /**
+   * Reads the request body as form data, returning a record of field values.
+   * When the endpoint declares a schema for the form, the values are
+   * validated and typed by the schema's output.
+   */
+  form: () => Promise<FormBody>;
+  /**
+   * Reads the URL's query string, returning a record of param values. When
+   * the endpoint declares a schema for the query (get/head handlers and the
+   * load function), the values are validated and typed by the schema's
+   * output.
+   */
+  query: () => Promise<QueryBody>;
+  /**
+   * A helper for getting and setting cookie data.
+   */
+  cookies: CookieHelper;
+  /**
+   * A helper for getting and setting headers.
+   */
+  headers: HeaderHelper;
+  /**
+   * An optional adapter object, containing adapter-specific functionality.
+   */
+  adapter: Record<PropertyKey, any>;
+}
+//#endregion
+//#region src/types/ServerHook.d.ts
+/**
+ * For _hook.server.
+ */
+interface ServerHook<Route extends string | undefined = undefined> {
+  /**
+   * Called before each server request is handled. Return a Response to
+   * short-circuit the request, skipping the load, action or view rendering
+   * (e.g. a redirect for unauthenticated users).
+   */
+  enter?: (event: ServerLoadEvent<Route>) => Promise<Response | void> | Response | void;
+  /**
+   * Called after the request has been handled, even if the handler threw
+   * an error or the enter hook short-circuited it.
+   */
+  exit?: (event: ServerLoadEvent<Route>) => Promise<void> | void;
+}
+//#endregion
+//#region src/types/Adapter.d.ts
+interface Adapter {
+  prebuild?: (site: Site) => Promise<void> | void;
+  postbuild?: (site: Site) => Promise<void> | void;
+  /**
+   * Vite plugin(s) used to drive dev mode. The adapter owns where server code
+   * runs (e.g. the default Node runtime, or workerd via miniflare) and how
+   * requests reach it. When omitted, the framework's default Node-runtime dev
+   * plugin is used.
+   */
+  dev?: (site: Site) => Plugin | Plugin[] | void;
+  /**
+   * Serve the built output (preview). Receives a torpor Server configured to
+   * load the built server entry.
+   */
+  serve: (server: Server, site: Site) => void;
+}
+//#endregion
+//#region src/types/SitePlugin.d.ts
+/**
+ * A Torpor site plugin. A plugin is a function that receives the Site and
+ * sets itself up on it, typically by registering routes (e.g. an OpenAPI
+ * document endpoint) or adding configuration.
+ *
+ * Plugins are added to `site.plugins` in the site config file, and are run
+ * once when the config is loaded (for dev and build), and once when the
+ * server starts up in production:
+ *
+ * ```ts
+ * import { Site } from "@torpor/build";
+ * import { openApi } from "@torpor/build/openapi";
+ *
+ * const site = new Site();
+ * site.addRouteFolder("src/routes");
+ * site.plugins = [openApi()];
+ * export default site;
+ * ```
+ */
+type SitePlugin = (site: Site) => void | Promise<void>;
+//#endregion
+//#region src/types/PageLoadEvent.d.ts
+/**
+ * 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>>`.
+ */
+interface PageLoadEvent<Route extends string | undefined = undefined, Data = Record<string, any>> {
+  /**
+   * The URL for the server function.
+   */
+  url: URL;
+  /**
+   * Route params from the URL and route path.
+   */
+  params: RouteParamsOf<Route>;
+  /**
+   * 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: Data;
+}
+//#endregion
+//#region src/types/PageLoadReturn.d.ts
+/**
+ * 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.
+ */
+type PageLoadReturn<Data> = TypedResponse<Partial<Data>> | UntypedResponse | undefined | void;
+//#endregion
+//#region src/types/PageEndPoint.d.ts
+/**
+ * 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>>`.
+ */
+interface PageEndPoint<Route extends string | undefined = undefined, Data = Record<string, any>> {
+  /**
+   * 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?: <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<Route>) => PageLoadReturn<Data> | Promise<PageLoadReturn<Data>>;
+  /**
+   * The component that is displayed for the page.
+   */
+  component?: Component;
+  /**
+   * The head element data for the page, which may include a <title> and <meta> elements.
+   */
+  head?: HeadElement[] | ((event: PageLoadEvent<Route>) => HeadElement[]);
+}
+type HeadElement = TitleElement | MetaElement;
+interface TitleElement {
+  title: string;
+}
+interface MetaElement {
+  name: string;
+  content: string;
+}
+//#endregion
+//#region src/types/PageServerAction.d.ts
+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>;
+//#endregion
+//#region src/types/PageServerLoad.d.ts
+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>>;
+//#endregion
+//#region src/types/PageServerEndPoint.d.ts
+/**
+ * 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.
+ */
+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.
+ */
+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.
+ */
+type LoadQuery<Schemas extends PageServerActionSchemas> = Schemas extends {
+  load: StandardSchemaV1;
+} ? StandardSchemaV1.InferOutput<Schemas["load"]> : QueryRecord;
+/**
+ * The route params type, inferred from the `params` schema.
+ */
+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>`.
+ */
+interface PageServerEndPoint<Route extends string | undefined = undefined, Data = Record<string, any>, Schemas extends PageServerActionSchemas = PageServerActionSchemas> {
+  /**
+   * Loads data from the server for a page. Its schema (the `load` key)
+   * validates the URL's query string.
+   */
+  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?: { [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;
+}
+//#endregion
+//#region src/types/ServerRequest.d.ts
+type ServerRequest<Route extends string | undefined = undefined, Body = unknown, FormBody = FormDataRecord, QueryBody = QueryRecord, Params = RouteParamsOf<Route>> = (event: ServerLoadEvent<Route, Body, FormBody, QueryBody, Params>) => Response | undefined | void | Promise<Response | undefined | void>;
+//#endregion
+//#region src/types/ServerEndPoint.d.ts
+/**
+ * Optional standard schemas for +server endpoints, keyed by handler name.
+ * Any schema implementing the Standard Schema interface (zod, valibot,
+ * arktype, etc) can be used.
+ *
+ * - `get`/`head` schemas validate the URL's query string, surfaced through
+ *   `event.query()`
+ * - `post`/`patch`/`put`/`del`/`options` schemas validate the JSON request
+ *   body, surfaced through `event.json()`
+ * - a `params` schema validates (and generally coerces) the route params,
+ *   surfaced through `event.params`
+ *
+ * When a request body or query string fails validation, the handler is not
+ * called and a 422 response with the schema's issues is returned. When route
+ * params fail validation, a 404 response is returned, since the URL can't
+ * refer to an existing resource.
+ */
+type ServerEndPointSchemas = {
+  params?: StandardSchemaV1;
+  get?: StandardSchemaV1;
+  post?: StandardSchemaV1;
+  patch?: StandardSchemaV1;
+  put?: StandardSchemaV1;
+  del?: StandardSchemaV1;
+  options?: StandardSchemaV1;
+  head?: StandardSchemaV1;
+};
+/**
+ * The json body type for a handler, inferred from its schema. Falls back to
+ * `unknown` for handlers without a declared schema.
+ */
+type SchemaBody<Schemas extends ServerEndPointSchemas, Method extends string> = [Method] extends [keyof Schemas & string] ? Schemas[Method] extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<Schemas[Method]> : unknown : unknown;
+/**
+ * The query type for a handler, inferred from its schema. Falls back to a
+ * loose record for handlers without a declared schema.
+ */
+type SchemaQuery<Schemas extends ServerEndPointSchemas, Method extends string> = [Method] extends [keyof Schemas & string] ? Schemas[Method] extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<Schemas[Method]> : QueryRecord : QueryRecord;
+/**
+ * The route params type for an endpoint, inferred from its `params` schema.
+ * Falls back to the route's string params when no schema is declared.
+ */
+type ParamsOf<Schemas extends {
+  params?: StandardSchemaV1;
+}, Route extends string | undefined> = Schemas extends {
+  params: StandardSchemaV1;
+} ? StandardSchemaV1.InferOutput<Schemas["params"]> : RouteParamsOf<Route>;
+/**
+ * For +server. Annotate with a route path to get typed params, e.g.
+ * `ServerEndPoint<"/api/posts/[id]">`, and with a schemas object to get
+ * typed (and validated) request bodies, query strings and params, e.g.
+ * `ServerEndPoint<"/api/posts", typeof schema>`.
+ */
+type ServerEndPoint<Route extends string | undefined = undefined, Schemas extends ServerEndPointSchemas = ServerEndPointSchemas> = {
+  /**
+   * Optional standard schemas for validating requests, keyed by handler
+   * name (plus a `params` schema for the route params), e.g.
+   *
+   * ```ts
+   * const schema = {
+   *   params: z.object({ id: z.coerce.number() }),
+   *   get: z.object({ sort: z.enum(["asc", "desc"]) }),
+   *   post: z.object({ title: z.string() }),
+   * };
+   * export default {
+   *   schema,
+   *   get: async (event) => ok(await event.query()),
+   *   post: async (event) => ok((await event.json()).title),
+   * } satisfies ServerEndPoint<"/api/posts/[id]", typeof schema>;
+   * ```
+   */
+  schema?: Schemas | undefined;
+  /**
+   * Performs a GET. Its schema validates the query string.
+   */
+  get?: ServerRequest<Route, unknown, FormDataRecord, SchemaQuery<Schemas, "get">, ParamsOf<Schemas, Route>>;
+  /**
+   * Performs a POST. Its schema validates the JSON request body.
+   */
+  post?: ServerRequest<Route, SchemaBody<Schemas, "post">, FormDataRecord, QueryRecord, ParamsOf<Schemas, Route>>;
+  /**
+   * Performs a PATCH. Its schema validates the JSON request body.
+   */
+  patch?: ServerRequest<Route, SchemaBody<Schemas, "patch">, FormDataRecord, QueryRecord, ParamsOf<Schemas, Route>>;
+  /**
+   * Performs a PUT. Its schema validates the JSON request body.
+   */
+  put?: ServerRequest<Route, SchemaBody<Schemas, "put">, FormDataRecord, QueryRecord, ParamsOf<Schemas, Route>>;
+  /**
+   * Performs a DELETE. Its schema validates the JSON request body.
+   */
+  del?: ServerRequest<Route, SchemaBody<Schemas, "del">, FormDataRecord, QueryRecord, ParamsOf<Schemas, Route>>;
+  /**
+   * Performs an OPTIONS request. Its schema validates the JSON request body.
+   */
+  options?: ServerRequest<Route, SchemaBody<Schemas, "options">, FormDataRecord, QueryRecord, ParamsOf<Schemas, Route>>;
+  /**
+   * Performs a HEAD request. Its schema validates the query string.
+   */
+  head?: ServerRequest<Route, unknown, FormDataRecord, SchemaQuery<Schemas, "head">, ParamsOf<Schemas, Route>>;
+};
+//#endregion
+//#region src/types/RouteType.d.ts
+declare const PAGE_ROUTE = 0;
+declare const PAGE_SERVER_ROUTE = 1;
+declare const SERVER_ROUTE = 3;
+declare const LAYOUT_ROUTE = 4;
+declare const LAYOUT_SERVER_ROUTE = 5;
+declare const HOOK_ROUTE = 6;
+declare const HOOK_SERVER_ROUTE = 7;
+declare const ERROR_ROUTE = 8;
+type RouteType = typeof PAGE_ROUTE | typeof PAGE_SERVER_ROUTE | typeof SERVER_ROUTE | typeof LAYOUT_ROUTE | typeof LAYOUT_SERVER_ROUTE | typeof HOOK_ROUTE | typeof HOOK_SERVER_ROUTE | typeof ERROR_ROUTE | -1;
+//#endregion
+//#region src/types/Route.d.ts
+/**
+ * Any endpoint shape that can be stored inline on a Route.
+ */
+type InlineEndPoint = PageServerEndPoint | ServerEndPoint | ServerHook | PageEndPoint;
+/**
+ * A route that is added to the Site.
+ */
+interface Route {
+  path: string;
+  /**
+   * The file for this route, relative to the site root. Omitted for inline
+   * endpoints (see `endPoint`).
+   */
+  file?: string;
+  /**
+   * For inline routes (defined in code rather than by file), the endpoint
+   * object itself. The shape depends on the route type
+   * (`PageServerEndPoint`, `ServerEndPoint`, `ServerHook`, etc.).
+   */
+  endPoint?: InlineEndPoint;
+  type: RouteType;
+  subFolder?: string;
+}
+//#endregion
+//#region src/site/Site.d.ts
+/**
+ * The Site class contains the information necessary to setup a @torpor/build
+ * site, including routes, plugins, and options.
+ */
+declare class Site {
+  #private;
+  root: string;
+  routes: Route[];
+  /**
+   * Torpor site plugins, run when the site config is loaded (for dev and
+   * build) and when the server starts up. Use these to register extra
+   * routes (e.g. `openApi()` from `@torpor/build/openapi`) or add other
+   * framework-level functionality
+   */
+  plugins: SitePlugin[];
+  /**
+   * Vite plugins to add to the client and server builds
+   */
+  vitePlugins: Plugin[];
+  adapter: Adapter;
+  /**
+   * Extra inputs, as absolute file paths, that will be compiled with the
+   * output. What you do with them after that is up to you. File paths ending
+   * with server.ts/js will only be compiled with the server output
+   */
+  inputs: string[];
+  /**
+   * Vite config options to merge with the standard Torpor build options.
+   * `plugins` and `build.rollupOptions.input` will be overridden, so you
+   * should set `Site.vitePlugins` and `Site.inputs` instead. Other options may be
+   * overridden or incompatible, so experimentation may be required
+   */
+  viteConfig?: UserConfig;
+  /**
+   * The path to the site.config file. Set automatically by the CLI; used by
+   * the manifest plugin to import inline endpoints for server builds.
+   */
+  configFile?: string;
+  /**
+   * A state map for plugins to store their configuration and state on the
+   * site, so that framework internals (e.g. the manifest plugin) and other
+   * plugins can read them back:
+   *
+   * ```ts
+   * const myKey = Symbol.for("my-plugin");
+   * site.pluginState.set(myKey, options);
+   * ```
+   *
+   * Prefer `Symbol.for("...")` keys (or plain strings) over `Symbol()`,
+   * because the user's config file and framework internals can be loaded as
+   * separate module instances -- registry symbols are shared across
+   * instances, `Symbol()` ones are not.
+   */
+  pluginState: Map<PropertyKey, unknown>;
+  /**
+   * Inline endpoints keyed by `"path:type"`. Populated by `addRoute` when
+   * the user passes an inline endpoint object instead of a file path.
+   */
+  inlineEndPoints: Record<string, InlineEndPoint>;
+  constructor();
+  /**
+   * Adds a folder of routes, based on the names of the files in the folder
+   * @param folder The folder containing the routes
+   * @param subFolder If a subFolder is set, all routes in the folder will be
+   * placed under the subFolder, and only hooks, layouts etc will be used if
+   * they have the same subFolder. This can be used to create e.g. an `api`
+   * set of routes with their own hook for authorization from various clients
+   */
+  addRouteFolder(folder: string, subFolder?: string): Promise<void>;
+  /**
+   * Adds a file route, which can have a standard name (e.g. +page.ts) or any
+   * name if you pass the type
+   * @param path The route path
+   * @param file The file
+   * @param type The file type (if the file name is non-standard)
+   */
+  addRouteFile(path: string, file: string, type?: "+page" | "+page.server" | "+server" | "_layout" | "_layout.server" | "_hook" | "_hook.server" | "_error", subFolder?: string): void;
+  /**
+   * Adds a route in code, without needing the standard file naming
+   * conventions (+page.ts, +page.server.ts, etc). This is useful for small
+   * sites with one or two pages.
+   *
+   * Any combination of options may be provided; each maps to the
+   * corresponding file-route type:
+   *
+   * - `page` — a `+page` (`.torp` component or `.ts`/`.js` `PageEndPoint`)
+   * - `pageServer` — a `+page.server` (`PageServerEndPoint`, file or inline)
+   * - `server` — a `+server` HTTP endpoint (`ServerEndPoint`, file or inline)
+   * - `layout` — a `_layout` (`.torp` component or `.ts`/`.js` `PageEndPoint`)
+   * - `layoutServer` — a `_layout.server` (`PageServerEndPoint`, file or inline)
+   * - `hookServer` — a `_hook.server` (`ServerHook`, file or inline)
+   * - `error` — an `_error` page (`.torp` component or `.ts`/`.js` `PageEndPoint`)
+   *
+   * Options that need a component (`page`, `layout`, `error`) must be file
+   * paths so the component is included in the client bundle. Server-only
+   * options (`pageServer`, `server`, `layoutServer`, `hookServer`) accept
+   * either a file path or an inline object; inline server code is kept out
+   * of the client bundle automatically.
+   *
+   * @example
+   * // A page with an inline server action
+   * site.addRoute("/", {
+   *   page: "./src/Counter.torp",
+   *   pageServer: { actions: { set: async ({ request }) => ok() } },
+   * });
+   * @example
+   * // A JSON API endpoint
+   * site.addRoute("/api/time", {
+   *   server: { get: async () => ok({ time: Date.now() }) },
+   * });
+   * @example
+   * // A root layout, server hook, and error page
+   * site.addRoute("/", {
+   *   layout: "./src/Layout.torp",
+   *   hookServer: { enter: async (event) => {} },
+   *   error: "./src/ErrorPage.torp",
+   * });
+   *
+   * @param path The route path, e.g. `/` or `/about`
+   * @param options File paths and/or inline endpoints for the route
+   * @param subFolder An optional subFolder for grouping routes
+   */
+  addRoute(path: string, options: {
+    page?: string;
+    pageServer?: string | PageServerEndPoint;
+    server?: string | ServerEndPoint;
+    layout?: string;
+    layoutServer?: string | PageServerEndPoint;
+    hookServer?: string | ServerHook;
+    error?: string;
+  }, subFolder?: string): void;
+}
+//#endregion
+export { ServerLoadEvent as C, QueryRecord as S, PageLoadEvent as _, ServerEndPoint as a, ServerHook as b, ActionBody as c, PageServerActionSchemas as d, PageServerEndPoint as f, PageLoadReturn as g, PageEndPoint as h, SchemaQuery as i, LoadParams as l, PageServerAction as m, ParamsOf as n, ServerEndPointSchemas as o, PageServerLoad as p, SchemaBody as r, ServerRequest as s, Site as t, LoadQuery as u, SitePlugin as v, FormDataRecord as x, Adapter as y };
+//# sourceMappingURL=Site-CMa153FA.d.mts.map

package/dist/Site-CMa153FA.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Site-CMa153FA.d.mts","names":[],"sources":["../src/types/ServerLoadEvent.ts","../src/types/ServerHook.ts","../src/types/Adapter.ts","../src/types/SitePlugin.ts","../src/types/PageLoadEvent.ts","../src/types/PageLoadReturn.ts","../src/types/PageEndPoint.ts","../src/types/PageServerAction.ts","../src/types/PageServerLoad.ts","../src/types/PageServerEndPoint.ts","../src/types/ServerRequest.ts","../src/types/ServerEndPoint.ts","../src/types/RouteType.ts","../src/types/Route.ts","../src/site/Site.ts"],"mappings":"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"}

package/dist/StandardSchema-D28L8_zZ.d.mts

@@ -0,0 +1,100 @@
+//#region src/types/StandardSchema.d.ts
+/**
+ * The Standard Schema interface, per the spec at https://standardschema.dev.
+ *
+ * It is implemented by Zod, Valibot, ArkType, Effect Schema and others, so
+ * endpoints can validate request bodies with whichever library they prefer
+ * without this package depending on any of them.
+ */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema props interface. */
+  export interface Props<Input = unknown, Output = Input> {
+    /**
+     * The Standard Schema version.
+     */
+    readonly version: 1;
+    /**
+     * The vendor name of the schema library.
+     */
+    readonly vendor: string;
+    /**
+     * Validates unknown input values and returns the parsed output.
+     */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /**
+     * Inferred types associated with the schema.
+     */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /**
+   * The result of a validation: a success with a value, or a failure with
+   * issues.
+   */
+  export type Result<Output> = SuccessResult<Output> | FailureResult;
+  /**
+   * The result of a successful validation.
+   */
+  export interface SuccessResult<Output> {
+    /**
+     * The typed output value.
+     */
+    readonly value: Output;
+    /**
+     * Only set when there are issues, so a success can be tested with
+     * `if (result.issues)`.
+     */
+    readonly issues?: undefined;
+  }
+  /**
+   * The result of a failed validation.
+   */
+  export interface FailureResult {
+    /**
+     * The issues detected during validation.
+     */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /**
+   * An issue encountered during validation.
+   */
+  export interface Issue {
+    /**
+     * The error message.
+     */
+    readonly message: string;
+    /**
+     * The path to the property the issue belongs to.
+     */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /**
+   * A segment of the path to an issue.
+   */
+  export interface PathSegment {
+    /**
+     * The key of the property.
+     */
+    readonly key: PropertyKey;
+  }
+  /**
+   * The input and output types inferred from a schema.
+   */
+  export interface Types<Input = unknown, Output = Input> {
+    readonly input: Input;
+    readonly output: Output;
+  }
+  /**
+   * Infers the input type of a schema.
+   */
+  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /**
+   * Infers the output type of a schema.
+   */
+  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+//#endregion
+export { StandardSchemaV1 as t };
+//# sourceMappingURL=StandardSchema-D28L8_zZ.d.mts.map

package/dist/StandardSchema-D28L8_zZ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StandardSchema-D28L8_zZ.d.mts","names":[],"sources":["../src/types/StandardSchema.ts"],"mappings":";;;;;;;;UAOiB,iBAAiB,iBAAiB,SAAS;WAClD,aAAa,iBAAiB,MAAM,OAAO;;kBAG5B;;mBAEP,MAAM,iBAAiB,SAAS;;;;aAIvC;;;;aAIA;;;;aAIA,WAAW,mBAAmB,OAAO,UAAU,QAAQ,OAAO;;;;aAI9D,QAAQ,MAAM,OAAO;;;;;;cAOnB,OAAO,UAAU,cAAc,UAAU;;;;mBAKpC,cAAc;;;;aAIrB,OAAO;;;;;aAKP;;;;;mBAMO;;;;aAIP,QAAQ,cAAc;;;;;mBAMf;;;;aAIP;;;;aAIA,OAAO,cAAc,cAAc;;;;;mBAM5B;;;;aAIP,KAAK;;;;;mBAME,MAAM,iBAAiB,SAAS;aACvC,OAAO;aACP,QAAQ;;;;;cAMN,WAAW,eAAe,oBAAoB,YACzD;;;;cAMW,YAAY,eAAe,oBAAoB,YAC1D"}