@marko/run 0.9.5 → 0.9.7

package/dist/adapter/index.js

@@ -1,6 +1,6 @@
 // src/adapter/index.ts
 import fs5 from "fs";
-import inspector from "inspector";
+import inspector2 from "inspector";
 import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -20,9 +20,10 @@ import {
 
 // src/adapter/utils.ts
 import kleur from "kleur";
-import supporsColor from "supports-color";
+import supportsColor from "supports-color";
 function stripAnsi(string) {
   return string.replace(
+    /* cspell:disable-next-line */
     /([\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><])/g,
     ""
   );
@@ -43,10 +44,10 @@ function prepareError(err) {
   };
 }
 function logInfoBox(address, explorer) {
-  const color = !!supporsColor.stdout;
+  const color = !!supportsColor.stdout;
   let message = kleur.bold("Marko Run");
   if (true) {
-    message += ` v${"0.9.5"}`;
+    message += ` v${"0.9.7"}`;
   }
   message += "\n\n";
   message += kleur.dim("Server listening at");
@@ -232,7 +233,7 @@ var httpVerbOrder = httpVerbs.reduce(
 import path3 from "path";
 var markoFiles = `(${RoutableFileTypes.Layout}|${RoutableFileTypes.Page}|${RoutableFileTypes.NotFound}|${RoutableFileTypes.Error})\\.(?:.*\\.)?(marko)`;
 var nonMarkoFiles = `(${RoutableFileTypes.Middleware}|${RoutableFileTypes.Handler}|${RoutableFileTypes.Meta})\\.(?:.*\\.)?(.+)`;
-var routeableFileRegex = new RegExp(
+var RoutableFileRegex = new RegExp(
   `[+](?:${markoFiles}|${nonMarkoFiles})$`,
   "i"
 );
@@ -302,11 +303,11 @@ async function resolveAdapter(root, options, log) {
   }
   const pkg = await getPackageData(root);
   if (pkg) {
-    let dependecies = pkg.dependencies ? Object.keys(pkg.dependencies) : [];
+    let dependencies = pkg.dependencies ? Object.keys(pkg.dependencies) : [];
     if (pkg.devDependencies) {
-      dependecies = dependecies.concat(Object.keys(pkg.devDependencies));
+      dependencies = dependencies.concat(Object.keys(pkg.devDependencies));
     }
-    for (const name of dependecies) {
+    for (const name of dependencies) {
       if (name.startsWith("@marko/run-adapter") || name.indexOf("marko-run-adapter") !== -1) {
         try {
           const module2 = await import(
@@ -314,7 +315,7 @@ async function resolveAdapter(root, options, log) {
             name
           );
           log && debug(
-            `Using adapter ${name} listed in your package.json dependecies`
+            `Using adapter ${name} listed in your package.json dependencies`
           );
           return module2.default();
         } catch (err) {
@@ -459,7 +460,7 @@ async function waitForServer(port, wait = 0) {
       await sleep(100);
     } else {
       throw new Error(
-        `Timeout while wating for server to start on port "${port}".`
+        `Timeout while waiting for server to start on port "${port}".`
       );
     }
   }
@@ -532,9 +533,9 @@ import {
 // src/adapter/logger.ts
 import DraftLog from "draftlog";
 import format2 from "human-format";
-import inpspector from "inspector";
+import inspector from "inspector";
 import kleur3 from "kleur";
-if (!inpspector.url()) {
+if (!inspector.url()) {
   DraftLog.into(console);
   DraftLog.defaults.canReWrite = false;
 }
@@ -1024,8 +1025,8 @@ function adapter() {
             port,
             envFile
           );
-          nextWorker.on("message", (messsage) => {
-            if (messsage === "restart") {
+          nextWorker.on("message", (message) => {
+            if (message === "restart") {
               start();
             }
           }).send({ type: "start", entry, config: config2 });
@@ -1055,7 +1056,7 @@ function adapter() {
       envFile && await loadEnv(envFile);
       const inspect = getInspectOptions(options.args);
       if (inspect) {
-        inspector.open(inspect.port, inspect.host, inspect.wait);
+        inspector2.open(inspect.port, inspect.host, inspect.wait);
       }
       const listenerPromise = new Promise((resolve) => {
         const listener2 = devServer.middlewares.listen(port, () => {

package/dist/cli/index.mjs

@@ -21,7 +21,7 @@ import { build as viteBuild, resolveConfig } from "vite";
 
 // src/adapter/index.ts
 import fs5 from "fs";
-import inspector from "inspector";
+import inspector2 from "inspector";
 import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -41,9 +41,10 @@ import {
 
 // src/adapter/utils.ts
 import kleur from "kleur";
-import supporsColor from "supports-color";
+import supportsColor from "supports-color";
 function stripAnsi(string) {
   return string.replace(
+    /* cspell:disable-next-line */
     /([\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><])/g,
     ""
   );
@@ -326,7 +327,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 +362,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 +376,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 +506,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 +807,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 +822,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 +983,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>;
   }`);
@@ -1324,12 +1353,12 @@ var VDir = _VDir;
 // src/vite/routes/builder.ts
 var markoFiles = `(${RoutableFileTypes.Layout}|${RoutableFileTypes.Page}|${RoutableFileTypes.NotFound}|${RoutableFileTypes.Error})\\.(?:.*\\.)?(marko)`;
 var nonMarkoFiles = `(${RoutableFileTypes.Middleware}|${RoutableFileTypes.Handler}|${RoutableFileTypes.Meta})\\.(?:.*\\.)?(.+)`;
-var routeableFileRegex = new RegExp(
+var RoutableFileRegex = new RegExp(
   `[+](?:${markoFiles}|${nonMarkoFiles})$`,
   "i"
 );
 function matchRoutableFile(filename) {
-  const match = filename.match(routeableFileRegex);
+  const match = filename.match(RoutableFileRegex);
   return match && (match[1] || match[3]).toLowerCase();
 }
 async function buildRoutes(sources, outDir) {
@@ -1371,7 +1400,7 @@ async function buildRoutes(sources, outDir) {
     },
     onFile(file) {
       const { name } = file;
-      const match = name.match(routeableFileRegex);
+      const match = name.match(RoutableFileRegex);
       if (!match) {
         return;
       }
@@ -2146,9 +2175,15 @@ function markoRun(opts = {}) {
           }
           rollupOutputOptions = mergeOutputOptions(
             {
-              assetFileNames: `${assetsDir}/[name]-[hash].[ext]`,
+              assetFileNames(info) {
+                var _a2;
+                const name = ((_a2 = info.names) == null ? void 0 : _a2[0]) && cleanFileName(info.names[0]);
+                return name ? `${assetsDir}/${name}-[hash].[ext]` : `${assetsDir}/_[hash].[ext]`;
+              },
               entryFileNames(info) {
-                return `${assetsDir}/${getEntryFileName(info.name) || "[name]"}-[hash].js`;
+                const raw = getEntryFileName(info.name) || info.name;
+                const name = raw && cleanFileName(raw);
+                return name ? `${assetsDir}/${name}-[hash].js` : `${assetsDir}/_[hash].js`;
               },
               chunkFileNames: isSSRBuild ? `_[hash].js` : `${assetsDir}/_[hash].js`
             },
@@ -2430,11 +2465,11 @@ async function resolveAdapter(root, options, log) {
   }
   const pkg = await getPackageData(root);
   if (pkg) {
-    let dependecies = pkg.dependencies ? Object.keys(pkg.dependencies) : [];
+    let dependencies = pkg.dependencies ? Object.keys(pkg.dependencies) : [];
     if (pkg.devDependencies) {
-      dependecies = dependecies.concat(Object.keys(pkg.devDependencies));
+      dependencies = dependencies.concat(Object.keys(pkg.devDependencies));
     }
-    for (const name of dependecies) {
+    for (const name of dependencies) {
       if (name.startsWith("@marko/run-adapter") || name.indexOf("marko-run-adapter") !== -1) {
         try {
           const module2 = await import(
@@ -2442,7 +2477,7 @@ async function resolveAdapter(root, options, log) {
             name
           );
           log && debug(
-            `Using adapter ${name} listed in your package.json dependecies`
+            `Using adapter ${name} listed in your package.json dependencies`
           );
           return module2.default();
         } catch (err) {
@@ -2464,6 +2499,9 @@ function getEntryFileName(file) {
   const match = file && markoEntryFileRegex.exec(file);
   return match ? match[1] : void 0;
 }
+function cleanFileName(name) {
+  return name.replace(/\.[^/.]+$/, "").replace(/[^a-zA-Z0-9._[\]-]+/g, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "");
+}
 function getPlugin(config2) {
   return config2.plugins.find(
     (plugin) => plugin.name === `${PLUGIN_NAME_PREFIX}:pre`
@@ -2538,9 +2576,9 @@ import {
 // src/adapter/logger.ts
 import DraftLog from "draftlog";
 import format2 from "human-format";
-import inpspector from "inspector";
+import inspector from "inspector";
 import kleur3 from "kleur";
-if (!inpspector.url()) {
+if (!inspector.url()) {
   DraftLog.into(console);
   DraftLog.defaults.canReWrite = false;
 }

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;