@marko/run 0.0.1-beta1 → 0.0.1-beta10

package/dist/vite/index.cjs

@@ -29,6 +29,8 @@ __export(vite_exports, {
   default: () => markoServe,
   getAvailablePort: () => getAvailablePort,
   isPortInUse: () => isPortInUse,
+  loadEnv: () => loadEnv,
+  parseEnv: () => parseEnv,
   spawnServer: () => spawnServer
 });
 module.exports = __toCommonJS(vite_exports);
@@ -36,13 +38,16 @@ module.exports = __toCommonJS(vite_exports);
 // src/vite/plugin.ts
 var import_path2 = __toESM(require("path"), 1);
 var import_crypto = __toESM(require("crypto"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
+var import_glob = __toESM(require("glob"), 1);
 var import_vite = require("vite");
 var import_vite2 = __toESM(require("@marko/vite"), 1);
 
 // src/vite/constants.ts
-var markoServeFilePrefix = "__marko-serve__";
-var virtualFilePrefix = "virtual:marko-serve";
+var markoRunFilePrefix = "__marko-run__";
+var virtualFilePrefix = "virtual:marko-run";
 var virtualRoutesPrefix = `${virtualFilePrefix}/routes`;
+var virtualRuntimePrefix = `${virtualFilePrefix}/internal`;
 var httpVerbs = ["get", "post", "put", "delete"];
 var serverEntryQuery = "?marko-server-entry";
 var browserEntryQuery = "?marko-browser-entry";
@@ -82,15 +87,20 @@ function isSpecialType(type) {
   return type === RoutableFileTypes.NotFound || type === RoutableFileTypes.Error;
 }
 async function buildRoutes(walk, basePath) {
-  const dirStack = basePath ? basePath.split("/") : [];
+  if (basePath) {
+    basePath = basePath.replace(/^\/+|\/+$/g, "");
+  }
+  const dirStack = [];
   const pathStack = [];
   const paramStack = [];
   const layoutsStack = [];
   const middlewareStack = [];
   const routes = /* @__PURE__ */ new Map();
   const special = {};
+  const middleware = /* @__PURE__ */ new Set();
   let isRoot = true;
-  let nextId = 1;
+  let nextFileId = 1;
+  let nextRouteIndex = 1;
   let current;
   let children = [];
   await walk({
@@ -118,10 +128,13 @@ async function buildRoutes(walk, basePath) {
       if (!entries) {
         current.files.set(type, entries = []);
       }
+      const relativePath = current.originalPath ? `${current.originalPath}/${entry.name}` : entry.name;
       entries.push({
+        id: String(nextFileId++),
         type,
         filePath: entry.path,
-        importPath: `${current.originalPath}/${entry.name}`,
+        relativePath,
+        importPath: `${basePath}/${relativePath}`,
         name: entry.name,
         verbs: type === RoutableFileTypes.Page ? ["get"] : void 0
       });
@@ -132,20 +145,31 @@ async function buildRoutes(walk, basePath) {
         return;
       }
       const { path: path3, files } = current;
-      const middleware = (_a = files.get(RoutableFileTypes.Middleware)) == null ? void 0 : _a[0];
-      const layout = (_b = files.get(RoutableFileTypes.Layout)) == null ? void 0 : _b[0];
+      const localMiddleware = (_a = files.get(RoutableFileTypes.Middleware)) == null ? void 0 : _a[0];
+      const localLayout = (_b = files.get(RoutableFileTypes.Layout)) == null ? void 0 : _b[0];
       const handler = (_c = files.get(RoutableFileTypes.Handler)) == null ? void 0 : _c[0];
       const page = (_d = files.get(RoutableFileTypes.Page)) == null ? void 0 : _d[0];
       const middlewareStackLength = middlewareStack.length;
       const layoutsStackLength = layoutsStack.length;
-      middleware && middlewareStack.push(middleware);
-      layout && layoutsStack.push(layout);
+      if (localMiddleware) {
+        middlewareStack.push(localMiddleware);
+      }
+      if (localLayout) {
+        layoutsStack.push(localLayout);
+      }
       if (handler || page) {
         const key = path3.replace(/(\$\$?)[^\/]*/g, "$1").replace(/^\/+/, "").replace(/[^a-z0-9_$\/]+/gi, "").replace(/\//g, "__") || "index";
         if (routes.has(key)) {
-          console.warn(`Duplicate route for path ${path3} -- ignoring`, current);
+          const existing = routes.get(key);
+          const existingFiles = [existing.handler, existing.page].filter(Boolean).map((f) => f.filePath);
+          const currentFiles = [handler, page].filter(Boolean).map((f) => f.filePath);
+          throw new Error(`Duplicate routes for path ${path3} were defined. A route established by:
+  ${existingFiles}
+    collides with
+  ${currentFiles.join(" and ")}
+  `);
         } else {
-          const index = nextId++;
+          const index = nextRouteIndex++;
           routes.set(key, {
             index,
             key,
@@ -158,6 +182,9 @@ async function buildRoutes(walk, basePath) {
             handler,
             score: scorePath(path3, index)
           });
+          for (const mw of middlewareStack) {
+            middleware.add(mw);
+          }
         }
       }
       if (isRoot) {
@@ -188,14 +215,16 @@ async function buildRoutes(walk, basePath) {
       const prevChildren = children;
       const prevCurrent = current;
       const prevIsRoot = isRoot;
-      if (name.charCodeAt(0) === 95 || name.charCodeAt(0) === 40 && name.charCodeAt(name.length - 1) === 41 || name.toLowerCase() === "index") {
+      if (name.charCodeAt(0) === 95) {
       } else {
         if (name.charCodeAt(0) === 36) {
           if (name.charCodeAt(1) === 36) {
-            paramStack.push({
-              name: name.slice(2) || "*",
-              index: -1
-            });
+            if (name.length > 2) {
+              paramStack.push({
+                name: name.slice(2),
+                index: -1
+              });
+            }
           } else if (name.length > 1) {
             paramStack.push({
               name: name.slice(1),
@@ -223,7 +252,8 @@ async function buildRoutes(walk, basePath) {
   });
   return {
     list: [...routes.values()],
-    special
+    special,
+    middleware: [...middleware]
   };
 }
 
@@ -273,6 +303,17 @@ function createWriter(sink, options) {
   let firstOpenIndex = 0;
   const branches = [];
   const openWriters = /* @__PURE__ */ new Map();
+  function write(data) {
+    if (!writer.__isActive) {
+      throw new Error("Cannot write to branch that has been joined");
+    }
+    if (openWriters.size) {
+      buffer += data;
+    } else {
+      sink(data);
+    }
+    return writer;
+  }
   const writer = {
     __isActive: true,
     get indent() {
@@ -289,24 +330,16 @@ function createWriter(sink, options) {
         }
       }
     },
-    write(data) {
-      if (!writer.__isActive) {
-        throw new Error("Cannot write to branch that has been joined");
+    write(data, indent = false) {
+      if (indent && indentString) {
+        write(indentString);
       }
-      if (openWriters.size) {
-        buffer += data;
-      } else {
-        sink(data);
-      }
-      return writer;
+      return write(data);
     },
     writeLines(...lines) {
       for (const line of lines) {
         if (line) {
-          if (indentString) {
-            writer.write(indentString);
-          }
-          writer.write(line);
+          writer.write(line, true);
         }
         writer.write("\n");
       }
@@ -453,16 +486,13 @@ function hasVerb(route, verb) {
 }
 
 // src/vite/codegen/index.ts
-var DefaultCodegenOptions = {
-  trailingSlashes: "RedirectWithout"
-};
 function renderRouteTemplate(route) {
   if (!route.page) {
     throw new Error(`Route ${route.key} has no page to render`);
   }
   const writer = createStringWriter();
   writer.writeLines(
-    `// ${virtualFilePrefix}/${markoServeFilePrefix}route__${route.key}.marko`
+    `// ${virtualFilePrefix}/${markoRunFilePrefix}route__${route.key}.marko`
   );
   writer.branch("imports");
   writer.writeLines("");
@@ -494,47 +524,76 @@ function renderRouteEntry(route) {
   }
   const writer = createStringWriter();
   writer.writeLines(
-    `// ${virtualFilePrefix}/${markoServeFilePrefix}route__${key}.js`
+    `// ${virtualFilePrefix}/${markoRunFilePrefix}route__${key}.js`
   );
   const imports = writer.branch("imports");
-  let i = 1;
-  for (const { importPath } of middleware) {
-    imports.writeLines(`import middleware$${i} from './${importPath}';`);
-    i++;
+  const runtimeImports = [];
+  if (handler) {
+    runtimeImports.push("normalize");
   }
-  if ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.length) {
-    const names = handler.verbs.map(
-      (verb) => `${verb === "delete" ? "del" : verb} as handler$${verb}`
+  if (handler || middleware.length) {
+    runtimeImports.push("call");
+  }
+  if (!page || verbs.length > 1) {
+    runtimeImports.push("noContent");
+  }
+  if (page) {
+    runtimeImports.push("pageResponse");
+  }
+  if (runtimeImports.length) {
+    imports.writeLines(
+      `import { ${runtimeImports.join(", ")} } from '${virtualRuntimePrefix}';`
     );
+  }
+  if (middleware.length) {
+    const names = middleware.map((m) => `mware${m.id}`);
+    imports.writeLines(
+      `import { ${names.join(
+        ", "
+      )} } from '${virtualFilePrefix}/${markoRunFilePrefix}middleware.js';`
+    );
+  }
+  if ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.length) {
+    writer.writeLines("");
+    const names = [];
+    for (const verb of handler.verbs) {
+      const importName = verb.toUpperCase();
+      names.push(importName);
+      writer.writeLines(`const ${verb}Handler = normalize(${importName});`);
+    }
     imports.writeLines(
       `import { ${names.join(", ")} } from './${handler.importPath}';`
     );
   }
   if (page) {
     imports.writeLines(
-      `import page from '${virtualFilePrefix}/${markoServeFilePrefix}route__${key}.marko${serverEntryQuery}';`
+      `import page from '${virtualFilePrefix}/${markoRunFilePrefix}route__${key}.marko${serverEntryQuery}';`
     );
   }
   if (meta) {
     imports.writeLines(
-      `export { default as meta$${index} } from './${meta.importPath}';`
+      `export { default as meta${index} } from './${meta.importPath}';`
     );
   }
-  if (!page || verbs.length > 1) {
-    writer.writeLines("").writeBlockStart(`function create204Response() {`).writeBlockStart(`return new Response(null, {`).writeLines(`status: 204`).writeBlockEnd(`})`).writeBlockEnd(`}`);
-  }
   for (const verb of verbs) {
     writeRouteEntryHandler(writer, route, verb);
   }
   return writer.end();
 }
-function writePageResponseContinuation(writer) {
-  writer.writeBlock(
-    `return new Response(page.stream(ctx), {`,
-    ["status: 200,", 'headers: { "content-type": "text/html;charset=UTF-8" }'],
-    "});"
+function writePageResponse(writer, wrapFn) {
+  writer.writeLines(
+    `${wrapFn ? `const ${wrapFn} = () =>` : `return`} pageResponse(page, buildInput());`
   );
 }
+function writeMiddleware(writer, middleware, next, wrapFn) {
+  if (wrapFn) {
+    writer.writeLines(
+      `const ${wrapFn} = () => call(${middleware}, ${next}, context);`
+    );
+  } else {
+    writer.writeLines(`return call(${middleware}, ${next}, context);`);
+  }
+}
 function writeRouteEntryHandler(writer, route, verb) {
   var _a;
   const { key, index, page, handler, middleware } = route;
@@ -542,47 +601,43 @@ function writeRouteEntryHandler(writer, route, verb) {
   let nextName;
   let currentName;
   let hasBody = false;
-  writer.writeLines("").writeBlockStart(`export async function ${verb}$${index}(ctx) {`);
+  writer.writeLines("");
+  if (page) {
+    writer.writeBlockStart(
+      `export async function ${verb}${index}(context, buildInput) {`
+    );
+  } else {
+    writer.writeBlockStart(`export async function ${verb}${index}(context) {`);
+  }
   const continuations = writer.branch("cont");
   if (page && verb === "get") {
-    currentName = "createPageResponse";
+    currentName = "__page";
     if ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.includes(verb)) {
-      continuations.writeBlockStart(`async function ${currentName}() {`);
-      writePageResponseContinuation(continuations);
-      continuations.writeBlockEnd("}");
+      const name = `${verb}Handler`;
+      writePageResponse(continuations, currentName);
       if (len) {
         nextName = currentName;
-        currentName = `__handler$${verb}`;
-        continuations.writeBlock(
-          `async function ${currentName}() {`,
-          [`return await handler$${verb}(ctx, ${nextName});`],
-          "}"
-        );
+        currentName = `__${name}`;
+        writeMiddleware(continuations, name, nextName, currentName);
       } else {
-        writer.writeLines(`return await handler$${verb}(ctx, ${currentName})`);
+        writeMiddleware(writer, name, currentName);
         hasBody = true;
       }
     } else if (len) {
-      continuations.writeBlockStart(`async function ${currentName}() {`);
-      writePageResponseContinuation(continuations);
-      continuations.writeBlockEnd("}");
+      writePageResponse(continuations, currentName);
       nextName = currentName;
     } else {
-      writePageResponseContinuation(continuations);
+      writePageResponse(continuations);
       hasBody = true;
     }
   } else if (handler) {
-    currentName = `__handler$${verb}`;
+    const name = `${verb}Handler`;
+    currentName = `__${name}`;
+    nextName = "noContent";
     if (len) {
-      continuations.writeBlock(
-        `async function ${currentName}() {`,
-        [`return await handler$${verb}(ctx, create204Response);`],
-        "}"
-      );
+      writeMiddleware(continuations, name, nextName, currentName);
     } else {
-      writer.writeLines(
-        `return await handler$${verb}(ctx, create204Response);`
-      );
+      writeMiddleware(writer, name, nextName);
       hasBody = true;
     }
   } else {
@@ -590,40 +645,48 @@ function writeRouteEntryHandler(writer, route, verb) {
   }
   if (!hasBody) {
     let i = len;
-    while (--i) {
+    while (i--) {
+      const { id } = middleware[i];
+      const name = `mware${id}`;
       nextName = currentName;
-      currentName = `__middleware${i + 1}`;
-      continuations.writeLines("").writeBlock(
-        `async function ${currentName}() {`,
-        [`return await middleware$${i + 1}(ctx, ${nextName});`],
-        "}"
-      );
+      currentName = i ? `__${name}` : "";
+      writeMiddleware(continuations, name, nextName, currentName);
     }
-    writer.writeLines(`return await middleware$1(ctx, ${currentName});`);
   }
   continuations.join();
   writer.writeBlockEnd("}");
 }
-function renderRouter(routes, options = DefaultCodegenOptions) {
+function renderRouter(routes, options = {
+  trailingSlashes: "RedirectWithout"
+}) {
   const writer = createStringWriter();
   writer.writeLines(`// @marko/run/router`);
   const imports = writer.branch("imports");
+  imports.writeLines(
+    `import { NotHandled, NotMatched, createInput } from 'virtual:marko-run/internal';`
+  );
   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 names = verbs.map((verb) => `${verb}${route.index}`);
+    route.meta && names.push(`meta${route.index}`);
     imports.writeLines(
       `import { ${names.join(
         ", "
-      )} } from '${virtualFilePrefix}/${markoServeFilePrefix}route__${route.key}.js';`
+      )} } from '${virtualFilePrefix}/${markoRunFilePrefix}route__${route.key}.js';`
     );
   }
   for (const { key } of Object.values(routes.special)) {
     imports.writeLines(
-      `import page$${key} from '${virtualFilePrefix}/${markoServeFilePrefix}special__${key}.marko${serverEntryQuery}';`
+      `import page${key} from '${virtualFilePrefix}/${markoRunFilePrefix}special__${key}.marko${serverEntryQuery}';`
     );
   }
-  writer.writeLines("").writeBlockStart(`function matchRoute(method, pathname) {`).writeBlockStart(`switch (method.toLowerCase()) {`);
+  writer.writeLines(``).writeBlockStart(`export function match(method, pathname) {`).writeLines(
+    `if (!pathname) {
+    pathname = '/';
+  } else if (pathname.charAt(0) !== '/') {
+    pathname = '/' + pathname;
+  }`
+  ).writeBlockStart(`switch (method.toLowerCase()) {`);
   for (const verb of httpVerbs) {
     const filteredRoutes = routes.list.filter((route) => hasVerb(route, verb));
     if (filteredRoutes.length) {
@@ -633,235 +696,477 @@ function renderRouter(routes, options = DefaultCodegenOptions) {
       writer.writeBlockEnd("}");
     }
   }
-  writer.writeBlockEnd("}").writeBlockEnd("}");
-  writer.writeLines("").writeBlockStart(`async function invokeRoute(route, url, request) {`);
-  const errorRoute = routes.special[RoutableFileTypes.Error];
-  if (errorRoute) {
-    writer.writeBlockStart(`try {`);
-  }
-  writer.writeBlock(
-    `if (route) {`,
-    [
-      `const [handler, params = {}, meta] = route;`,
-      `const response = await handler({ request, url, params, meta });`,
-      `if (response) return response;`
-    ],
-    `}`
-  );
-  const notFoundRoute = routes.special[RoutableFileTypes.NotFound];
-  if (notFoundRoute) {
-    writer.writeBlockStart(
-      `if (request.headers.get('Accept')?.includes('text/html')) {`
-    ).writeBlock(
-      `return new Response(page$404.stream({ request, url, params: {} }), {`,
-      [
-        `status: 404,`,
-        `headers: { "content-type": "text/html;charset=UTF-8" },`
-      ],
-      `});`
-    ).writeBlockEnd("}");
+  writer.writeBlockEnd("}").writeLines("return null;").writeBlockEnd("}");
+  writer.write(`
+export async function invoke(route, request, platform, url = new URL(request.url)) {
+  const context = {
+    url,
+    request,
+    platform
+  };
+  const buildInput = createInput(context);
+	try {
+		if (route) {
+			context.params = route.params;
+			context.meta = route.meta;
+      try {
+				const response = await route.handler(context, buildInput);
+				if (response) return response;
+			} catch (error) {
+				if (error === NotHandled) {
+					return;
+				} else if (error !== NotMatched) {
+					throw error;
+				}
+			}
+`).indent = 2;
+  if (routes.special[RoutableFileTypes.NotFound]) {
+    writer.write(
+      `    } else {
+      context.params = {};
+      context.meta = {};
+    }
+    if (context.request.headers.get('Accept')?.includes('text/html')) {
+      return new Response(page404.stream(buildInput()), {
+        status: 404,
+        headers: { "content-type": "text/html;charset=UTF-8" },
+      });
+    }
+`
+    );
+  } else {
+    writer.writeBlockEnd("}");
   }
-  writer.writeLines(`return null;`);
-  if (errorRoute) {
-    writer.indent--;
-    writer.writeBlockStart(`} catch (err) {`).writeBlockStart(
-      `if (request.headers.get('Accept')?.includes('text/html')) {`
+  writer.indent--;
+  writer.writeBlockStart(`} catch (error) {`);
+  if (routes.special[RoutableFileTypes.Error]) {
+    writer.writeBlockStart(
+      `if (context.request.headers.get('Accept')?.includes('text/html')) {`
     ).writeBlock(
-      `return new Response(page$500.stream({ request, url, params: {}, error: err }), {`,
+      `return new Response(page500.stream(buildInput({ error })), {`,
       [
         `status: 500,`,
         `headers: { "content-type": "text/html;charset=UTF-8" },`
       ],
       `});`
-    ).writeBlockEnd("}").writeLines(`throw err;`).writeBlockEnd("}");
-  }
-  writer.writeBlockEnd("}");
-  writer.write(`
-export function getMatchedRoute(method, url) {
-  const route = matchRoute(method, url.pathname);
-  if (route) {
-    const [handler, params = {}, meta] = route;
-    return {
-      handler,
-      params,
-      meta,
-      async invoke(request) {
-        return await invokeRoute(route, url, request);
-      }
-    }
+    ).writeBlockEnd("}");
   }
-  return null;
-}
-
-export async function handler(context) {
-	const response = await router(context.request);
-	//if (response.body) {
-	//	context.waitUntil?.(once(Readable.from(response.body), "end"));
-	//}
-	return response;
-}
-
-export async function router(request) {
+  writer.writeLines(`throw error;`).writeBlockEnd("}").writeBlockEnd("}").write(`
+export async function fetch(request, platform) {
   try {
     const url = new URL(request.url);
-    let { pathname } = url;
-
-    if (pathname !== '/') {
-      if (pathname.endsWith('/')) {
-        pathname = pathname.replace(/\\/+$/, '');
-`);
+    let { pathname } = url;`);
   switch (options.trailingSlashes) {
     case "RedirectWithout":
       writer.write(`
-        url.pathname = pathname;
-        return Response.redirect(url.href);
-`);
+    if (pathname !== '/' && pathname.endsWith('/')) {
+      url.pathname = pathname.slice(0, -1);
+      return Response.redirect(url);
+    }`);
       break;
     case "RedirectWith":
       writer.write(`
-      } else {
-        url.pathname = pathname + '/';
-        return Response.redirect(url.href);
-`);
+    if (pathname !== '/' && !pathname.endsWith('/')) {
+      url.pathname = pathname + '/';
+      return Response.redirect(url);
+    }`);
       break;
     case "RewriteWithout":
       writer.write(`
-        url.pathname = pathname;
-`);
+    if (pathname !== '/' && pathname.endsWith('/')) {
+      url.pathname = pathname = pathname.slice(0, -1);
+    }`);
       break;
     case "RewriteWith":
       writer.write(`
-      } else {
-        url.pathname = pathname + '/';
-`);
+    if (pathname !== '/' && !pathname.endsWith('/')) {
+      url.pathname = pathname = pathname + '/';
+    }`);
       break;
   }
-  writer.write(`
-      }
-    }
-    const route = matchRoute(request.method, pathname);
-    return await invokeRoute(route, url, request) || new Response(null, {
-      statusText: \`Not Found (No route matched \${pathname})\`,
-      status: 404
-    });
-  } catch (err) {
-    const message = import.meta.env.DEV
-      ? \`Internal Server Error (\${err.message})\`
-      : "Internal Server Error";
+  writer.write(`   
 
-    return new Response(
-      JSON.stringify({
-        error: {
-          message,
-          stack: import.meta.env.DEV
-            ? \`This will only be seen in development mode\\n\\n\${err.stack}\`
-            : ""
-        }
-      }),
-      {
-        statusText: message,
-        status: 500,
-      }
-    );
+    const route = match(request.method, pathname);
+    return await invoke(route, request, platform, url);
+  } catch (error) {
+    const body = import.meta.env.DEV
+      ? error.stack || error.message || "Internal Server Error"
+      : null;
+    return new Response(body, {
+      status: 500
+    });
   }
 }`);
   return writer.end();
 }
-function writeRouterVerb(writer, trie, verb, level = 0, pathIndex = 0, useSwitch) {
-  const { key, route: value, static: children, dynamic, catchAll } = trie;
-  pathIndex += key.length;
-  if (level <= 0) {
-    level = 0;
-    if (value) {
+function writeRouterVerb(writer, trie, verb, level = 0, offset = 1) {
+  const { route, dynamic, catchAll } = trie;
+  let closeCount = 0;
+  if (level === 0) {
+    writer.writeLines(`const len = pathname.length;`);
+    if (route) {
       writer.writeLines(
-        `if (pathname === '/') return ${renderMatch(verb, value)}; // ${value.path}`
-      );
-    }
-    if (children || dynamic) {
-      writer.writeLines(
-        `const segments = pathname.split('/');`,
-        `const len = segments.length;`
-      );
-    }
-  } else {
-    if (!key) {
-      writer.writeBlockStart(`if (segments[${level}]) {`);
-    } else if (useSwitch) {
-      writer.writeBlockStart(`case '${key}':`);
-    } else {
-      writer.writeBlockStart(
-        `if (segments[${level}]?.toLowerCase() === '${key}') {`
-      );
-    }
-    if (value) {
-      writer.writeLines(
-        `if (len === ${level + 1}) return ${renderMatch(verb, value)}; // ${value.path}`
+        `if (len === 1) return ${renderMatch(verb, route)}; // ${route.path}`
       );
+    } else if (trie.static || dynamic) {
+      writer.writeBlockStart(`if (len > 1) {`);
+      closeCount++;
     }
   }
-  if (children || dynamic) {
-    if (children) {
-      if (children.size > 1) {
-        writer.writeBlockStart(
-          `switch(segments[${level + 1}]?.toLowerCase()) {`
-        );
-        for (const child of children.values()) {
-          writeRouterVerb(writer, child, verb, level + 1, pathIndex, true);
+  if (trie.static || dynamic) {
+    const next = level + 1;
+    const index = `i${next}`;
+    let terminal;
+    let children;
+    writer.writeLines(`const ${index} = pathname.indexOf('/', ${offset}) + 1;`);
+    if (trie.static) {
+      for (const child of trie.static.values()) {
+        if (child.route) {
+          (terminal ?? (terminal = [])).push(child);
         }
-        writer.writeBlockEnd("}");
-      } else {
-        for (const child of children.values()) {
-          writeRouterVerb(writer, child, verb, level + 1, pathIndex);
+        if (child.static || child.dynamic || child.catchAll) {
+          (children ?? (children = [])).push(child);
         }
       }
     }
-    if (dynamic) {
-      writeRouterVerb(writer, dynamic, verb, level + 1, pathIndex);
+    if (terminal || (dynamic == null ? void 0 : dynamic.route)) {
+      closeCount++;
+      writer.writeBlockStart(`if (!${index} || ${index} === len) {`);
+      let value = `pathname.slice(${offset}, ${index} ? -1 : len)`;
+      if (dynamic == null ? void 0 : dynamic.route) {
+        const segment = `s${next}`;
+        writer.writeLines(`const ${segment} = ${value};`);
+        value = segment;
+      }
+      if (terminal) {
+        const useSwitch = terminal.length > 1;
+        if (useSwitch) {
+          writer.writeBlockStart(`switch (${value}.toLowerCase()) {`);
+        }
+        for (const { key, route: route2 } of terminal) {
+          if (useSwitch) {
+            writer.write(`case '${key}': `, true);
+          } else {
+            writer.write(`if (${value}.toLowerCase() === '${key}') `, true);
+          }
+          writer.write(
+            `return ${renderMatch(verb, route2)}; // ${route2.path}
+`
+          );
+        }
+        if (useSwitch) {
+          writer.writeBlockEnd("}");
+        }
+      }
+      if (dynamic == null ? void 0 : dynamic.route) {
+        writer.writeLines(
+          `if (${value}) return ${renderMatch(verb, dynamic.route)}; // ${dynamic.route.path}`
+        );
+      }
+    }
+    if (children || (dynamic == null ? void 0 : dynamic.static) || (dynamic == null ? void 0 : dynamic.dynamic) || (dynamic == null ? void 0 : dynamic.catchAll)) {
+      if (terminal || (dynamic == null ? void 0 : dynamic.route)) {
+        writer.writeBlockEnd("} else {").indent++;
+      } else {
+        writer.writeBlockStart(`if (${index} && ${index} !== len) {`);
+        closeCount++;
+      }
+      let value = `pathname.slice(${offset}, ${index} - 1)`;
+      if ((dynamic == null ? void 0 : dynamic.static) || (dynamic == null ? void 0 : dynamic.dynamic)) {
+        const segment = `s${next}`;
+        writer.writeLines(`const ${segment} = ${value};`);
+        value = segment;
+      }
+      if (children) {
+        const useSwitch = children.length > 1;
+        if (useSwitch) {
+          writer.writeBlockStart(`switch (${value}.toLowerCase()) {`);
+        }
+        for (const child of children) {
+          if (useSwitch) {
+            writer.writeBlockStart(`case '${child.key}': {`);
+          } else {
+            writer.writeBlockStart(
+              `if (${value}.toLowerCase() === '${child.key}') {`
+            );
+          }
+          const nextOffset = typeof offset === "string" ? index : offset + child.key.length + 1;
+          writeRouterVerb(writer, child, verb, next, nextOffset);
+          writer.writeBlockEnd("}");
+        }
+        if (useSwitch) {
+          writer.writeBlockEnd("}");
+        }
+      }
+      if ((dynamic == null ? void 0 : dynamic.static) || (dynamic == null ? void 0 : dynamic.dynamic) || (dynamic == null ? void 0 : dynamic.catchAll)) {
+        writer.writeBlockStart(`if (${value}) {`);
+        writeRouterVerb(writer, dynamic, verb, next, index);
+        writer.writeBlockEnd(`}`);
+      }
     }
   }
+  while (closeCount--) {
+    writer.writeBlockEnd("}");
+  }
   if (catchAll) {
     writer.writeLines(
-      `return ${renderMatch(verb, catchAll, pathIndex)}; // ${catchAll.path}`
+      `return ${renderMatch(verb, catchAll, String(offset))}; // ${catchAll.path}`
     );
-    if (level > 0) {
-      writer.indent--;
-    }
   } else if (level === 0) {
-    writer.writeLines("return;");
-  } else if (useSwitch) {
-    writer.writeLines("break;").indent--;
-  } else {
-    writer.writeBlockEnd("}");
+    writer.writeLines("return null;");
   }
 }
+function wrapPropertyName(name) {
+  return /^[^A-Za-z_$]|[^A-Za-z0-9$_]/.test(name) ? `'${name}'` : name;
+}
 function renderParamsInfo(params, pathIndex) {
+  if (!params.length) {
+    return "{}";
+  }
   let result = "";
   let catchAll = "";
-  let dynamicLength = "";
+  let sep = "{";
   for (const { name, index } of params) {
     if (index >= 0) {
-      result += result ? ", " : "{ ";
-      result += `'${name}': segments[${index + 1}]`;
-      dynamicLength += ` + segments[${index + 1}].length`;
-    } else if (pathIndex && pathIndex >= 0) {
+      result += `${sep} ${wrapPropertyName(name)}: s${index + 1}`;
+      sep || (sep = ",");
+    } else if (pathIndex) {
       catchAll = name;
     }
   }
   if (catchAll) {
-    result += result ? ", " : "{ ";
-    result += `'${catchAll}': pathname.slice(${pathIndex}${dynamicLength})`;
+    result += `${sep} ${wrapPropertyName(
+      catchAll
+    )}: pathname.slice(${pathIndex})`;
   }
   return result ? result + " }" : "{}";
 }
-function renderMatch(verb, { index, params, meta }, pathIndex) {
-  const tuple = [`${verb}$${index}`];
-  if (params == null ? void 0 : params.length) {
-    tuple[1] = renderParamsInfo(params, pathIndex);
+function renderParamsInfoType(params) {
+  if (!params.length) {
+    return "{}";
   }
-  if (meta) {
-    tuple[2] = `meta$${index}`;
+  let result = "{";
+  for (const { name } of params) {
+    result += ` ${wrapPropertyName(name)}: string;`;
   }
-  return `[${tuple.join(", ")}]`;
+  return result + " }";
+}
+function renderMatch(verb, route, pathIndex) {
+  var _a;
+  const handler = `${verb}${route.index}`;
+  const params = ((_a = route.params) == null ? void 0 : _a.length) ? renderParamsInfo(route.params, pathIndex) : "{}";
+  const meta = route.meta ? `meta${route.index}` : "{}";
+  return `{ handler: ${handler}, params: ${params}, meta: ${meta} }`;
+}
+function renderMiddleware(middleware) {
+  const writer = createStringWriter();
+  writer.writeLines(
+    `// ${virtualFilePrefix}/${markoRunFilePrefix}middleware.js`
+  );
+  const imports = writer.branch("imports");
+  imports.writeLines(`import { normalize } from 'virtual:marko-run/internal';`);
+  writer.writeLines("");
+  for (const { id, importPath } of middleware) {
+    const importName = `middleware${id}`;
+    imports.writeLines(`import ${importName} from './${importPath}';`);
+    writer.writeLines(`export const mware${id} = normalize(${importName});`);
+  }
+  imports.join();
+  return writer.end();
+}
+function stripTsExtension(path3) {
+  const index = path3.lastIndexOf(".");
+  if (index !== -1) {
+    const ext = path3.slice(index + 1);
+    if (ext.toLowerCase() === "ts") {
+      return path3.slice(0, index);
+    }
+  }
+  return path3;
+}
+function renderRouteTypeInfo(routes, pathPrefix = ".", adapterTypes = "") {
+  var _a, _b;
+  const writer = createStringWriter();
+  writer.writeLines(
+    `/*
+  WARNING: This file is automatically generated and any changes made to it will be overwritten without warning.
+  Do NOT manually edit this file or your changes will be lost.
+*/
+`,
+    `import type { HandlerLike, Route as AnyRoute, Context as AnyContext, ValidatePath, ValidateHref } from "@marko/run";`,
+    adapterTypes,
+    `
+
+declare global {
+  namespace MarkoRun {`
+  );
+  const pathsWriter = writer.branch("paths");
+  writer.write(`
+    type GetablePath<T extends string> = ValidatePath<GetPaths, T>;
+    type GetableHref<T extends string> = ValidateHref<GetPaths, T>; 
+    type PostablePath<T extends string> = ValidatePath<PostPaths, T>;
+    type PostableHref<T extends string> = ValidateHref<PostPaths, T>; 
+  }
+}
+`);
+  const routesWriter = writer.branch("types");
+  const serverWriter = writer.branch("server");
+  const middlewareRouteTypes = /* @__PURE__ */ new Map();
+  const layoutRouteTypes = /* @__PURE__ */ new Map();
+  const getPaths = /* @__PURE__ */ new Set();
+  const postPaths = /* @__PURE__ */ new Set();
+  for (const route of routes.list) {
+    const { meta, handler, params, middleware, page, layouts } = route;
+    const routeType = `Route${route.index}`;
+    const pathType = `\`${route.path.replace(
+      /\/\$(\$?)([^\/]*)/,
+      (_, catchAll, name) => catchAll ? `/:${name || "rest"}*` : `/:${name}`
+    )}\``;
+    const paramsType = params ? renderParamsInfoType(params) : "{}";
+    let metaType = "undefined";
+    if (page || handler) {
+      const isGet = page || ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.includes("get"));
+      const isPost = (_b = handler == null ? void 0 : handler.verbs) == null ? void 0 : _b.includes("post");
+      if (isGet || isPost) {
+        const path3 = route.path.replace(
+          /\$(\$?)([^/]+)/g,
+          (_, s, name) => s ? `\${...${name}}` : `\${${name}}`
+        );
+        const splatIndex = path3.indexOf("/${...");
+        if (splatIndex >= 0) {
+          const path22 = path3.slice(0, splatIndex) || "/";
+          isGet && getPaths.add(path22);
+          isPost && postPaths.add(path22);
+        }
+        isGet && getPaths.add(path3);
+        isPost && postPaths.add(path3);
+      }
+    }
+    if (meta) {
+      metaType = `typeof import('${pathPrefix}/${stripTsExtension(
+        meta.relativePath
+      )}')`;
+      if (/\.(ts|js|mjs)$/.test(meta.relativePath)) {
+        metaType += `['default']`;
+      }
+    }
+    if (handler) {
+      writeRouteTypeModule(
+        serverWriter,
+        pathPrefix,
+        handler.relativePath,
+        routeType
+      );
+    }
+    if (page) {
+      writer.writeLines(`
+declare module '${pathPrefix}/${page.relativePath}' {
+  export interface Input {}
+
+  namespace MarkoRun {
+    type Route = ${routeType};
+    type Context = AnyContext<AnyContext['platform'], Route>;
+  }
+}`);
+    }
+    if (middleware) {
+      let i = 0;
+      for (const mw of middleware) {
+        const existing = middlewareRouteTypes.get(mw);
+        if (!existing) {
+          middlewareRouteTypes.set(mw, {
+            routeTypes: [routeType],
+            middleware: middleware.slice(0, i)
+          });
+        } else {
+          existing.routeTypes.push(routeType);
+        }
+        i++;
+      }
+    }
+    if (layouts) {
+      for (const layout of layouts) {
+        const existing = layoutRouteTypes.get(layout);
+        if (!existing) {
+          layoutRouteTypes.set(layout, {
+            routeTypes: [routeType]
+          });
+        } else {
+          existing.routeTypes.push(routeType);
+        }
+      }
+    }
+    routesWriter.writeLines(
+      `interface ${routeType} extends AnyRoute<${paramsType}, ${metaType}, ${pathType}> {}`
+    );
+  }
+  pathsWriter.write("    type GetPaths =");
+  for (const path3 of getPaths) {
+    pathsWriter.write(`
+      | '${path3}'`);
+  }
+  pathsWriter.writeLines(";", "");
+  pathsWriter.write("    type PostPaths =");
+  for (const path3 of postPaths) {
+    pathsWriter.write(`
+      | '${path3}'`);
+  }
+  pathsWriter.writeLines(";");
+  pathsWriter.join();
+  for (const [file, { routeTypes }] of middlewareRouteTypes) {
+    writeRouteTypeModule(
+      serverWriter,
+      pathPrefix,
+      file.relativePath,
+      routeTypes.join(" | ")
+    );
+  }
+  for (const [file, { routeTypes }] of layoutRouteTypes) {
+    writer.writeLines(`
+declare module '${pathPrefix}/${file.relativePath}' {
+  export interface Input {
+    renderBody: Marko.Body;
+  }
+
+  namespace MarkoRun {
+    type Route = ${routeTypes.join(" | ")};
+    type Context = AnyContext<AnyContext['platform'], Route>;
+  }
+}`);
+  }
+  for (const route of [routes.special["404"], routes.special["500"]]) {
+    if (route && route.page) {
+      writer.write(`
+declare module '${pathPrefix}/${route.page.relativePath}' {
+  export interface Input {`);
+      if (route.page.type === RoutableFileTypes.Error) {
+        writer.write(`
+    error: unknown;
+  `);
+      }
+      writer.writeLines(`}
+
+  namespace MarkoRun {
+    type Route = AnyRoute;
+    type Context = AnyContext<AnyContext['platform'], Route>;
+  }
+}`);
+    }
+  }
+  serverWriter.join();
+  return writer.end();
+}
+function writeRouteTypeModule(writer, pathPrefix, path3, routeType) {
+  writer.writeLines(`
+declare module '${pathPrefix}/${stripTsExtension(path3)}' {
+  namespace MarkoRun {
+    type Route = ${routeType};
+    type Context = AnyContext<AnyContext['platform'], Route>;
+    type Handler<_Params = Route['params'], _Meta = Route['meta']> = HandlerLike<Route>;
+    function route(handler: Handler): typeof handler;
+    function route<_Params = Route['params'], _Meta = Route['meta']>(handler: Handler): typeof handler;
+  }
+}`);
 }
 
 // src/vite/utils/ast.ts
@@ -908,7 +1213,7 @@ function getExportIdentifiers(astProgramNode) {
 var import_cli_table3 = __toESM(require("cli-table3"), 1);
 var import_kleur = __toESM(require("kleur"), 1);
 var import_gzip_size = require("gzip-size");
-var import_pretty_bytes = __toESM(require("pretty-bytes"), 1);
+var import_human_format = __toESM(require("human-format"), 1);
 var HttpVerbColors = {
   get: import_kleur.default.green,
   post: import_kleur.default.magenta,
@@ -935,7 +1240,7 @@ function logRoutesTable(routes, bundle) {
     headings.push("Meta");
     colAligns.push("center");
   }
-  headings.push("Size");
+  headings.push("Size/GZip");
   colAligns.push("right");
   const table = new import_cli_table3.default({
     head: headings.map((title) => import_kleur.default.bold(import_kleur.default.white(title.toUpperCase()))),
@@ -966,7 +1271,7 @@ function logRoutesTable(routes, bundle) {
       row.push(entryType.join(" -> "));
       hasMiddleware && row.push(route.middleware.length || "");
       hasMeta && row.push(route.meta ? "\u2713" : "");
-      row.push(size || { hAlign: "center", content: "-" });
+      row.push(size || "");
       table.push(row);
     }
   }
@@ -982,54 +1287,76 @@ function logRoutesTable(routes, bundle) {
 function computeRouteSize(route, bundle) {
   if (route.page) {
     for (const chunk of Object.values(bundle)) {
-      if (chunk.type === "chunk" && chunk.modules[route.page.filePath]) {
-        return computeChunkSize(chunk, bundle);
+      if (chunk.type === "chunk") {
+        for (const key of Object.keys(chunk.modules)) {
+          if (key.startsWith(route.page.filePath)) {
+            return computeChunkSize(chunk, bundle);
+          }
+        }
       }
     }
   }
-  return 0;
+  return [0, 0];
+}
+function byteSize(str) {
+  return new Blob([str]).size;
 }
 function computeChunkSize(chunk, bundle, seen = /* @__PURE__ */ new Set()) {
   if (chunk.type === "asset") {
-    return (0, import_gzip_size.gzipSizeSync)(chunk.source);
+    return [
+      byteSize(chunk.source),
+      (0, import_gzip_size.gzipSizeSync)(chunk.source)
+    ];
   }
-  let size = (0, import_gzip_size.gzipSizeSync)(chunk.code);
+  const size = [byteSize(chunk.code), (0, import_gzip_size.gzipSizeSync)(chunk.code)];
   for (const id of chunk.imports) {
     if (!seen.has(id)) {
-      size += computeChunkSize(bundle[id], bundle, seen);
+      const [bytes, compBytes] = computeChunkSize(bundle[id], bundle, seen);
+      size[0] += bytes;
+      size[1] += compBytes;
       seen.add(id);
     }
   }
   return size;
 }
-function prettySize(size) {
-  const _size = (0, import_pretty_bytes.default)(size, {
-    minimumFractionDigits: 1,
-    maximumFractionDigits: 1
-  }).replace(/\sB$/, " B ");
-  if (size < 20 * 1e3)
-    return import_kleur.default.green(_size);
-  if (size < 50 * 1e3)
-    return import_kleur.default.yellow(_size);
-  return import_kleur.default.bold(import_kleur.default.red(_size));
+function prettySize([bytes, compBytes]) {
+  if (bytes <= 0) {
+    return import_kleur.default.gray("0.0 kB");
+  }
+  const [size, prefix] = (0, import_human_format.default)(bytes, { decimals: 1 }).split(/\s+/);
+  const compSize = (0, import_human_format.default)(compBytes, { decimals: 1, prefix, unit: "B" });
+  let str = import_kleur.default.white(size) + import_kleur.default.gray("/");
+  if (compBytes < 20 * 1e3)
+    str += import_kleur.default.green(compSize);
+  else if (compBytes < 50 * 1e3)
+    str += import_kleur.default.yellow(compSize);
+  else
+    import_kleur.default.bold(import_kleur.default.red(compSize));
+  return str;
 }
 function prettyPath(path3) {
   return path3.replace(/\/\$\$(.*)$/, (_, p) => "/" + import_kleur.default.bold(import_kleur.default.dim(`*${p}`))).replace(/\/\$([^/]+)/g, (_, p) => "/" + import_kleur.default.bold(import_kleur.default.dim(`:${p}`)));
 }
 
 // src/vite/utils/config.ts
-var KEY = "__MARKO_SERVE_OPTIONS__";
-function getMarkoServeOptions(viteConfig) {
-  return viteConfig[KEY];
+var PluginConfigKey = "__MARKO_RUN_PLUGIN_CONFIG__";
+var AdapterConfigKey = "__MARKO_RUN_ADAPTER_CONFIG__";
+function getConfig(obj, key) {
+  return obj[key];
 }
-function setMarkoServeOptions(viteConfig, options) {
-  viteConfig[KEY] = options;
-  return viteConfig;
+function setConfig(obj, key, value) {
+  obj[key] = value;
+  return obj;
 }
+var getExternalPluginOptions = (viteConfig) => getConfig(viteConfig, PluginConfigKey);
+var setExternalPluginOptions = (viteConfig, value) => setConfig(viteConfig, PluginConfigKey, value);
+var getExternalAdapterOptions = (viteConfig) => getConfig(viteConfig, AdapterConfigKey);
 
 // src/vite/plugin.ts
+var import_url = require("url");
+var import_meta = {};
+var __dirname = (0, import_url.fileURLToPath)(new URL(".", import_meta.url));
 var markoExt = ".marko";
-var markoServeFilePrefix2 = "__marko-serve__";
 function isMarkoFile(id) {
   return id.endsWith(markoExt);
 }
@@ -1038,8 +1365,10 @@ function markoServe(opts = {}) {
   let store;
   let root;
   let resolvedRoutesDir;
+  let typesDir;
   let isBuild = false;
   let isSSRBuild = false;
+  let tsConfigExists;
   let ssrEntryFiles;
   let devEntryFile;
   let devServer;
@@ -1048,6 +1377,7 @@ function markoServe(opts = {}) {
   let routeDataFilename = "routes.json";
   let extractVerbs;
   let resolvedConfig;
+  let typesFile;
   let isStale = true;
   let isRendered = false;
   const virtualFiles = /* @__PURE__ */ new Map();
@@ -1055,6 +1385,20 @@ function markoServe(opts = {}) {
     routesBuild: 0,
     routesRender: 0
   };
+  async function writeTypesFile() {
+    if (tsConfigExists ?? (tsConfigExists = await globFileExists(
+      root,
+      "{.tsconfig*,tsconfig*.json}"
+    ))) {
+      const filepath = import_path2.default.join(typesDir, "routes.d.ts");
+      const adapterTypeInfo = (adapter == null ? void 0 : adapter.writeTypeInfo) && await (adapter == null ? void 0 : adapter.writeTypeInfo());
+      const data = renderRouteTypeInfo(routes, import_path2.default.relative(typesDir, routesDir), adapterTypeInfo);
+      if (data !== typesFile || !import_fs2.default.existsSync(filepath)) {
+        await ensureDir(typesDir);
+        await import_fs2.default.promises.writeFile(filepath, typesFile = data);
+      }
+    }
+  }
   async function setVirtualFiles(render = false) {
     for (const route of routes.list) {
       if (render && route.handler) {
@@ -1067,24 +1411,30 @@ function markoServe(opts = {}) {
       }
       if (route.page) {
         virtualFiles.set(
-          import_path2.default.join(root, `${markoServeFilePrefix2}route__${route.key}.marko`),
+          import_path2.default.join(root, `${markoRunFilePrefix}route__${route.key}.marko`),
           render ? renderRouteTemplate(route) : ""
         );
       }
       virtualFiles.set(
-        import_path2.default.join(root, `${markoServeFilePrefix2}route__${route.key}.js`),
+        import_path2.default.join(root, `${markoRunFilePrefix}route__${route.key}.js`),
         render ? renderRouteEntry(route) : ""
       );
     }
     for (const route of Object.values(routes.special)) {
       virtualFiles.set(
-        import_path2.default.join(root, `${markoServeFilePrefix2}special__${route.key}.marko`),
+        import_path2.default.join(root, `${markoRunFilePrefix}special__${route.key}.marko`),
         render ? renderRouteTemplate(route) : ""
       );
     }
     virtualFiles.set(
       "@marko/run/router",
-      render ? renderRouter(routes, opts.codegen) : ""
+      render ? renderRouter(routes, {
+        trailingSlashes: opts.trailingSlashes || "RedirectWithout"
+      }) : ""
+    );
+    virtualFiles.set(
+      import_path2.default.join(root, `${markoRunFilePrefix}middleware.js`),
+      render ? renderMiddleware(routes.middleware) : ""
     );
   }
   const buildVirtualFiles = single(async () => {
@@ -1098,6 +1448,7 @@ function markoServe(opts = {}) {
   const renderVirtualFiles = single(async () => {
     const startTime = performance.now();
     await setVirtualFiles(true);
+    await writeTypesFile();
     times.routesRender = performance.now() - startTime;
     isRendered = true;
   });
@@ -1105,23 +1456,30 @@ function markoServe(opts = {}) {
     {
       name: "marko-run-vite:pre",
       enforce: "pre",
-      async config(config, env) {
+      async config(config2, env) {
         var _a, _b, _c;
-        const externalPluginOptions = getMarkoServeOptions(config);
+        const externalPluginOptions = getExternalPluginOptions(config2);
         if (externalPluginOptions) {
           opts = (0, import_vite.mergeConfig)(opts, externalPluginOptions);
         }
-        const adapterOptions = await ((_a = adapter == null ? void 0 : adapter.pluginOptions) == null ? void 0 : _a.call(adapter, opts));
-        if (adapterOptions) {
-          opts = (0, import_vite.mergeConfig)(opts, adapterOptions);
+        if (adapter) {
+          const externalAdapterConfig = getExternalAdapterOptions(config2);
+          if (externalAdapterConfig && adapter.configure) {
+            adapter.configure(externalAdapterConfig);
+          }
+          const adapterOptions = await ((_a = adapter.pluginOptions) == null ? void 0 : _a.call(adapter, opts));
+          if (adapterOptions) {
+            opts = (0, import_vite.mergeConfig)(opts, adapterOptions);
+          }
         }
-        root = (0, import_vite.normalizePath)(config.root || process.cwd());
+        root = (0, import_vite.normalizePath)(config2.root || process.cwd());
         store = opts.store || new import_vite2.FileStore(
           `marko-serve-vite-${import_crypto.default.createHash("SHA1").update(root).digest("hex")}`
         );
         isBuild = env.command === "build";
-        isSSRBuild = isBuild && Boolean((_b = config.build) == null ? void 0 : _b.ssr);
+        isSSRBuild = isBuild && Boolean((_b = config2.build) == null ? void 0 : _b.ssr);
         resolvedRoutesDir = import_path2.default.resolve(root, routesDir);
+        typesDir = import_path2.default.join(root, ".marko-run");
         devEntryFile = import_path2.default.join(root, "index.html");
         let pluginConfig = {
           logLevel: isBuild ? "warn" : void 0,
@@ -1132,18 +1490,18 @@ function markoServe(opts = {}) {
             emptyOutDir: isSSRBuild
           }
         };
-        const adapterConfig = await ((_c = adapter == null ? void 0 : adapter.viteConfig) == null ? void 0 : _c.call(adapter, config));
+        const adapterConfig = await ((_c = adapter == null ? void 0 : adapter.viteConfig) == null ? void 0 : _c.call(adapter, config2));
         if (adapterConfig) {
           pluginConfig = (0, import_vite.mergeConfig)(pluginConfig, adapterConfig);
         }
-        return setMarkoServeOptions(pluginConfig, opts);
+        return setExternalPluginOptions(pluginConfig, opts);
       },
-      configResolved(config) {
-        resolvedConfig = config;
+      configResolved(config2) {
+        resolvedConfig = config2;
         const {
           ssr,
           rollupOptions: { input }
-        } = config.build;
+        } = config2.build;
         if (typeof ssr === "string") {
           ssrEntryFiles = [ssr];
         } else if (typeof input === "string") {
@@ -1174,6 +1532,7 @@ function markoServe(opts = {}) {
             if (isStale) {
               for (const id of virtualFiles.keys()) {
                 devServer.watcher.emit("change", id);
+                break;
               }
             }
           }
@@ -1203,12 +1562,18 @@ function markoServe(opts = {}) {
       },
       async resolveId(importee, importer, { ssr }) {
         let resolved;
-        if (importee.startsWith(virtualFilePrefix)) {
+        if (importee.startsWith(virtualRuntimePrefix)) {
+          return this.resolve(
+            import_path2.default.resolve(__dirname, "../runtime/internal"),
+            importer,
+            { skipSelf: true }
+          );
+        } else if (importee.startsWith(virtualFilePrefix)) {
           importee = import_path2.default.resolve(
             root,
             importee.slice(virtualFilePrefix.length + 1)
           );
-        } else if (!isBuild && importer === devEntryFile && importee.startsWith(`/${markoServeFilePrefix2}`)) {
+        } else if (!isBuild && importer === devEntryFile && importee.startsWith(`/${markoRunFilePrefix}`)) {
           importee = import_path2.default.resolve(root, "." + importee);
         }
         if (isStale) {
@@ -1294,8 +1659,8 @@ async function getVerbsFromFileBuild(context, filePath) {
   if (result) {
     const exportIds = getExportIdentifiers(result.ast);
     for (const id of exportIds) {
-      const verb = id === "del" ? "delete" : id;
-      if (httpVerbs.includes(verb)) {
+      const verb = id.toLowerCase();
+      if (id === verb.toUpperCase() && httpVerbs.includes(verb)) {
         verbs.push(verb);
       }
     }
@@ -1306,12 +1671,19 @@ async function getVerbsFromFileDev(devServer, filePath) {
   const verbs = [];
   const result = await devServer.transformRequest(filePath, { ssr: true });
   if (result && result.code) {
-    const verbMatchReg = /__vite_ssr_exports__,\s+["'](get|post|put|del)["']/g;
+    const verbMatchReg = /__vite_ssr_exports__,\s+["'](GET|POST|PUT|DELETE)["']/gi;
     let match = verbMatchReg.exec(result.code);
     while (match) {
-      const verb = match[1] === "del" ? "delete" : match[1];
+      const id = match[1];
+      const verb = id.toLowerCase();
       if (httpVerbs.includes(verb)) {
-        verbs.push(verb);
+        if (id === verb.toUpperCase()) {
+          verbs.push(verb);
+        } else {
+          console.warn(
+            `Found export '${id}' in handler ${filePath} which is close to '${verb.toUpperCase()}'. Exported handlers need to be uppercase: GET, POST, PUT or DELETE.`
+          );
+        }
       }
       match = verbMatchReg.exec(result.code);
     }
@@ -1330,20 +1702,49 @@ function single(fn) {
     return result;
   };
 }
+async function globFileExists(root, pattern) {
+  return new Promise((resolve, reject) => {
+    (0, import_glob.default)(pattern, { root }, (err, matches) => {
+      if (err) {
+        reject(err);
+      }
+      resolve(matches.length > 0);
+    });
+  });
+}
+async function ensureDir(dir) {
+  if (!import_fs2.default.existsSync(dir)) {
+    await import_fs2.default.promises.mkdir(dir, { recursive: true });
+  }
+}
 
 // src/vite/utils/server.ts
 var import_net = __toESM(require("net"), 1);
 var import_child_process = __toESM(require("child_process"), 1);
-async function spawnServer(cmd, port = 0, cwd = process.cwd(), wait = 3e4) {
+var import_dotenv = require("dotenv");
+var import_fs3 = __toESM(require("fs"), 1);
+async function parseEnv(envFile) {
+  if (import_fs3.default.existsSync(envFile)) {
+    const content = await import_fs3.default.promises.readFile(envFile, "utf8");
+    return (0, import_dotenv.parse)(content);
+  }
+}
+function loadEnv(envFile) {
+  (0, import_dotenv.config)({ path: envFile });
+}
+async function spawnServer(cmd, port = 0, env, cwd = process.cwd(), wait = 3e4) {
   if (port <= 0) {
     port = await getAvailablePort();
   }
+  if (typeof env === "string") {
+    env = await parseEnv(env);
+  }
   const proc = import_child_process.default.spawn(cmd, {
     cwd,
     shell: true,
     stdio: "inherit",
     windowsHide: true,
-    env: { NODE_ENV: "development", ...process.env, PORT: `${port}` }
+    env: { ...env, NODE_ENV: "development", ...process.env, PORT: `${port}` }
   });
   const close = () => {
     proc.unref();
@@ -1390,5 +1791,7 @@ function sleep(ms) {
 0 && (module.exports = {
   getAvailablePort,
   isPortInUse,
+  loadEnv,
+  parseEnv,
   spawnServer
 });