@marko/run 0.9.4 → 0.9.6

package/dist/cli/index.mjs

@@ -326,7 +326,10 @@ function renderRouteEntry(route, rootDir) {
   const imports = writer.branch("imports");
   const runtimeImports = [];
   if (handler) {
-    runtimeImports.push("normalize");
+    runtimeImports.push("normalizeHandler");
+  }
+  if (meta) {
+    runtimeImports.push("normalizeMeta");
   }
   if (handler || middleware.length) {
     runtimeImports.push("call");
@@ -358,7 +361,9 @@ function renderRouteEntry(route, rootDir) {
     for (const verb of handler.verbs) {
       const importName = verb.toUpperCase();
       names.push(importName);
-      writer.writeLines(`const ${verb}Handler = normalize(${importName});`);
+      writer.writeLines(
+        `const ${verb}Handler = normalizeHandler(${importName});`
+      );
     }
     imports.writeLines(
       `import { ${names.join(", ")} } from "${normalizedRelativePath(rootDir, handler.filePath)}";`
@@ -370,8 +375,18 @@ function renderRouteEntry(route, rootDir) {
     );
   }
   if (meta) {
+    const metaName = `meta${index}`;
+    const metaVerbsExports = verbs.map((verb) => {
+      var _a2;
+      const name = verb === "head" && !((_a2 = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a2.includes(verb)) ? "GET" : verb.toUpperCase();
+      return `${name}: ${verb}${index}_meta`;
+    }).join(", ");
+    writer.writeLines("");
     imports.writeLines(
-      `export { default as meta${index} } from "${normalizedRelativePath(rootDir, meta.filePath)}";`
+      `import ${metaName} from "${normalizedRelativePath(rootDir, meta.filePath)}";`
+    );
+    writer.writeLines(
+      `export const { ${metaVerbsExports} } = normalizeMeta(${metaName});`
     );
   }
   for (const verb of verbs) {
@@ -490,10 +505,16 @@ function renderRouter(routes, rootDir, runtimeInclude, options = {
   );
   for (const route of routes.list) {
     const verbs = getVerbs(route);
-    const names = verbs.map((verb) => `${verb}${route.index}`);
-    route.meta && names.push(`meta${route.index}`);
+    const routeImports = [];
+    for (const verb of verbs) {
+      const verbName = `${verb}${route.index}`;
+      routeImports.push(verbName);
+      if (route.meta) {
+        routeImports.push(`${verbName}_meta`);
+      }
+    }
     imports.writeLines(
-      `import { ${names.join(", ")} } from "${virtualFilePrefix}/${getRouteVirtualFileName(route)}";`
+      `import { ${routeImports.join(", ")} } from "${virtualFilePrefix}/${getRouteVirtualFileName(route)}";`
     );
   }
   for (const route of Object.values(routes.special)) {
@@ -785,14 +806,14 @@ function renderParams(params, pathIndex) {
 function renderMatch(verb, route, path10, pathIndex) {
   const handler = `${verb}${route.index}`;
   const params = path10.params ? renderParams(path10.params, pathIndex) : "{}";
-  const meta = route.meta ? `meta${route.index}` : "{}";
+  const meta = route.meta ? `${verb}${route.index}_meta` : "{}";
   return `{ handler: ${handler}, params: ${params}, meta: ${meta}, path: '${path10.path}' }`;
 }
 function renderMiddleware(middleware, rootDir) {
   const writer = createStringWriter();
   const imports = writer.branch("imports");
   imports.writeLines(
-    `import { normalize } from "${virtualFilePrefix}/runtime/internal";`
+    `import { normalizeHandler } from "${virtualFilePrefix}/runtime/internal";`
   );
   writer.writeLines("");
   for (const { id, filePath } of middleware) {
@@ -800,7 +821,9 @@ function renderMiddleware(middleware, rootDir) {
     imports.writeLines(
       `import ${importName} from "${normalizedRelativePath(rootDir, filePath)}";`
     );
-    writer.writeLines(`export const mware${id} = normalize(${importName});`);
+    writer.writeLines(
+      `export const mware${id} = normalizeHandler(${importName});`
+    );
   }
   imports.join();
   return writer.end();
@@ -959,7 +982,12 @@ function writeModuleDeclaration(writer, name, routeType, moduleTypes) {
     export { NotHandled, NotMatched, GetPaths, PostPaths, GetablePath, GetableHref, PostablePath, PostableHref, Platform };
     export type Route = ${routeType};
     export type Context = Run.MultiRouteContext<Route>${isMarko ? " & Marko.Global" : ""};
-    export type Handler = Run.HandlerLike<Route>;
+    export type Handler = Run.HandlerLike<Route>;`);
+    for (const verb of httpVerbs) {
+      writer.write(`
+    export type ${verb.toUpperCase()} = Run.HandlerLike<Route, "${verb.toUpperCase()}">;`);
+    }
+    writer.write(`
     /** @deprecated use \`((context, next) => { ... }) satisfies MarkoRun.Handler\` instead */
     export const route: Run.HandlerTypeFn<Route>;
   }`);
@@ -1560,7 +1588,7 @@ function createFSWalker(dir) {
 }
 
 // src/vite/utils/ast.ts
-import * as t from "@babel/types";
+import { types as t } from "@marko/compiler";
 function getExportIdentifiers(astProgramNode) {
   const result = [];
   if (t.isProgram(astProgramNode)) {

package/dist/runtime/index.d.ts

@@ -1,13 +1,23 @@
 import { InlineConfig } from "vite";
 import { NotHandled, NotMatched } from "./namespace";
-import type { AnyContext, AnyHandler, AnyRoute, GetableHref, GetablePath, GetPaths, HandlerTypeFn, Platform, PostableHref, PostablePath, PostPaths, RuntimeModule } from "./types";
+import type { AnyRoute, GetableHref, GetablePath, GetPaths, HandlerLike, HandlerTypeFn, MultiRouteContext, Platform, PostableHref, PostablePath, PostPaths, RuntimeModule } from "./types";
 declare global {
     var __marko_run__: RuntimeModule;
     var __marko_run_vite_config__: InlineConfig | undefined;
     namespace MarkoRun {
+        export { GetableHref, GetablePath, GetPaths, NotHandled, NotMatched, Platform, PostableHref, PostablePath, PostPaths, };
+        export type Route = AnyRoute;
+        export type Context = MultiRouteContext<AnyRoute>;
+        export type Handler = HandlerLike<AnyRoute>;
+        export type GET = HandlerLike<AnyRoute, "GET">;
+        export type HEAD = HandlerLike<AnyRoute, "HEAD">;
+        export type POST = HandlerLike<AnyRoute, "POST">;
+        export type PUT = HandlerLike<AnyRoute, "PUT">;
+        export type DELETE = HandlerLike<AnyRoute, "DELETE">;
+        export type PATCH = HandlerLike<AnyRoute, "PATCH">;
+        export type OPTIONS = HandlerLike<AnyRoute, "OPTIONS">;
         /** @deprecated use `((context, next) => { ... }) satisfies MarkoRun.Handler` instead */
         export const route: HandlerTypeFn;
-        export { AnyContext as Context, GetableHref, GetablePath, GetPaths, AnyHandler as Handler, NotHandled, NotMatched, Platform, PostableHref, PostablePath, PostPaths, AnyRoute as Route, };
     }
 }
-export type { AppData, Context, DefineApp, Fetch, HandlerLike, HandlerTypeFn, InputObject, Invoke, LayoutInput, Match, MultiRouteContext, NextFunction, ParamsObject, Platform, Route, RouteHandler, Routes, RouteWithHandler, RuntimeModule, } from "./types";
+export type { AppData, Context, DefineApp, Fetch, HandlerLike, HandlerTypeFn, InputObject, Invoke, LayoutInput, Match, MultiRouteContext, NextFunction, ParamsObject, Platform, Route, RouteHandler, Routes, RouteWithHandler, RuntimeModule, Verb, } from "./types";

package/dist/runtime/internal.cjs

@@ -26,7 +26,8 @@ __export(internal_exports, {
   compose: () => compose,
   createContext: () => createContext,
   noContent: () => noContent,
-  normalize: () => normalize,
+  normalizeHandler: () => normalizeHandler,
+  normalizeMeta: () => getMetaDataLookup,
   notHandled: () => notHandled,
   notMatched: () => notMatched,
   passthrough: () => passthrough,
@@ -39,6 +40,49 @@ module.exports = __toCommonJS(internal_exports);
 var import_url = require("url");
 var __importMetaURL = (0, import_url.pathToFileURL)(__filename);
 
+// src/vite/constants.ts
+var httpVerbs = [
+  "get",
+  "head",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "options"
+];
+
+// src/vite/utils/meta-data.ts
+var verbKeys = new Set(httpVerbs.map((v) => v.toUpperCase()));
+function isObject(obj) {
+  return obj && typeof obj === "object" && !Array.isArray(obj);
+}
+function getMetaDataForVerb(data, verb) {
+  if (!httpVerbs.includes(verb.toLowerCase())) {
+    throw new Error(
+      `Invalid argument 'verb': expected one of ${[...verbKeys].join(", ")} but received ${verb}`
+    );
+  }
+  if (isObject(data)) {
+    return Object.keys(data).reduce(
+      (result, key) => {
+        if (!(key in result || verbKeys.has(key))) {
+          result[key] = data[key];
+        }
+        return result;
+      },
+      isObject(data[verb]) ? { ...data[verb] } : {}
+    );
+  }
+  return data;
+}
+function getMetaDataLookup(data) {
+  const lookup = {};
+  for (const verb of verbKeys) {
+    lookup[verb] = getMetaDataForVerb(data, verb);
+  }
+  return lookup;
+}
+
 // src/runtime/internal.ts
 var NotHandled = Symbol(
   "marko-run not handled"
@@ -101,6 +145,7 @@ function createContext(route, request, platform, url = new URL(request.url)) {
   }
   return {
     request,
+    method: request.method,
     url,
     platform,
     meta,
@@ -211,7 +256,7 @@ function compose(handlers) {
     })();
   };
 }
-function normalize(obj) {
+function normalizeHandler(obj) {
   if (typeof obj === "function") {
     return obj;
   } else if (Array.isArray(obj)) {
@@ -255,7 +300,8 @@ function notMatched() {
   compose,
   createContext,
   noContent,
-  normalize,
+  normalizeHandler,
+  normalizeMeta,
   notHandled,
   notMatched,
   passthrough,

package/dist/runtime/internal.d.ts

@@ -1,10 +1,11 @@
 import type { AnyRoute, Awaitable, Context, MultiRouteContext, NextFunction, Platform, RouteHandler } from "./types";
+export { getMetaDataLookup as normalizeMeta } from "../vite/utils/meta-data";
 export declare const NotHandled: typeof MarkoRun.NotHandled;
 export declare const NotMatched: typeof MarkoRun.NotMatched;
 export declare function createContext<TRoute extends AnyRoute>(route: TRoute | null, request: Request, platform: Platform, url?: URL): Context<TRoute>;
 export declare function call<TRoute extends AnyRoute>(handler: RouteHandler<TRoute>, next: NextFunction, context: MultiRouteContext<TRoute>): Promise<Response>;
 export declare function compose(handlers: RouteHandler[]): RouteHandler;
-export declare function normalize(obj: RouteHandler | RouteHandler[] | Promise<RouteHandler | RouteHandler[]>): RouteHandler;
+export declare function normalizeHandler(obj: RouteHandler | RouteHandler[] | Promise<RouteHandler | RouteHandler[]>): RouteHandler;
 export declare function stripResponseBodySync(response: Response): Response;
 export declare function stripResponseBody(response: Awaitable<Response>): Awaitable<Response>;
 export declare function passthrough(): void;

package/dist/runtime/internal.js

@@ -1,3 +1,46 @@
+// src/vite/constants.ts
+var httpVerbs = [
+  "get",
+  "head",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "options"
+];
+
+// src/vite/utils/meta-data.ts
+var verbKeys = new Set(httpVerbs.map((v) => v.toUpperCase()));
+function isObject(obj) {
+  return obj && typeof obj === "object" && !Array.isArray(obj);
+}
+function getMetaDataForVerb(data, verb) {
+  if (!httpVerbs.includes(verb.toLowerCase())) {
+    throw new Error(
+      `Invalid argument 'verb': expected one of ${[...verbKeys].join(", ")} but received ${verb}`
+    );
+  }
+  if (isObject(data)) {
+    return Object.keys(data).reduce(
+      (result, key) => {
+        if (!(key in result || verbKeys.has(key))) {
+          result[key] = data[key];
+        }
+        return result;
+      },
+      isObject(data[verb]) ? { ...data[verb] } : {}
+    );
+  }
+  return data;
+}
+function getMetaDataLookup(data) {
+  const lookup = {};
+  for (const verb of verbKeys) {
+    lookup[verb] = getMetaDataForVerb(data, verb);
+  }
+  return lookup;
+}
+
 // src/runtime/internal.ts
 var NotHandled = Symbol(
   "marko-run not handled"
@@ -60,6 +103,7 @@ function createContext(route, request, platform, url = new URL(request.url)) {
   }
   return {
     request,
+    method: request.method,
     url,
     platform,
     meta,
@@ -170,7 +214,7 @@ function compose(handlers) {
     })();
   };
 }
-function normalize(obj) {
+function normalizeHandler(obj) {
   if (typeof obj === "function") {
     return obj;
   } else if (Array.isArray(obj)) {
@@ -213,7 +257,8 @@ export {
   compose,
   createContext,
   noContent,
-  normalize,
+  normalizeHandler,
+  getMetaDataLookup as normalizeMeta,
   notHandled,
   notMatched,
   passthrough,

package/dist/runtime/namespace.d.ts

@@ -1,3 +1,3 @@
 export declare const NotHandled: unique symbol;
 export declare const NotMatched: unique symbol;
-export type { GetableHref, GetablePath, GetPaths, Platform, PostableHref, PostablePath, PostPaths, } from "./types";
+export type { GetableHref, GetablePath, GetPaths, Platform, PostableHref, PostablePath, PostPaths, Verb, } from "./types";

package/dist/runtime/types.d.ts

@@ -1,24 +1,28 @@
-export type Awaitable<T> = Promise<T> | T;
+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>;
 export interface Platform {
 }
-export interface Context<TRoute extends Route = AnyRoute> {
+export interface Context<TRoute extends Route = AnyRoute, TVerb extends Verb = Verb> {
     readonly url: URL;
     readonly request: Request;
+    readonly method: TVerb;
     readonly route: TRoute["path"];
     readonly params: TRoute["params"];
-    readonly meta: TRoute["meta"];
+    readonly meta: NormalizedMeta<TRoute["meta"], TVerb>;
     readonly platform: Platform;
     readonly serializedGlobals: Record<string, boolean>;
     readonly parent: Context | undefined;
@@ -27,14 +31,14 @@ export interface Context<TRoute extends Route = AnyRoute> {
     redirect(to: string | URL, status?: number): Response;
     back(fallback?: string | URL, status?: number): Response;
 }
-export type MultiRouteContext<TRoute extends Route, _Preserved extends TRoute = TRoute> = TRoute extends any ? Context<Simplify<SuperSets<TRoute, _Preserved, "params">>> : never;
+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> = Awaitable<OneOrMany<RouteHandler<TRoute>>>;
+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> = (context: MultiRouteContext<TRoute>, next: NextFunction) => Awaitable<RouteHandlerResult>;
-export interface Route<Params extends ParamsObject = ParamsObject, Meta = unknown, Path extends string = string> {
+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;
@@ -44,14 +48,14 @@ type DefineRoutes<T extends Record<string, {
 }>> = {
     [K in keyof T]: K extends string ? T[K] extends {
         meta: infer Meta;
-    } ? Route<PathParams<K>, Meta, K> : Route<PathParams<K>, unknown, K> : never;
+    } ? Route<PathParams<K>, Meta, K> : Route<PathParams<K>, any, K> : never;
 };
 type DefinePaths<T extends Record<string, {
     verb: unknown;
-}>, Verb extends "get" | "post"> = {
+}>, TVerb extends "get" | "post"> = {
     [K in keyof T]: K extends string ? T[K] extends {
         verb: infer V;
-    } ? V extends Verb ? K : never : never : never;
+    } ? V extends TVerb ? K : never : never : never;
 }[keyof T];
 export type DefineApp<T extends {
     routes: Record<string, {
@@ -86,20 +90,22 @@ type MatchSegments<A extends string, B extends string> = A extends `${infer P}/$
 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 {
 }
-type HasAppData = AppData extends {
-    routes: any;
-} ? 1 : 0;
-type AnyParams = 0 extends HasAppData ? ParamsObject : never;
-type AnyMeta = 0 extends HasAppData ? unknown : never;
 export type Routes = AppData extends {
     routes: infer T;
 } ? T : Record<string, Route>;
 export type AnyRoute = Routes[keyof Routes];
-export type AnyContext = MultiRouteContext<AnyRoute>;
-export type AnyHandler<Params extends AnyParams = AnyParams, Meta extends AnyMeta = AnyMeta> = 0 extends HasAppData ? HandlerLike<Route<Params, Meta>> : HandlerLike<AnyRoute>;
-export type HandlerTypeFn<TRoute extends Route = AnyRoute> = 0 extends HasAppData ? <Params extends ParamsObject = ParamsObject, Meta = unknown, T extends HandlerLike<Route<Params, Meta>> = HandlerLike<Route<Params, Meta>>>(handler: T) => T : <T extends HandlerLike<TRoute>>(handler: T) => T;
+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;

package/dist/vite/index.cjs

@@ -43,6 +43,7 @@ __export(vite_exports, {
   defaultConfigPlugin: () => defaultConfigPlugin,
   getApi: () => getApi,
   getAvailablePort: () => getAvailablePort,
+  getMetaDataForVerb: () => getMetaDataForVerb,
   getPackageData: () => getPackageData,
   isPortInUse: () => isPortInUse,
   loadEnv: () => loadEnv,
@@ -354,7 +355,10 @@ function renderRouteEntry(route, rootDir) {
   const imports = writer.branch("imports");
   const runtimeImports = [];
   if (handler) {
-    runtimeImports.push("normalize");
+    runtimeImports.push("normalizeHandler");
+  }
+  if (meta) {
+    runtimeImports.push("normalizeMeta");
   }
   if (handler || middleware.length) {
     runtimeImports.push("call");
@@ -386,7 +390,9 @@ function renderRouteEntry(route, rootDir) {
     for (const verb of handler.verbs) {
       const importName = verb.toUpperCase();
       names.push(importName);
-      writer.writeLines(`const ${verb}Handler = normalize(${importName});`);
+      writer.writeLines(
+        `const ${verb}Handler = normalizeHandler(${importName});`
+      );
     }
     imports.writeLines(
       `import { ${names.join(", ")} } from "${normalizedRelativePath(rootDir, handler.filePath)}";`
@@ -398,8 +404,18 @@ function renderRouteEntry(route, rootDir) {
     );
   }
   if (meta) {
+    const metaName = `meta${index}`;
+    const metaVerbsExports = verbs.map((verb) => {
+      var _a2;
+      const name = verb === "head" && !((_a2 = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a2.includes(verb)) ? "GET" : verb.toUpperCase();
+      return `${name}: ${verb}${index}_meta`;
+    }).join(", ");
+    writer.writeLines("");
     imports.writeLines(
-      `export { default as meta${index} } from "${normalizedRelativePath(rootDir, meta.filePath)}";`
+      `import ${metaName} from "${normalizedRelativePath(rootDir, meta.filePath)}";`
+    );
+    writer.writeLines(
+      `export const { ${metaVerbsExports} } = normalizeMeta(${metaName});`
     );
   }
   for (const verb of verbs) {
@@ -518,10 +534,16 @@ function renderRouter(routes, rootDir, runtimeInclude, options = {
   );
   for (const route of routes.list) {
     const verbs = getVerbs(route);
-    const names = verbs.map((verb) => `${verb}${route.index}`);
-    route.meta && names.push(`meta${route.index}`);
+    const routeImports = [];
+    for (const verb of verbs) {
+      const verbName = `${verb}${route.index}`;
+      routeImports.push(verbName);
+      if (route.meta) {
+        routeImports.push(`${verbName}_meta`);
+      }
+    }
     imports.writeLines(
-      `import { ${names.join(", ")} } from "${virtualFilePrefix}/${getRouteVirtualFileName(route)}";`
+      `import { ${routeImports.join(", ")} } from "${virtualFilePrefix}/${getRouteVirtualFileName(route)}";`
     );
   }
   for (const route of Object.values(routes.special)) {
@@ -813,14 +835,14 @@ function renderParams(params, pathIndex) {
 function renderMatch(verb, route, path7, pathIndex) {
   const handler = `${verb}${route.index}`;
   const params = path7.params ? renderParams(path7.params, pathIndex) : "{}";
-  const meta = route.meta ? `meta${route.index}` : "{}";
+  const meta = route.meta ? `${verb}${route.index}_meta` : "{}";
   return `{ handler: ${handler}, params: ${params}, meta: ${meta}, path: '${path7.path}' }`;
 }
 function renderMiddleware(middleware, rootDir) {
   const writer = createStringWriter();
   const imports = writer.branch("imports");
   imports.writeLines(
-    `import { normalize } from "${virtualFilePrefix}/runtime/internal";`
+    `import { normalizeHandler } from "${virtualFilePrefix}/runtime/internal";`
   );
   writer.writeLines("");
   for (const { id, filePath } of middleware) {
@@ -828,7 +850,9 @@ function renderMiddleware(middleware, rootDir) {
     imports.writeLines(
       `import ${importName} from "${normalizedRelativePath(rootDir, filePath)}";`
     );
-    writer.writeLines(`export const mware${id} = normalize(${importName});`);
+    writer.writeLines(
+      `export const mware${id} = normalizeHandler(${importName});`
+    );
   }
   imports.join();
   return writer.end();
@@ -987,7 +1011,12 @@ function writeModuleDeclaration(writer, name, routeType, moduleTypes) {
     export { NotHandled, NotMatched, GetPaths, PostPaths, GetablePath, GetableHref, PostablePath, PostableHref, Platform };
     export type Route = ${routeType};
     export type Context = Run.MultiRouteContext<Route>${isMarko ? " & Marko.Global" : ""};
-    export type Handler = Run.HandlerLike<Route>;
+    export type Handler = Run.HandlerLike<Route>;`);
+    for (const verb of httpVerbs) {
+      writer.write(`
+    export type ${verb.toUpperCase()} = Run.HandlerLike<Route, "${verb.toUpperCase()}">;`);
+    }
+    writer.write(`
     /** @deprecated use \`((context, next) => { ... }) satisfies MarkoRun.Handler\` instead */
     export const route: Run.HandlerTypeFn<Route>;
   }`);
@@ -1588,31 +1617,31 @@ function createFSWalker(dir) {
 }
 
 // src/vite/utils/ast.ts
-var t = __toESM(require("@babel/types"), 1);
+var import_compiler = require("@marko/compiler");
 function getExportIdentifiers(astProgramNode) {
   const result = [];
-  if (t.isProgram(astProgramNode)) {
+  if (import_compiler.types.isProgram(astProgramNode)) {
     for (const node of astProgramNode.body) {
-      if (t.isExportNamedDeclaration(node)) {
+      if (import_compiler.types.isExportNamedDeclaration(node)) {
         const { declaration, specifiers } = node;
         if (declaration) {
-          if (t.isFunctionDeclaration(declaration) && declaration.id) {
+          if (import_compiler.types.isFunctionDeclaration(declaration) && declaration.id) {
             result.push(declaration.id.name);
-          } else if (t.isVariableDeclaration(declaration)) {
+          } else if (import_compiler.types.isVariableDeclaration(declaration)) {
             for (const declarator of declaration.declarations) {
-              if (t.isIdentifier(declarator.id)) {
+              if (import_compiler.types.isIdentifier(declarator.id)) {
                 result.push(declarator.id.name);
               }
             }
           }
         } else if (specifiers) {
           for (const specifier of specifiers) {
-            if (t.isExportSpecifier(specifier) && t.isIdentifier(specifier.exported)) {
+            if (import_compiler.types.isExportSpecifier(specifier) && import_compiler.types.isIdentifier(specifier.exported)) {
               result.push(specifier.exported.name);
             }
           }
         }
-      } else if (t.isExportDefaultDeclaration(node)) {
+      } else if (import_compiler.types.isExportDefaultDeclaration(node)) {
         result.push("default");
       }
     }
@@ -2528,6 +2557,31 @@ var defaultConfigPlugin = {
   }
 };
 
+// src/vite/utils/meta-data.ts
+var verbKeys = new Set(httpVerbs.map((v) => v.toUpperCase()));
+function isObject(obj) {
+  return obj && typeof obj === "object" && !Array.isArray(obj);
+}
+function getMetaDataForVerb(data, verb) {
+  if (!httpVerbs.includes(verb.toLowerCase())) {
+    throw new Error(
+      `Invalid argument 'verb': expected one of ${[...verbKeys].join(", ")} but received ${verb}`
+    );
+  }
+  if (isObject(data)) {
+    return Object.keys(data).reduce(
+      (result, key) => {
+        if (!(key in result || verbKeys.has(key))) {
+          result[key] = data[key];
+        }
+        return result;
+      },
+      isObject(data[verb]) ? { ...data[verb] } : {}
+    );
+  }
+  return data;
+}
+
 // src/vite/utils/server.ts
 var import_child_process = __toESM(require("child_process"), 1);
 var import_cluster = __toESM(require("cluster"), 1);
@@ -2678,6 +2732,7 @@ function sleep(ms) {
   defaultConfigPlugin,
   getApi,
   getAvailablePort,
+  getMetaDataForVerb,
   getPackageData,
   isPortInUse,
   loadEnv,

package/dist/vite/index.d.ts

@@ -1,4 +1,4 @@
 export { default, defaultConfigPlugin, getApi, getPackageData } from "./plugin";
 export type { Adapter, AdapterConfig, BuiltRoutes, ExplorerData, ExternalRoutes, HttpVerb, Options, PackageData, PathInfo, RoutableFile, RoutableFileType, Route, RouteGenerationData, } from "./types";
-export type { SpawnedServer } from "./utils/server";
-export { getAvailablePort, isPortInUse, loadEnv, parseEnv, spawnServer, spawnServerWorker, } from "./utils/server";
+export { getMetaDataForVerb } from "./utils/meta-data";
+export { getAvailablePort, isPortInUse, loadEnv, parseEnv, type SpawnedServer, spawnServer, spawnServerWorker, } from "./utils/server";