@marko/run 0.10.0 → 0.11.0-rc.1

package/dist/runtime/types.d.ts

@@ -1,128 +1,421 @@
-import type { HttpVerb } from "../vite";
-type OneOrMany<T> = T | T[];
-type NoParams = {};
-type AllKeys<T> = T extends T ? keyof T : never;
-type Simplify<T> = T extends unknown ? {
-    [K in keyof T]: T[K];
-} : never;
-type IsObject<T> = T extends object ? T extends any[] ? 0 : T extends (...args: any[]) => any ? 0 : 1 : 0;
-type SuperSet<T, U extends T> = T & {
-    [K in AllKeys<U> as K extends keyof T ? never : K]?: never;
-};
-type SuperSets<T, U extends T, K extends keyof T> = Omit<T, K> & {
-    [P in K]: Simplify<SuperSet<T[P], U[P]>>;
-};
-export type Awaitable<T> = Promise<T> | T;
-export type Verb = Uppercase<HttpVerb>;
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+export type ValidatorFn<T = unknown> = (input: T) => any;
+export type Validator<T = unknown> = StandardSchemaV1<T> | ValidatorFn<T>;
+export type JsonBodyValidator = Validator<unknown> | JsonBodyValidatorOptions;
+export type JsonBodyValidatorOptions = {
+    validator?: Validator<unknown>;
+    maxBytes?: number;
+};
+export type FormBodyValidator<Ctx> = Validator<Record<string, any>> | FormBodyValidatorOptions<Ctx>;
+export type FormBodyValidatorOptions<Ctx> = {
+    validator?: Validator<Record<string, any>>;
+    maxBytes?: number;
+    maxFiles?: number;
+    maxParts?: number;
+    maxFileBytes?: number;
+    onFile?(ctx: Ctx, file: Multipart): any;
+};
+type Schema<I, O> = [O, undefined] | [I, StandardSchemaV1.FailureResult["issues"]];
+type Validated<V, Default = unknown> = V extends StandardSchemaV1<infer I, infer O> ? Schema<I, O> : V extends (...args: any[]) => infer R ? R : Default;
+type Valid<V, Default = unknown> = V extends StandardSchemaV1<infer I> ? I : V extends (...args: any[]) => infer R ? R : Default;
+type HttpVerbWithoutBody = "GET" | "HEAD" | "DELETE" | "OPTIONS";
+type HttpVerbWithBody = "POST" | "PUT" | "PATCH";
+export type HttpVerb = HttpVerbWithoutBody | HttpVerbWithBody;
+export type HttpVerbOrAll = HttpVerb | "ALL";
+type RouteFileType = "handler" | "middleware" | "template" | "meta" | `@${string}`;
+type RouteFileGroup = {
+    all: File[];
+    handler: File | never;
+    template: File[];
+    middleware: File[];
+    meta: File[];
+    partial: File[];
+};
+type Simplify<T> = {
+    [Z in keyof T]: T[Z];
+} & {};
+type Keys<T> = [T] extends [never] ? never : keyof T;
+type Union<T> = T[keyof T];
+type IsPlainObject<T> = T extends object ? T extends (...args: any[]) => any ? false : T extends readonly any[] ? false : T extends Date ? false : true : false;
+type Fallback<T, Value> = [T] extends [never] ? Value : T;
+type MapTuple<T extends readonly any[], K extends keyof T[number], Value = never> = {
+    [I in keyof T]: Fallback<T[I][K], Value>;
+};
+type FindTuple<T extends readonly unknown[], K extends PropertyKey, V> = T extends readonly [infer H, ...infer R] ? H extends Record<K, V> ? H : FindTuple<R, K, V> : never;
+type FilterTuple<T extends readonly unknown[], K extends PropertyKey, V> = T extends readonly [infer H, ...infer R] ? H extends Record<K, V> ? [H, ...FilterTuple<R, K, V>] : FilterTuple<R, K, V> : [];
+type MergeTwo<A, B> = IsPlainObject<A> extends true ? IsPlainObject<B> extends true ? Simplify<Omit<A, keyof B> & B> : B : IsPlainObject<B> extends true ? B : {};
+type MergeTuple<T extends readonly any[]> = T extends readonly [
+    infer A,
+    infer B,
+    ...infer Rest
+] ? MergeTuple<[MergeTwo<A, B>, ...Rest]> : T extends readonly [infer Only] ? IsPlainObject<Only> extends true ? Only : {} : {};
+type MergeValidators<A, B> = IsPlainObject<A> extends true ? IsPlainObject<B> extends true ? Simplify<Omit<A, keyof B> & B> : A extends Record<"validator", Validator> ? Simplify<Omit<A, "validator"> & {
+    validator: B;
+}> : B : B;
+type MergeHandlerOptions<A, B> = [A] extends [never] ? B : [B] extends [never] ? A : {
+    [K in keyof A | keyof B]: K extends keyof A ? K extends keyof B ? K extends "params" | "search" | "form" | "json" ? MergeValidators<A[K], B[K]> : B[K] : A[K] : K extends keyof B ? B[K] : never;
+};
+type MergeHandlerOptionsTuple<T extends readonly any[]> = T extends readonly [
+    infer A,
+    infer B,
+    ...infer Rest
+] ? MergeHandlerOptionsTuple<[MergeHandlerOptions<A, B>, ...Rest]> : T extends readonly [infer Only] ? Only : never;
+type PathParamKeys<Path extends string> = Path extends `${infer _}$${infer Param}/${infer Rest}` ? [Unescape<Param>, ...PathParamKeys<Rest>] : Path extends `${infer _}$$${infer Param}` ? [Unescape<Param>] : Path extends `${infer _}$${infer Param}` ? [Unescape<Param>] : [];
+type Unescape<Escaped extends string> = Escaped extends `\`${infer Value}\`` ? Value : Escaped;
+type PathParams<Path extends string, Keys extends string[] = PathParamKeys<Path>> = {
+    [K in Keys[number]]: string;
+};
+type NormalizedMetaObject<Meta, Verb extends HttpVerb> = IsPlainObject<Meta> extends true ? Verb extends keyof Meta ? Simplify<Omit<Meta, HttpVerb | keyof Meta[Verb]> & Meta[Verb]> : Simplify<Omit<Meta, HttpVerb>> : never;
+export type NormalizedMeta<Meta, Verb extends HttpVerb> = IsPlainObject<Meta> extends true ? {
+    [K in Verb]: NormalizedMetaObject<Meta, K>;
+}[Verb] : Meta;
+export type NormalizedMetaLookup<T> = {
+    [K in HttpVerb]: IsPlainObject<T> extends 1 ? NormalizedMetaObject<T, K> : T;
+};
+type NormalizedMetaFiles<Files extends readonly File[], Verb extends HttpVerb> = {
+    [I in keyof Files]: NormalizedMeta<Files[I]["exports"], Verb>;
+};
+type RouteFiles<Files extends readonly File[]> = {
+    [Type in RouteFileType | "all" as Type extends `@${string}` ? "partial" : Type]: Type extends "all" ? Files : Type extends "handler" ? FindTuple<Files, "type", Type> : FilterTuple<Files, "type", Type>;
+};
+type ID = string | number;
+interface File<Id extends ID = ID, Type extends RouteFileType = RouteFileType, Module = any> {
+    id: Id;
+    type: Type;
+    name: Type extends `@${infer P}` ? P : Type;
+    module: Module;
+    exports: Type extends "handler" ? Module : "default" extends keyof Module ? Module["default"] : Module;
+}
+export type RouteData = Record<string, any>;
+export interface RouteDef<Path extends string = string, Verb extends HttpVerb = HttpVerb, Meta = any, Partials extends Record<string, any> = Record<string, any>, Options = RouteOptionsContainer<Path, Verb>> {
+    path: Path;
+    method: Verb;
+    meta: Meta;
+    partials: Partials;
+    params: Options extends [
+        {
+            params: infer T;
+        }
+    ] ? T : Simplify<PathParams<Path>>;
+    search: Options extends [
+        {
+            search: infer T;
+        }
+    ] ? T : undefined;
+    form: Verb extends HttpVerbWithBody ? Options extends [
+        {
+            form: infer T;
+        }
+    ] ? T : never : undefined;
+    json: Verb extends HttpVerbWithBody ? Options extends [
+        {
+            json: infer T;
+        }
+    ] ? T : never : undefined;
+}
+type RouteOptionsContainer<Path extends string = string, Verb extends HttpVerb = HttpVerb> = [
+    Path extends keyof AppPaths ? AppPaths[Path]["verbs"][Verb extends keyof AppPaths[Path]["verbs"] ? Verb : never]["options"] : never
+];
+export interface Route<Def extends RouteDef = RouteDef, Data = any> {
+    path: Def["path"];
+    method: Def["method"];
+    meta: Def["meta"];
+    params: Def["params"];
+    search: Def["search"];
+    body: Fallback<Def["json"], Fallback<Def["form"], undefined>>;
+    data: Data extends [infer T extends RouteData] ? T : RouteData;
+}
+type RouteFileGroupVerb<Group extends RouteFileGroup> = (Keys<Group["handler"]["exports"]> & HttpVerb) | (Group["template"] extends [] ? never : "GET");
+type RouteFileGroupMeta<Group extends RouteFileGroup, Verb extends HttpVerb> = Fallback<MergeTuple<NormalizedMetaFiles<Group["meta"], Verb>>, {}>;
+type RouteFileGroupOptions<Group extends RouteFileGroup, Verb extends HttpVerb> = MergeHandlerOptionsTuple<MapTuple<TypesFromHandlerFiles<[...Group["middleware"], Group["handler"]], Verb>, "options", {}>>;
+type RouteFileGroupData<Group extends RouteFileGroup, Verb extends HttpVerb> = MergeTuple<MapTuple<TypesFromHandlerFiles<[...Group["middleware"], Group["handler"]], Verb>, "data", {}>>;
+type TypesFromHandlerFiles<Files extends File[], Verb extends HttpVerb> = {
+    [I in keyof Files]: TypesFromHandlerFile<Files[I], Verb>;
+};
+type TypesFromHandlerFile<F extends File, Verb extends HttpVerb> = TypesFromHandler<F["type"] extends "handler" ? F["exports"][Verb] : F["exports"], Verb>;
+type TypesFromHandler<Handler, Verb extends HttpVerb> = Handler extends Typed<{}, infer Types> ? Types extends {
+    verb: infer HVerb;
+} ? HVerb extends Verb | "ALL" ? Types : never : never : never;
+type DefineRoute<Path extends string, Group extends RouteFileGroup> = {
+    files: Group;
+    verbs: {
+        [Verb in RouteFileGroupVerb<Group>]: {
+            rawOptions: RouteFileGroupOptions<Group, Verb>;
+            options: Fallback<Validation<RouteFileGroupOptions<Group, Verb>>, {}>;
+            data: RouteFileGroupData<Group, Verb>;
+            def: RouteDef<Path, Verb, RouteFileGroupMeta<Group, Verb>, Verb extends "GET" ? {
+                [File in Group["partial"][number] as File["name"] & string]: File["exports"];
+            } : {}>;
+        };
+    };
+};
+type NextHandlerResult<Data> = Typed<Promise<Response>, {
+    data: Data;
+}>;
+export type DefinePaths<Groups extends Record<string, RouteFileGroup>> = {
+    [Path in keyof Groups & string]: DefineRoute<Path, Groups[Path]>;
+};
+type HandlerFuncData<T> = T extends Typed<{}, {
+    data: infer Data;
+}> ? Data : {};
+export interface NormalizedHandlerFunction<Ctx, Options> extends HandlerFunction<Ctx, Promise<Response>> {
+    options: Options;
+}
+export type NormalizedHandler<Ctx, Verb extends HttpVerbOrAll, Return, Options> = Typed<NormalizedHandlerFunction<Ctx, Options>, HandlerTypes<Ctx, Verb, Options, Return extends readonly unknown[] ? MergeTuple<{
+    [I in keyof Return]: HandlerFuncData<Return[I]>;
+}> : HandlerFuncData<Return>>>;
+type HandlerArray<Ctx, Return extends unknown[]> = {
+    [K in keyof Return]: HandlerFunction<Ctx, Return[K]>;
+};
+type Exact<T, Shape> = T & Record<Exclude<keyof T, keyof Shape>, never>;
+type DefineHandlerOptions<Verb extends HttpVerbOrAll, Ctx> = [Verb] extends [
+    HttpVerbWithoutBody
+] ? HandlerOptionsWithoutBody : HandlerOptionsWithBody<Ctx>;
+type TypesFromHandlerFilesWithLocal<Files extends File[], Verb extends HttpVerb, Id extends ID, Options> = {
+    [I in keyof Files]: Files[I] extends {
+        id: Id;
+    } ? HandlerTypes<Context, Verb, Options, {}> : TypesFromHandlerFile<Files[I], Verb>;
+};
+type RouteFileGroupOptionsWithLocal<Group extends RouteFileGroup, Verb extends HttpVerb, Id extends ID, Options> = MergeHandlerOptionsTuple<MapTuple<TypesFromHandlerFilesWithLocal<[
+    ...Group["middleware"],
+    Group["handler"]
+], Verb, Id, Options>, "options", {}>>;
+type MergedRouteOptionsForFile<Path extends keyof AppPaths, Verb extends HttpVerb, Id extends ID, Options> = Fallback<Validation<RouteFileGroupOptionsWithLocal<AppPaths[Path]["files"], Verb, Id, Options>>, {}>;
+export interface RouteForFileDef<F extends File, Path extends keyof AppPaths, Verb extends HttpVerb, Options> {
+    path: Path;
+    method: Verb;
+    meta: Verb extends keyof AppPaths[Path]["verbs"] ? AppPaths[Path]["verbs"][Verb]["def"]["meta"] : {};
+    params: MergedRouteOptionsForFile<Path, Verb, F["id"], Options> extends {
+        params: infer T;
+    } ? T : Simplify<PathParams<Path & string>>;
+    search: MergedRouteOptionsForFile<Path, Verb, F["id"], Options> extends {
+        search: infer T;
+    } ? T : undefined;
+    body: Verb extends HttpVerbWithBody ? MergedRouteOptionsForFile<Path, Verb, F["id"], Options> extends {
+        json: infer T;
+    } ? T : MergedRouteOptionsForFile<Path, Verb, F["id"], Options> extends {
+        form: infer T;
+    } ? T : undefined : undefined;
+    data: GetUpstreamData<F, Path, Verb> extends [infer T extends RouteData] ? T : RouteData;
+}
+type ContextForFileWithOptions<F extends File, Verb extends HttpVerbOrAll, Options> = Union<{
+    [Path in PathsForFile<F>]: Union<{
+        [V in VerbsForPath<Path, Verb>]: V extends HttpVerb ? Context<RouteForFileDef<F, Path & keyof AppPaths, V, Options>> : never;
+    }>;
+}>;
+export type DefineHandler<F extends File, Verb extends HttpVerbOrAll> = {
+    <Return>(handler: HandlerFunction<ContextForFileWithOptions<F, Verb, {}> & {}, Return>): NormalizedHandler<ContextForFileWithOptions<F, Verb, {}> & {}, Verb, Return, {}>;
+    <const Options extends DefineHandlerOptions<Verb, ContextForFileWithOptions<F, Verb, {}> & {}>>(options: Exact<Options, DefineHandlerOptions<Verb, ContextForFileWithOptions<F, Verb, {}> & {}>>): NormalizedHandler<ContextForFileWithOptions<F, Verb, Options> & {}, Verb, {}, Options>;
+    <const Options extends DefineHandlerOptions<Verb, ContextForFileWithOptions<F, Verb, {}> & {}>, Return>(options: Exact<Options, DefineHandlerOptions<Verb, ContextForFileWithOptions<F, Verb, {}> & {}>>, handler: HandlerFunction<ContextForFileWithOptions<F, Verb, Options> & {}, Return>): NormalizedHandler<ContextForFileWithOptions<F, Verb, Options> & {}, Verb, Return, Options>;
+    <Return extends unknown[]>(handlers: HandlerArray<ContextForFileWithOptions<F, Verb, {}> & {}, Return>): NormalizedHandler<ContextForFileWithOptions<F, Verb, {}> & {}, Verb, Return, {}>;
+    <const Options extends DefineHandlerOptions<Verb, ContextForFileWithOptions<F, Verb, {}> & {}>, Return extends unknown[]>(options: Exact<Options, DefineHandlerOptions<Verb, ContextForFileWithOptions<F, Verb, {}> & {}>>, handlers: HandlerArray<ContextForFileWithOptions<F, Verb, Options> & {}, Return>): NormalizedHandler<ContextForFileWithOptions<F, Verb, Options> & {}, Verb, Return, Options>;
+};
+type TakeUntil<Arr extends any[], Id extends ID, Prev extends any[] = []> = Arr extends [infer A, ...infer Rest] ? A extends {
+    id: Id;
+} ? Prev : TakeUntil<Rest, Id, [...Prev, A]> : [];
+type GetUpstreamData<F extends File, Path extends PathsForFile<F>, Verb extends HttpVerbOrAll> = Path extends keyof AppPaths ? [
+    Union<{
+        [V in VerbsForPath<Path, Verb>]: V extends HttpVerb ? MergeTuple<MapTuple<TypesFromHandlerFiles<F["type"] extends "template" ? [
+            ...AppPaths[Path]["files"]["middleware"],
+            AppPaths[Path]["files"]["handler"]
+        ] : TakeUntil<[
+            ...AppPaths[Path]["files"]["middleware"],
+            AppPaths[Path]["files"]["handler"]
+        ], F["id"]>, V>, "data", {}>> : {};
+    }>
+] : {};
+type HandlerReturnValue = void | undefined | null | Response | typeof MarkoRun.NotHandled | typeof MarkoRun.NotMatched;
+type HandlerReturn = HandlerReturnValue | Promise<HandlerReturnValue>;
+export type HandlerFunction<Ctx = Context, Return = HandlerReturn> = (ctx: Ctx, next: NextFunction) => Return extends HandlerReturn ? Return : HandlerReturn;
+export interface HandlerOptionsWithoutBody {
+    params?: Validator<Record<string, any>>;
+    search?: Validator<Record<string, any>>;
+}
+export interface HandlerOptionsWithBody<Ctx> extends HandlerOptionsWithoutBody {
+    json?: JsonBodyValidator;
+    form?: FormBodyValidator<Ctx>;
+}
+export type HandlerOptions<Ctx = Context> = [Ctx] extends [
+    {
+        method: HttpVerbWithoutBody;
+    }
+] ? HandlerOptionsWithoutBody : HandlerOptionsWithBody<Ctx>;
+export type NormalizedHandlerOptions<Ctx extends Context = Context> = {
+    params: ValidatorFn<Record<string, any>> | undefined;
+    search: ValidatorFn<Record<string, any>> | undefined;
+    json: Ctx["method"] extends HttpVerbWithoutBody ? undefined : {
+        maxBytes: number;
+        validator: ValidatorFn | undefined;
+    };
+    form: Ctx["method"] extends HttpVerbWithoutBody ? undefined : {
+        maxBytes: number;
+        maxFiles: number;
+        maxParts: number;
+        maxFileBytes: number;
+        onFile: ((ctx: Ctx, file: Multipart) => any) | undefined;
+        validator: ValidatorFn<Record<string, any>> | undefined;
+    };
+};
+export interface Multipart extends globalThis.File {
+    fieldName: string;
+}
+type Validation<T> = Simplify<{
+    [K in "params" | "search" | "form" | "json" as K extends keyof T ? K : never]: T extends Record<K, infer Value> ? Validated<Value, 1> : keyof T;
+}>;
+type RoutesForFile<F extends File> = {
+    [K in keyof AppPaths as F["id"] extends AppPaths[K]["files"]["all"][number]["id"] ? K : never]: AppPaths[K];
+};
+type PathsForFile<F extends File> = keyof RoutesForFile<F>;
+type FilterContextByVerb<Ctx extends Context, Verb extends HttpVerbOrAll> = Verb extends HttpVerb ? Extract<Ctx, {
+    method: Verb;
+}> : Ctx;
+type MatchedPaths<Path> = Path extends string ? Path extends keyof AppPaths ? Path : Path extends `${infer Root}*` ? keyof AppPaths & `${Root}${string}` : keyof AppPaths : Path;
+type AllVerbs = Union<{
+    [Path in keyof AppPaths]: keyof AppPaths[Path]["verbs"];
+}>;
+type AvailableVerbs<Scope extends keyof AppPaths | object> = Scope extends string ? {
+    [K in Scope]: keyof AppPaths[K]["verbs"];
+}[Scope] : Scope extends {
+    Run: Typed<{}, {
+        context: {
+            method: infer Verb extends HttpVerb;
+        };
+    }>;
+} ? Verb : Scope extends Typed<{}, {
+    context: {
+        method: infer Verb extends HttpVerb;
+    };
+}> ? Verb : never;
+type ContextForPath<Path extends keyof AppPaths, Verb extends keyof AppPaths[Path]["verbs"] = keyof AppPaths[Path]["verbs"]> = Verb extends HttpVerb ? Context<Simplify<Route<AppPaths[Path]["verbs"][Verb]["def"], [
+    AppPaths[Path]["verbs"][Verb]["data"]
+]>>> : never;
+export type Typed<Original, Types> = Original & {
+    [" ~types"]: Types;
+};
+type VerbsForPath<Path extends keyof AppPaths, Verb extends HttpVerbOrAll = "ALL"> = Verb extends HttpVerb ? keyof AppPaths[Path]["verbs"] & Verb : keyof AppPaths[Path]["verbs"];
+export type PathsForVerb<Verb extends HttpVerbOrAll = "ALL"> = Verb extends HttpVerb ? Union<{
+    [Path in keyof AppPaths as Verb extends keyof AppPaths[Path]["verbs"] ? Path : never]: Path;
+}> : keyof AppPaths;
+export type ContextForFile<F extends File, Verb extends HttpVerbOrAll = F["type"] extends "template" ? "GET" : "ALL"> = Union<{
+    [Path in PathsForFile<F>]: Union<{
+        [V in VerbsForPath<Path, Verb>]: V extends HttpVerb ? Context<Simplify<Route<AppPaths[Path]["verbs"][V]["def"], GetUpstreamData<F, Path, V>>>> : never;
+    }>;
+}>;
+export type AppPaths = App extends {
+    paths: infer Paths;
+} ? Paths : DefineRoutes["paths"];
+export interface HandlerTypes<Ctx = Context, Verb extends HttpVerbOrAll = HttpVerbOrAll, Options = HandlerOptions<Ctx>, Data = RouteData> {
+    context: Ctx;
+    verb: Verb;
+    options: Options;
+    data: Data extends RouteData ? Data : {};
+}
+export type Middleware<Id extends ID, Mod> = File<Id, "middleware", Mod>;
+export type Handler<Id extends ID, Mod> = File<Id, "handler", Mod>;
+export type Template<Id extends ID, Mod> = File<Id, "template", Mod>;
+export type Meta<Id extends ID, Mod> = File<Id, "meta", Mod>;
+export type PartialTemplate<Id extends ID, Name extends string, Mod> = File<Id, `@${Name}`, Mod>;
+export type NamespaceVerb<Verb extends HttpVerbOrAll = "ALL"> = {
+    href: Href<Verb>;
+};
+export type GlobalNamespace = {
+    [Verb in HttpVerbOrAll]: NamespaceVerb<Verb>;
+} & NamespaceVerb;
+export type Namespace<F extends File> = Typed<(F["type"] extends "middleware" ? {
+    [Verb in HttpVerbOrAll]: DefineHandler<F, Verb> & NamespaceVerb<Verb>;
+} : F["type"] extends "handler" ? {
+    [Verb in HttpVerb]: DefineHandler<F, Verb> & NamespaceVerb<Verb>;
+} : {
+    [Verb in AllVerbs]: NamespaceVerb<Verb>;
+}) & NamespaceVerb, {
+    context: ContextForFile<F> & {};
+}>;
+export type DefineRoutes<Paths = void> = {
+    paths: [Paths] extends [Record<string, File[]>] ? DefinePaths<{
+        [Path in keyof Paths & string]: RouteFiles<Paths[Path]>;
+    }> : Record<string, {
+        files: any;
+        verbs: Record<HttpVerbOrAll, {
+            rawOptions: any;
+            options: any;
+            data: any;
+            def: RouteDef;
+        }>;
+    }>;
+};
 export interface Platform {
 }
-export interface Context<TRoute extends Route = AnyRoute, TVerb extends Verb = Verb> {
+export interface Context<T extends Route = Route> {
+    readonly route: T["path"];
+    readonly method: T["method"];
+    readonly meta: T["meta"];
+    readonly params: T["params"];
+    readonly search: T["search"];
+    readonly body: T["body"];
+    readonly data: T["data"];
     readonly url: URL;
     readonly request: Request;
-    readonly method: TVerb;
-    readonly route: TRoute["path"];
-    readonly params: TRoute["params"];
-    readonly meta: NormalizedMeta<TRoute["meta"], TVerb>;
     readonly platform: Platform;
     readonly serializedGlobals: Record<string, boolean>;
     readonly parent: Context | undefined;
-    render<T>(template: Marko.Template<T>, input: T, init?: ResponseInit): Response;
     fetch(resource: string | URL | Request, init?: RequestInit): Promise<Response>;
+    render<T>(template: Marko.Template<T>, input: T, init?: ResponseInit): Response;
     redirect(to: string | URL, status?: number): Response;
     back(fallback?: string | URL, status?: number): Response;
 }
-export type MultiRouteContext<TRoute extends Route, TVerb extends Verb = Verb, _Preserved extends TRoute = TRoute> = TRoute extends any ? TVerb extends any ? Context<Simplify<SuperSets<TRoute, _Preserved, "params">>, TVerb> : never : never;
-export type ParamsObject = Record<string, string>;
-export type InputObject = Record<PropertyKey, any>;
-export type NextFunction = () => Awaitable<Response>;
-export type HandlerLike<TRoute extends Route = AnyRoute, TVerb extends Verb = Verb> = Awaitable<OneOrMany<RouteHandler<TRoute, TVerb>>>;
-export type RouteHandlerResult = Response | typeof MarkoRun.NotHandled | typeof MarkoRun.NotMatched | null | void;
-export type RouteHandler<TRoute extends Route = AnyRoute, TVerb extends Verb = Verb> = (context: MultiRouteContext<TRoute, TVerb>, next: NextFunction) => Awaitable<RouteHandlerResult>;
-export interface Route<Params extends ParamsObject = ParamsObject, Meta = any, Path extends string = string> {
-    path: Path;
-    params: Params;
-    meta: Meta;
-}
-type DefineRoutes<T extends Record<string, {
-    meta?: unknown;
-}>> = {
-    [K in keyof T]: K extends string ? T[K] extends {
-        meta: infer Meta;
-    } ? Route<PathParams<K>, Meta, K> : Route<PathParams<K>, any, K> : never;
-};
-type DefinePaths<T extends Record<string, {
-    verb: unknown;
-}>, TVerb extends "get" | "post"> = {
-    [K in keyof T]: K extends string ? T[K] extends {
-        verb: infer V;
-    } ? V extends TVerb ? K : never : never : never;
-}[keyof T];
-export type DefineApp<T extends {
-    routes: Record<string, {
-        verb: "get" | "post";
-        meta?: unknown;
+export type GetContext<Scope extends keyof AppPaths | `*` | `/${string}*` | object = "*", Verb extends AvailableVerbs<Scope extends string ? MatchedPaths<Scope> : Scope> | "ALL" = "ALL"> = Scope extends string ? {
+    [Path in MatchedPaths<Scope>]: Path extends keyof AppPaths ? ContextForPath<Path, Verb extends HttpVerb ? Verb & keyof AppPaths[Path]["verbs"] : keyof AppPaths[Path]["verbs"]> : never;
+}[MatchedPaths<Scope>] : Scope extends {
+    Run: Typed<{}, {
+        context: infer Ctx extends Context;
     }>;
-}> = {
-    routes: DefineRoutes<T["routes"]>;
-    getPaths: DefinePaths<T["routes"], "get">;
-    postPaths: DefinePaths<T["routes"], "post">;
-};
-export interface RouteWithHandler<Params extends ParamsObject = ParamsObject, Meta = unknown, Path extends string = string> extends Route<Params, Meta, Path> {
-    handler: RouteHandler<this>;
+} ? FilterContextByVerb<Ctx, Verb> : Scope extends Typed<{}, {
+    context: infer Ctx extends Context;
+}> ? FilterContextByVerb<Ctx, Verb> : never;
+export type NextFunction = <Data extends RouteData = RouteData>(data?: Data) => NextHandlerResult<Data>;
+export interface App {
+}
+export interface RouteMatch<Ctx extends Context = Context> {
+    handler: HandlerFunction<Ctx, Promise<Response>>;
+    path: Ctx["route"];
+    params: Ctx["params"];
+    options: NormalizedHandlerOptions<Ctx>;
+    meta: Ctx["meta"];
 }
 export type Fetch<TPlatform extends Platform = Platform> = (request: Request, platform: TPlatform) => Promise<Response | void>;
-export type Match = (method: string, pathname: string) => RouteWithHandler | null;
-export type Invoke<TPlatform extends Platform = Platform> = (route: RouteWithHandler | null, request: Request, platform: TPlatform) => Promise<Response | void>;
+export type Match = (method: string, pathname: string) => RouteMatch | null;
+export type Invoke<TPlatform extends Platform = Platform> = (route: RouteMatch | null, request: Request, platform: TPlatform) => Promise<Response | void>;
 export interface RuntimeModule {
     fetch<TPlatform extends Platform = Platform>(...args: Parameters<Fetch<TPlatform>>): ReturnType<Fetch<TPlatform>>;
     match: Match;
     invoke<TPlatform extends Platform = Platform>(...args: Parameters<Invoke<TPlatform>>): ReturnType<Invoke<TPlatform>>;
 }
-type Member<T, U> = T extends T ? (U extends T ? T : never) : never;
-type PathParamKeys<Path extends string> = Path extends `${infer _}$${infer Param}/${infer Rest}` ? [Unescape<Param>, ...PathParamKeys<Rest>] : Path extends `${infer _}$$${infer Param}` ? [Unescape<Param>] : Path extends `${infer _}$${infer Param}` ? [Unescape<Param>] : [];
-type Unescape<Escaped extends string> = Escaped extends `\`${infer Value}\`` ? Value : Escaped;
-type PathParams<Path extends string, Keys extends string[] = PathParamKeys<Path>> = 0 extends Keys["length"] ? NoParams : {
-    [K in Keys[number]]: string;
-};
-type Segments<T extends string, Acc extends string[] = []> = T extends "" ? Acc : T extends `${infer Left}/${infer Rest}` ? Segments<Rest, [...Acc, Left]> : [...Acc, T];
-type GTE<A extends any[], B extends any[]> = A["length"] extends B["length"] ? 1 : A extends [infer _Ha, ...infer Ta] ? B extends [infer _Hb, ...infer Tb] ? GTE<Ta, Tb> : 1 : 0;
-type MatchSegments<A extends string, B extends string> = A extends `${infer P}/${string}*` ? 1 extends GTE<Segments<B>, Segments<P>> ? `${P}/${string}` : never : Segments<B>["length"] extends Segments<A>["length"] ? A : never;
-type PathPattern<T extends string> = T extends `${infer Left}/\${${string}}/${infer Rest}` ? PathPattern<`${Left}/${string}/${Rest}`> : T extends `${infer Left}/\${...${string}}` ? PathPattern<`${Left}/${string}*`> : T extends `${infer Left}/\${${string}}` ? PathPattern<`${Left}/${string}`> : T;
-type ValidatePath<Paths extends string, Path extends string> = Paths | (Path extends `/${string}` ? MatchSegments<Member<PathPattern<Paths>, Path>, Path> : Path);
-type ValidateHref<Paths extends string, Href extends string> = Href extends `${infer P}#${infer H}?${infer Q}` ? `${ValidatePath<Paths, P>}#${H}?${Q}` : Href extends `${infer P}?${infer Q}` ? `${ValidatePath<Paths, P>}?${Q}` : Href extends `${infer P}#${infer H}` ? `${ValidatePath<Paths, P>}#${H}` : ValidatePath<Paths, Href>;
-type NormalizedMetaObject<T, TVerb extends Verb = Verb> = IsObject<T> extends 1 ? TVerb extends keyof T ? Simplify<Omit<T, Verb | keyof T[TVerb]> & T[TVerb]> : Simplify<Omit<T, Verb>> : never;
-export type NormalizedMeta<T, TVerb extends Verb = Verb> = IsObject<T> extends 1 ? {
-    [K in TVerb]: NormalizedMetaObject<T, K>;
-}[TVerb] : T;
-export type NormalizedMetaLookup<T> = {
-    [K in Verb]: IsObject<T> extends 1 ? NormalizedMetaObject<T, K> : T;
-};
-export interface AppData {
-}
-export type Routes = AppData extends {
-    routes: infer T;
-} ? T : Record<string, Route>;
-export type AnyRoute = Routes[keyof Routes];
-export type HandlerTypeFn<TRoute extends Route = AnyRoute> = AppData extends {
-    routes: any;
-} ? <Params extends ParamsObject = ParamsObject, Meta = any, T extends HandlerLike<Route<Params, Meta>> = HandlerLike<Route<Params, Meta>>>(handler: T) => T : <T extends HandlerLike<TRoute>>(handler: T) => T;
 type DefaultAPI = keyof Exclude<Marko.Renderable, Marko.Template<any, any> | Marko.Body<any, any> | string> extends "content" ? "tags" : "class";
 type TemplateAPI<T> = T extends {
     api: infer API;
 } ? API : DefaultAPI;
-export type LayoutInput<T> = TemplateAPI<T> extends "tags" ? {
+export type LayoutInput<F extends File> = TemplateAPI<F["module"]> extends "tags" ? {
     content: Marko.Body;
 } : {
     renderBody: Marko.Body;
 };
-export type GetPaths = AppData extends {
-    getPaths: infer T;
-} ? T : string;
-export type PostPaths = AppData extends {
-    postPaths: infer T;
-} ? T : string;
-export type GetablePath<T extends string> = ValidatePath<GetPaths, T>;
-export type GetableHref<T extends string> = ValidateHref<GetPaths, T>;
-export type PostablePath<T extends string> = ValidatePath<PostPaths, T>;
-export type PostableHref<T extends string> = ValidateHref<PostPaths, T>;
+type GetProperty<Obj, Prop> = Prop extends keyof Obj ? Obj[Prop] : never;
+type GetRawSearchValidator<Path extends string, Verb extends HttpVerb = "GET"> = Path extends keyof AppPaths ? Verb extends keyof AppPaths[Path]["verbs"] ? GetProperty<AppPaths[Path]["verbs"][Verb]["rawOptions"], "search"> : never : never;
+type ParamObject<T> = {
+    [K in keyof T]: string | number;
+};
+export type HrefParams<Path extends `${string}/$${string}`> = {
+    [Param in PathParamKeys<Path>[number]]: Path extends `${string}/$$${Param}` ? string | number | (string | number)[] : string | number;
+};
+export type HrefOptions<Path extends string = `${string}/$${string}` | `${string}/$$${string}`> = Path extends `${string}/$${string}` ? HrefParamsOptions<Path> : HrefBaseOptions<Path>;
+interface HrefBaseOptions<Path extends string> {
+    search?: ParamObject<Valid<GetRawSearchValidator<Path>>>;
+    hash?: string | number;
+}
+interface HrefParamsOptions<Path extends `${string}/$${string}`> extends HrefBaseOptions<Path> {
+    params: HrefParams<Path>;
+}
+export type Href<Verb extends HttpVerbOrAll = "ALL"> = {
+    <Path extends PathsForVerb<Verb>>(path: Path, ...args: Path extends `${string}/$${string}` ? [options: HrefOptions<Path>] : [options?: HrefOptions<Path>]): string;
+};
 export {};

package/dist/runtime/url-builder.cjs

@@ -0,0 +1,96 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime/url-builder.ts
+var url_builder_exports = {};
+__export(url_builder_exports, {
+  href: () => href,
+  href_keys: () => href_keys,
+  href_path: () => href_path,
+  href_values: () => href_values,
+  parsePathParts: () => parsePathParts
+});
+module.exports = __toCommonJS(url_builder_exports);
+
+// scripts/importMetaURL.js
+var import_url = require("url");
+var __importMetaURL = (0, import_url.pathToFileURL)(__filename);
+
+// src/runtime/url-builder.ts
+var encode = encodeURIComponent;
+var pathParts = /* @__PURE__ */ new Map();
+function parsePathParts(path) {
+  let parts = pathParts.get(path);
+  if (!parts) {
+    let lastEnd = 0;
+    let paramStart;
+    pathParts.set(path, parts = [[]]);
+    while (lastEnd >= 0 && (paramStart = path.indexOf("/$", lastEnd) + 1)) {
+      parts.push(path.slice(lastEnd, paramStart++));
+      if (path.charAt(paramStart) === "$") {
+        paramStart++;
+        lastEnd = -1;
+      } else {
+        lastEnd = path.indexOf("/", paramStart);
+      }
+      parts[0].push(path.slice(paramStart, lastEnd < 0 ? void 0 : lastEnd));
+    }
+    parts.push(lastEnd >= 0 ? path.slice(lastEnd) : "");
+  }
+  return parts;
+}
+function joinHref(path, options) {
+  let result = path;
+  if (options.search) {
+    const query = "" + new URLSearchParams(options.search);
+    if (query) result += "?" + query;
+  }
+  if (options.hash) result += "#" + encode(options.hash);
+  return result;
+}
+function href(path, ...[options]) {
+  return options ? "params" in options ? ((parts) => href_keys(parts, options, ...parts[0]))(
+    parsePathParts(path)
+  ) : joinHref(path, options) : path;
+}
+function href_path(strings, ...params) {
+  let i = 0;
+  let j = 0;
+  let result = strings[i++];
+  if (!result || Array.isArray(result)) result = strings[i++];
+  while (i < strings.length) {
+    const param = params[j++];
+    result += (Array.isArray(param) ? param.map(encode).join("/") : encode(param)) + strings[i++];
+  }
+  return result;
+}
+function href_values(strings, options, ...params) {
+  return joinHref(href_path(strings, ...params), options);
+}
+function href_keys(strings, options, ...keys) {
+  return href_values(strings, options, ...keys.map((k) => options.params[k]));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  href,
+  href_keys,
+  href_path,
+  href_values,
+  parsePathParts
+});

package/dist/runtime/url-builder.d.ts

@@ -0,0 +1,6 @@
+import type { HrefOptions, PathsForVerb } from "./types";
+export declare function parsePathParts(path: string): [string[], ...string[]];
+export declare function href<Path extends PathsForVerb>(path: Path, ...[options]: Path extends `${string}/$${string}` ? [options: HrefOptions<Path>] : [options?: HrefOptions<Path>]): string;
+export declare function href_path(strings: TemplateStringsArray, ...params: (string | number | (string | number)[])[]): string;
+export declare function href_values(strings: TemplateStringsArray, options: HrefOptions<any>, ...params: (string | number | (string | number)[])[]): string;
+export declare function href_keys(strings: TemplateStringsArray, options: HrefOptions, ...keys: string[]): string;