@marko/run 0.11.0-rc.1 → 0.11.0-rc.3

package/dist/runtime/types.d.ts

@@ -15,7 +15,15 @@ export type FormBodyValidatorOptions<Ctx> = {
     maxFileBytes?: number;
     onFile?(ctx: Ctx, file: Multipart): any;
 };
-type Schema<I, O> = [O, undefined] | [I, StandardSchemaV1.FailureResult["issues"]];
+interface Empty {
+}
+declare const MARKO_RUN_TYPES: unique symbol;
+declare global {
+    interface Response {
+        readonly [MARKO_RUN_TYPES]: void;
+    }
+}
+export 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";
@@ -43,12 +51,12 @@ type MapTuple<T extends readonly any[], K extends keyof T[number], Value = never
 };
 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 MergeTwo<A, B> = IsPlainObject<A> extends true ? IsPlainObject<B> extends true ? Simplify<Omit<A, keyof B> & B> : B : IsPlainObject<B> extends true ? B : Empty;
 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 : {} : {};
+] ? MergeTuple<[MergeTwo<A, B>, ...Rest]> : T extends readonly [infer Only] ? IsPlainObject<Only> extends true ? Only : Empty : Empty;
 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;
@@ -70,7 +78,7 @@ export type NormalizedMeta<Meta, Verb extends HttpVerb> = IsPlainObject<Meta> ex
     [K in Verb]: NormalizedMetaObject<Meta, K>;
 }[Verb] : Meta;
 export type NormalizedMetaLookup<T> = {
-    [K in HttpVerb]: IsPlainObject<T> extends 1 ? NormalizedMetaObject<T, K> : T;
+    [K in HttpVerb]: IsPlainObject<T> extends true ? NormalizedMetaObject<T, K> : T;
 };
 type NormalizedMetaFiles<Files extends readonly File[], Verb extends HttpVerb> = {
     [I in keyof Files]: NormalizedMeta<Files[I]["exports"], Verb>;
@@ -106,12 +114,12 @@ export interface RouteDef<Path extends string = string, Verb extends HttpVerb =
         {
             form: infer T;
         }
-    ] ? T : never : undefined;
+    ] ? Promise<T> : never : undefined;
     json: Verb extends HttpVerbWithBody ? Options extends [
         {
             json: infer T;
         }
-    ] ? T : never : undefined;
+    ] ? Promise<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
@@ -123,12 +131,12 @@ export interface Route<Def extends RouteDef = RouteDef, Data = any> {
     params: Def["params"];
     search: Def["search"];
     body: Fallback<Def["json"], Fallback<Def["form"], undefined>>;
-    data: Data extends [infer T extends RouteData] ? T : RouteData;
+    data: Data extends [infer T extends RouteData] ? T : Empty;
 }
 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 RouteFileGroupMeta<Group extends RouteFileGroup, Verb extends HttpVerb> = Fallback<MergeTuple<NormalizedMetaFiles<Group["meta"], Verb>>, Empty>;
+type RouteFileGroupOptions<Group extends RouteFileGroup, Verb extends HttpVerb> = MergeHandlerOptionsTuple<MapTuple<TypesFromHandlerFiles<[...Group["middleware"], Group["handler"]], Verb>, "options", Empty>>;
+type RouteFileGroupData<Group extends RouteFileGroup, Verb extends HttpVerb> = MergeTuple<MapTuple<TypesFromHandlerFiles<[...Group["middleware"], Group["handler"]], Verb>, "data", Empty>>;
 type TypesFromHandlerFiles<Files extends File[], Verb extends HttpVerb> = {
     [I in keyof Files]: TypesFromHandlerFile<Files[I], Verb>;
 };
@@ -141,32 +149,68 @@ type DefineRoute<Path extends string, Group extends RouteFileGroup> = {
     verbs: {
         [Verb in RouteFileGroupVerb<Group>]: {
             rawOptions: RouteFileGroupOptions<Group, Verb>;
-            options: Fallback<Validation<RouteFileGroupOptions<Group, Verb>>, {}>;
+            options: Fallback<Validation<RouteFileGroupOptions<Group, Verb>>, Empty>;
             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"];
-            } : {}>;
+            } : Empty>;
         };
     };
 };
-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<{}, {
+type ExtractHandlerData<U> = U extends Typed<{}, {
     data: infer Data;
-}> ? Data : {};
-export interface NormalizedHandlerFunction<Ctx, Options> extends HandlerFunction<Ctx, Promise<Response>> {
+}> ? Data : never;
+type HandlerDataUnionKeys<U> = U extends unknown ? keyof U : never;
+type HandlerDataUnionValue<U, K extends PropertyKey> = U extends unknown ? K extends keyof U ? U[K] : never : never;
+type HandlerDataRequiredKeys<U> = {
+    [K in HandlerDataUnionKeys<U>]: [U] extends [
+        {
+            [P in K]-?: unknown;
+        }
+    ] ? K : never;
+}[HandlerDataUnionKeys<U>];
+type MergeHandlerData<U> = Simplify<{
+    [K in HandlerDataRequiredKeys<U>]: HandlerDataUnionValue<U, K>;
+} & {
+    [K in Exclude<HandlerDataUnionKeys<U>, HandlerDataRequiredKeys<U>>]?: HandlerDataUnionValue<U, K>;
+}>;
+type HandlerFuncData<T> = MergeHandlerData<ExtractHandlerData<Awaited<T>>>;
+export interface NormalizedHandlerFunction<Verb extends HttpVerbOrAll, Options> extends HandlerFunction<Context, Promise<Response>> {
     options: Options;
+    verb: Verb;
 }
-export type NormalizedHandler<Ctx, Verb extends HttpVerbOrAll, Return, Options> = Typed<NormalizedHandlerFunction<Ctx, Options>, HandlerTypes<Ctx, Verb, Options, Return extends readonly unknown[] ? MergeTuple<{
+export type NormalizedHandler<Ctx, Verb extends HttpVerbOrAll, Return, Options> = Typed<NormalizedHandlerFunction<Verb, 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]>;
+    [K in keyof Return]: {
+        [MARKO_RUN_TYPES]: {
+            options: any;
+            data: any;
+        };
+    } | HandlerFunction<Ctx, Return[K]>;
 };
+type HandlerValueOptions<H> = H extends {
+    [MARKO_RUN_TYPES]: {
+        options: infer O;
+    };
+} ? O : never;
+type ComposedHandlerOptions<Handlers extends readonly unknown[]> = MergeHandlerOptionsTuple<{
+    [K in keyof Handlers]: HandlerValueOptions<Handlers[K]>;
+}>;
+type HandlerValueData<H> = H extends {
+    [MARKO_RUN_TYPES]: {
+        data: infer D;
+    };
+} ? D : H extends (...args: any[]) => infer R ? HandlerFuncData<R> : Empty;
+type ComposedHandlerData<Handlers extends readonly unknown[]> = MergeTuple<{
+    [K in keyof Handlers]: HandlerValueData<Handlers[K]>;
+}>;
 type Exact<T, Shape> = T & Record<Exclude<keyof T, keyof Shape>, never>;
 type DefineHandlerOptions<Verb extends HttpVerbOrAll, Ctx> = [Verb] extends [
     HttpVerbWithoutBody
@@ -174,17 +218,17 @@ type DefineHandlerOptions<Verb extends HttpVerbOrAll, Ctx> = [Verb] extends [
 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>;
+    } ? 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>>, {}>;
+], Verb, Id, Options>, "options", Empty>>;
+type MergedRouteOptionsForFile<Path extends keyof AppPaths, Verb extends HttpVerb, Id extends ID, Options> = Fallback<Validation<RouteFileGroupOptionsWithLocal<AppPaths[Path]["files"], Verb, Id, Options>>, Empty>;
 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"] : {};
+    meta: Verb extends keyof AppPaths[Path]["verbs"] ? AppPaths[Path]["verbs"][Verb]["def"]["meta"] : Empty;
     params: MergedRouteOptionsForFile<Path, Verb, F["id"], Options> extends {
         params: infer T;
     } ? T : Simplify<PathParams<Path & string>>;
@@ -193,10 +237,10 @@ export interface RouteForFileDef<F extends File, Path extends keyof AppPaths, Ve
     } ? T : undefined;
     body: Verb extends HttpVerbWithBody ? MergedRouteOptionsForFile<Path, Verb, F["id"], Options> extends {
         json: infer T;
-    } ? T : MergedRouteOptionsForFile<Path, Verb, F["id"], Options> extends {
+    } ? Promise<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;
+    } ? Promise<T> : undefined : undefined;
+    data: [F & 1] extends [0] ? Partial<AppPaths[Path]["verbs"][Verb]["data"]> : GetUpstreamData<F, Path, Verb> extends [infer T extends RouteData] ? T : Empty;
 }
 type ContextForFileWithOptions<F extends File, Verb extends HttpVerbOrAll, Options> = Union<{
     [Path in PathsForFile<F>]: Union<{
@@ -204,11 +248,11 @@ type ContextForFileWithOptions<F extends File, Verb extends HttpVerbOrAll, Optio
     }>;
 }>;
 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>;
+    <const Handlers extends readonly unknown[], Return extends unknown[]>(handlers: HandlerArray<ContextForFileWithOptions<F, Verb, Empty> & {}, Return> & Handlers): Typed<NormalizedHandlerFunction<Verb, ComposedHandlerOptions<Handlers>>, HandlerTypes<ContextForFileWithOptions<F, Verb, Empty> & {}, Verb, ComposedHandlerOptions<Handlers>, ComposedHandlerData<Handlers>>>;
+    <const Options extends DefineHandlerOptions<Verb, ContextForFileWithOptions<F, Verb, Empty> & {}>, const Handlers extends readonly unknown[], Return extends unknown[]>(options: Exact<Options, DefineHandlerOptions<Verb, ContextForFileWithOptions<F, Verb, Empty> & {}>>, handlers: HandlerArray<ContextForFileWithOptions<F, Verb, Options> & {}, Return> & Handlers): Typed<NormalizedHandlerFunction<Verb, MergeHandlerOptions<ComposedHandlerOptions<Handlers>, Options>>, HandlerTypes<ContextForFileWithOptions<F, Verb, Options> & {}, Verb, MergeHandlerOptions<ComposedHandlerOptions<Handlers>, Options>, ComposedHandlerData<Handlers>>>;
+    <Return>(handler: HandlerFunction<ContextForFileWithOptions<F, Verb, Empty> & {}, Return>): NormalizedHandler<ContextForFileWithOptions<F, Verb, Empty> & {}, Verb, Return, {}>;
+    <const Options extends DefineHandlerOptions<Verb, ContextForFileWithOptions<F, Verb, Empty> & {}>>(options: Exact<Options, DefineHandlerOptions<Verb, ContextForFileWithOptions<F, Verb, Empty> & {}>>): NormalizedHandler<ContextForFileWithOptions<F, Verb, Options> & {}, Verb, {}, Options>;
+    <const Options extends DefineHandlerOptions<Verb, ContextForFileWithOptions<F, Verb, Empty> & {}>, Return>(options: Exact<Options, DefineHandlerOptions<Verb, ContextForFileWithOptions<F, Verb, Empty> & {}>>, handler: HandlerFunction<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;
@@ -221,10 +265,10 @@ type GetUpstreamData<F extends File, Path extends PathsForFile<F>, Verb extends
         ] : TakeUntil<[
             ...AppPaths[Path]["files"]["middleware"],
             AppPaths[Path]["files"]["handler"]
-        ], F["id"]>, V>, "data", {}>> : {};
+        ], F["id"]>, V>, "data", Empty>> : Empty;
     }>
-] : {};
-type HandlerReturnValue = void | undefined | null | Response | typeof MarkoRun.NotHandled | typeof MarkoRun.NotMatched;
+] : Empty;
+type HandlerReturnValue = void | undefined | null | Response | Typed<Response, any> | 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 {
@@ -270,9 +314,6 @@ type FilterContextByVerb<Ctx extends Context, Verb extends HttpVerbOrAll> = Verb
     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 {
@@ -289,8 +330,12 @@ type AvailableVerbs<Scope extends keyof AppPaths | object> = Scope extends strin
 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;
+export type Typed<Original, Types> = ([Original] extends [
+    {
+        readonly [MARKO_RUN_TYPES]: any;
+    }
+] ? Omit<Original, typeof MARKO_RUN_TYPES> : Original) & {
+    [MARKO_RUN_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<{
@@ -304,11 +349,11 @@ export type ContextForFile<F extends File, Verb extends HttpVerbOrAll = F["type"
 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> {
+export interface HandlerTypes<Ctx = Context, Verb extends HttpVerbOrAll = HttpVerbOrAll, Options = HandlerOptions<Ctx>, Data = Empty> {
     context: Ctx;
     verb: Verb;
     options: Options;
-    data: Data extends RouteData ? Data : {};
+    data: Data extends RouteData ? Data : Empty;
 }
 export type Middleware<Id extends ID, Mod> = File<Id, "middleware", Mod>;
 export type Handler<Id extends ID, Mod> = File<Id, "handler", Mod>;
@@ -319,15 +364,13 @@ export type NamespaceVerb<Verb extends HttpVerbOrAll = "ALL"> = {
     href: Href<Verb>;
 };
 export type GlobalNamespace = {
-    [Verb in HttpVerbOrAll]: NamespaceVerb<Verb>;
+    [Verb in HttpVerbOrAll]: DefineHandler<any, Verb>;
 } & NamespaceVerb;
 export type Namespace<F extends File> = Typed<(F["type"] extends "middleware" ? {
-    [Verb in HttpVerbOrAll]: DefineHandler<F, Verb> & NamespaceVerb<Verb>;
+    [Verb in HttpVerbOrAll]: DefineHandler<F, Verb>;
 } : F["type"] extends "handler" ? {
-    [Verb in HttpVerb]: DefineHandler<F, Verb> & NamespaceVerb<Verb>;
-} : {
-    [Verb in AllVerbs]: NamespaceVerb<Verb>;
-}) & NamespaceVerb, {
+    [Verb in HttpVerb]: DefineHandler<F, Verb>;
+} : Empty) & NamespaceVerb, {
     context: ContextForFile<F> & {};
 }>;
 export type DefineRoutes<Paths = void> = {
@@ -372,7 +415,9 @@ export type GetContext<Scope extends keyof AppPaths | `*` | `/${string}*` | obje
 } ? 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 type NextFunction = <Data extends RouteData = Empty>(data?: Data) => Promise<Typed<Response, {
+    data: Data;
+}>>;
 export interface App {
 }
 export interface RouteMatch<Ctx extends Context = Context> {
@@ -390,26 +435,23 @@ export interface RuntimeModule {
     match: Match;
     invoke<TPlatform extends Platform = Platform>(...args: Parameters<Invoke<TPlatform>>): ReturnType<Invoke<TPlatform>>;
 }
-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;
+} ? API : keyof Exclude<Marko.Renderable, Marko.Template<any, any> | Marko.Body<any, any> | string> extends "content" ? "tags" : "class";
 export type LayoutInput<F extends File> = TemplateAPI<F["module"]> extends "tags" ? {
     content: Marko.Body;
 } : {
     renderBody: Marko.Body;
 };
-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;
-};
+type GetRawSearchValidator<Path extends string, Verb extends HttpVerb = "GET"> = Path extends keyof AppPaths ? Verb extends keyof AppPaths[Path]["verbs"] ? "search" extends keyof AppPaths[Path]["verbs"][Verb]["rawOptions"] ? AppPaths[Path]["verbs"][Verb]["rawOptions"]["search"] : never : never : never;
 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>>>;
+    search?: {
+        [K in keyof Valid<GetRawSearchValidator<Path>>]: string | number;
+    };
     hash?: string | number;
 }
 interface HrefParamsOptions<Path extends `${string}/$${string}`> extends HrefBaseOptions<Path> {

package/dist/vite/constants.d.ts

@@ -7,9 +7,9 @@ export declare const RoutableFileTypes: {
     readonly Handler: "handler";
     readonly Layout: "layout";
     readonly Page: "page";
-    readonly Meta: "meta";
     readonly NotFound: "404";
     readonly Error: "500";
+    readonly Meta: "meta";
 };
 export type RoutableFileType = ValuesOf<typeof RoutableFileTypes>;
 export type HttpVerb = (typeof httpVerbs)[number];

package/dist/vite/index.cjs

@@ -115,9 +115,9 @@ var RoutableFileTypes = {
   Handler: "handler",
   Layout: "layout",
   Page: "page",
-  Meta: "meta",
   NotFound: "404",
-  Error: "500"
+  Error: "500",
+  Meta: "meta"
 };
 
 // src/vite/utils/fs.ts
@@ -927,6 +927,7 @@ async function renderRouteTypeInfo(routes, outDir, adapter) {
 `);
     }
   }
+  headWriter.join();
   const fileInfoByType = /* @__PURE__ */ new Map();
   let fileIndex = 1;
   function addFile(file) {
@@ -965,6 +966,11 @@ async function renderRouteTypeInfo(routes, outDir, adapter) {
           info.id = `P${group.size + 1}`;
           info.typeName = "Template";
           break;
+        case RoutableFileTypes.Error:
+        case RoutableFileTypes.NotFound:
+          info.id = "";
+          info.typeName = "Template";
+          break;
         default:
           info.id = `F${fileIndex++}`;
           break;
@@ -993,14 +999,20 @@ async function renderRouteTypeInfo(routes, outDir, adapter) {
   for (const fileType of Object.values(RoutableFileTypes)) {
     const fileGroup = fileInfoByType.get(fileType);
     if (!fileGroup) continue;
-    for (const info of fileGroup.values()) {
+    const hasModule = fileType !== RoutableFileTypes.Meta;
+    if (!hasModule) {
       writer.writeLines("");
-      if (info.typeName) {
+    }
+    for (const info of fileGroup.values()) {
+      if (hasModule) {
+        writer.writeLines("");
+      }
+      if (info.typeName && info.id) {
         writer.writeLines(
           `type ${info.id} = $.${info.typeName}<"${info.id}", typeof import("${info.modulePath}")>;`
         );
       }
-      if (fileType === RoutableFileTypes.Meta) continue;
+      if (!hasModule) continue;
       writer.write(`declare module "${info.modulePath}" {`);
       switch (fileType) {
         case RoutableFileTypes.Layout:
@@ -1015,10 +1027,11 @@ async function renderRouteTypeInfo(routes, outDir, adapter) {
           break;
       }
       if (info.typeName) {
+        const id = info.id || "any";
         writer.write(`
-  const Run: $.Namespace<${info.id}>;
+  const Run: $.Namespace<${id}>;
   namespace Run {
-    type Context = $.ContextForFile<${info.id}>${info.typeName === "Template" ? " & Marko.Global" : ""};
+    type Context = $.ContextForFile<${id}>${info.typeName === "Template" ? " & Marko.Global" : ""};
   }
 `);
       }
@@ -1039,7 +1052,6 @@ async function renderRouteTypeInfo(routes, outDir, adapter) {
 }`);
     }
   }
-  headWriter.join();
   return writer.end();
 }
 function createRouteTrie(routes) {

package/dist/vite/index.js

@@ -72,9 +72,9 @@ var RoutableFileTypes = {
   Handler: "handler",
   Layout: "layout",
   Page: "page",
-  Meta: "meta",
   NotFound: "404",
-  Error: "500"
+  Error: "500",
+  Meta: "meta"
 };
 
 // src/vite/utils/fs.ts
@@ -884,6 +884,7 @@ async function renderRouteTypeInfo(routes, outDir, adapter) {
 `);
     }
   }
+  headWriter.join();
   const fileInfoByType = /* @__PURE__ */ new Map();
   let fileIndex = 1;
   function addFile(file) {
@@ -922,6 +923,11 @@ async function renderRouteTypeInfo(routes, outDir, adapter) {
           info.id = `P${group.size + 1}`;
           info.typeName = "Template";
           break;
+        case RoutableFileTypes.Error:
+        case RoutableFileTypes.NotFound:
+          info.id = "";
+          info.typeName = "Template";
+          break;
         default:
           info.id = `F${fileIndex++}`;
           break;
@@ -950,14 +956,20 @@ async function renderRouteTypeInfo(routes, outDir, adapter) {
   for (const fileType of Object.values(RoutableFileTypes)) {
     const fileGroup = fileInfoByType.get(fileType);
     if (!fileGroup) continue;
-    for (const info of fileGroup.values()) {
+    const hasModule = fileType !== RoutableFileTypes.Meta;
+    if (!hasModule) {
       writer.writeLines("");
-      if (info.typeName) {
+    }
+    for (const info of fileGroup.values()) {
+      if (hasModule) {
+        writer.writeLines("");
+      }
+      if (info.typeName && info.id) {
         writer.writeLines(
           `type ${info.id} = $.${info.typeName}<"${info.id}", typeof import("${info.modulePath}")>;`
         );
       }
-      if (fileType === RoutableFileTypes.Meta) continue;
+      if (!hasModule) continue;
       writer.write(`declare module "${info.modulePath}" {`);
       switch (fileType) {
         case RoutableFileTypes.Layout:
@@ -972,10 +984,11 @@ async function renderRouteTypeInfo(routes, outDir, adapter) {
           break;
       }
       if (info.typeName) {
+        const id = info.id || "any";
         writer.write(`
-  const Run: $.Namespace<${info.id}>;
+  const Run: $.Namespace<${id}>;
   namespace Run {
-    type Context = $.ContextForFile<${info.id}>${info.typeName === "Template" ? " & Marko.Global" : ""};
+    type Context = $.ContextForFile<${id}>${info.typeName === "Template" ? " & Marko.Global" : ""};
   }
 `);
       }
@@ -996,7 +1009,6 @@ async function renderRouteTypeInfo(routes, outDir, adapter) {
 }`);
     }
   }
-  headWriter.join();
   return writer.end();
 }
 function createRouteTrie(routes) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marko/run",
-  "version": "0.11.0-rc.1",
+  "version": "0.11.0-rc.3",
   "description": "The Marko application framework.",
   "keywords": [
     "marko"
@@ -46,12 +46,24 @@
   "types": "./dist/runtime/index.d.ts",
   "typesVersions": {
     "*": {
-      "*": ["./dist/runtime/index.d.ts"],
-      "namespace": ["./dist/runtime/namespace.d.ts"],
-      "router": ["./dist/runtime/router.d.ts"],
-      "vite": ["./dist/vite/index.d.ts"],
-      "adapter/middleware": ["./dist/adapter/middleware.d.ts"],
-      "adapter": ["./dist/adapter/index.d.ts"]
+      "*": [
+        "./dist/runtime/index.d.ts"
+      ],
+      "namespace": [
+        "./dist/runtime/namespace.d.ts"
+      ],
+      "router": [
+        "./dist/runtime/router.d.ts"
+      ],
+      "vite": [
+        "./dist/vite/index.d.ts"
+      ],
+      "adapter/middleware": [
+        "./dist/adapter/middleware.d.ts"
+      ],
+      "adapter": [
+        "./dist/adapter/index.d.ts"
+      ]
     }
   },
   "bin": {