@marko/run 0.0.1-beta2 → 0.0.1-beta4

package/dist/vite/index.js

@@ -1,13 +1,16 @@
 // src/vite/plugin.ts
 import path2 from "path";
 import crypto from "crypto";
+import fs2 from "fs";
+import glob from "glob";
 import { mergeConfig, normalizePath } from "vite";
 import markoVitePlugin, { FileStore } from "@marko/vite";
 
 // 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";
@@ -47,15 +50,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({
@@ -83,10 +91,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
       });
@@ -97,20 +108,24 @@ 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);
         } else {
-          const index = nextId++;
+          const index = nextRouteIndex++;
           routes.set(key, {
             index,
             key,
@@ -123,6 +138,9 @@ async function buildRoutes(walk, basePath) {
             handler,
             score: scorePath(path3, index)
           });
+          for (const mw of middlewareStack) {
+            middleware.add(mw);
+          }
         }
       }
       if (isRoot) {
@@ -158,7 +176,7 @@ async function buildRoutes(walk, basePath) {
         if (name.charCodeAt(0) === 36) {
           if (name.charCodeAt(1) === 36) {
             paramStack.push({
-              name: name.slice(2) || "*",
+              name: name.slice(2) || "rest",
               index: -1
             });
           } else if (name.length > 1) {
@@ -188,7 +206,8 @@ async function buildRoutes(walk, basePath) {
   });
   return {
     list: [...routes.values()],
-    special
+    special,
+    middleware: [...middleware]
   };
 }
 
@@ -238,6 +257,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() {
@@ -254,24 +284,16 @@ function createWriter(sink, options) {
         }
       }
     },
-    write(data) {
-      if (!writer.__isActive) {
-        throw new Error("Cannot write to branch that has been joined");
-      }
-      if (openWriters.size) {
-        buffer += data;
-      } else {
-        sink(data);
+    write(data, indent = false) {
+      if (indent && indentString) {
+        write(indentString);
       }
-      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");
       }
@@ -418,16 +440,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("");
@@ -459,25 +478,47 @@ 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 (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 name = verb === "delete" ? "del" : verb;
+      names.push(name);
+      writer.writeLines(`const handler$${name} = normalize(${name});`);
+    }
     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) {
@@ -485,21 +526,27 @@ function renderRouteEntry(route) {
       `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) {
+function writePageResponse(writer, wrapFn) {
   writer.writeBlock(
-    `return new Response(page.stream(ctx), {`,
+    `${wrapFn ? `const ${wrapFn} = () =>` : `return`} new Response(page.stream(buildInput()), {`,
     ["status: 200,", 'headers: { "content-type": "text/html;charset=UTF-8" }'],
     "});"
   );
 }
+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;
@@ -507,47 +554,38 @@ function writeRouteEntryHandler(writer, route, verb) {
   let nextName;
   let currentName;
   let hasBody = false;
-  writer.writeLines("").writeBlockStart(`export async function ${verb}$${index}(ctx) {`);
+  writer.writeLines("").writeBlockStart(
+    `export async function ${verb}$${index}(context, buildInput) {`
+  );
   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 = `handler$${verb}`;
+      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 = `handler$${verb}`;
+    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 {
@@ -555,24 +593,26 @@ 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 { RequestNotHandled, RequestNotMatched, createInput } from 'virtual:marko-run/internal';`
+  );
   for (const route of routes.list) {
     const verbs = getVerbs(route);
     const names = verbs.map((verb) => `${verb}$${route.index}`);
@@ -580,15 +620,15 @@ function renderRouter(routes, options = DefaultCodegenOptions) {
     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(`function findRoute(method, pathname) {`).writeBlockStart(`switch (method.toLowerCase()) {`);
   for (const verb of httpVerbs) {
     const filteredRoutes = routes.list.filter((route) => hasVerb(route, verb));
     if (filteredRoutes.length) {
@@ -598,120 +638,105 @@ 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.writeBlockEnd("}").writeLines("return null;").writeBlockEnd("}");
+  writer.write(`
+export function matchRoute(method, pathname) {
+  if (!pathname) {
+    pathname = '/';
+  } else if (pathname.charAt(0) !== '/') {
+    pathname = '/' + pathname;
   }
-  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("}");
+  return findRoute(method, pathname);
+}
+
+export async function invokeRoute(route, context) {
+	try {
+    const buildInput = createInput(context);
+		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 === RequestNotHandled) {
+					return;
+				} else if (error !== RequestNotMatched) {
+					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(page$404.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(page$500.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 router(context) {
   try {
-    const url = new URL(request.url);
-    let { pathname } = url;
-
-    if (pathname !== '/') {
-      if (pathname.endsWith('/')) {
-        pathname = pathname.replace(/\\/+$/, '');
-`);
+    const { url, method } = context;
+    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) {
+  writer.write(`   
+
+    const route = matchRoute(method, pathname);
+    return await invokeRoute(route, context);
+  } catch (error) {
     const message = import.meta.env.DEV
-      ? \`Internal Server Error (\${err.message})\`
+      ? \`Internal Server Error (\${error.message})\`
       : "Internal Server Error";
 
     return new Response(
@@ -719,7 +744,7 @@ export async function router(request) {
         error: {
           message,
           stack: import.meta.env.DEV
-            ? \`This will only be seen in development mode\\n\\n\${err.stack}\`
+            ? \`This will only be seen in development mode\\n\\n\${error.stack}\`
             : ""
         }
       }),
@@ -732,101 +757,259 @@ export async function router(request) {
 }`);
   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) {
-      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) {
+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 (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 (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 (dynamic) {
-      writeRouterVerb(writer, dynamic, verb, level + 1, pathIndex);
+    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 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 = `mware${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 = ".") {
+  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 } from "@marko/run";
+    `
+  );
+  const routesWriter = writer.branch("types");
+  const middlewareRouteTypes = /* @__PURE__ */ new Map();
+  for (const route of routes.list) {
+    const { meta, handler, params, middleware } = 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 (meta) {
+      metaType = `typeof import('${pathPrefix}/${stripTsExtension(
+        meta.relativePath
+      )}')`;
+      if (/\.(ts|js|mjs)$/.test(meta.relativePath)) {
+        metaType += `['default']`;
+      }
+    }
+    if (handler) {
+      writeRouteTypeModule(writer, pathPrefix, handler.relativePath, routeType);
+    }
+    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++;
+      }
+    }
+    routesWriter.writeLines(
+      `interface ${routeType} extends Route<${paramsType}, ${metaType}, ${pathType}> {}`
+    );
   }
-  return `[${tuple.join(", ")}]`;
+  for (const [file, { routeTypes }] of middlewareRouteTypes) {
+    const routeType = routeTypes.length > 1 ? routeTypes.join(" | ") : routeTypes[0];
+    writeRouteTypeModule(writer, pathPrefix, file.relativePath, routeType);
+  }
+  return writer.end();
+}
+function writeRouteTypeModule(writer, pathPrefix, path3, routeType) {
+  writer.writeLines(`
+declare module '${pathPrefix}/${stripTsExtension(path3)}' {
+  namespace Marko {
+    type CurrentRoute = ${routeType};
+    type Handler<_Params = CurrentRoute['params'], _Meta = CurrentRoute['meta']> = HandlerLike<CurrentRoute>;
+    function route(handler: Handler): typeof handler;
+    function route<_Params = CurrentRoute['params'], _Meta = CurrentRoute['meta']>(handler: Handler): typeof handler;
+  }
+}`);
 }
 
 // src/vite/utils/ast.ts
@@ -873,7 +1056,7 @@ function getExportIdentifiers(astProgramNode) {
 import Table from "cli-table3";
 import kleur from "kleur";
 import { gzipSizeSync } from "gzip-size";
-import prettyBytes from "pretty-bytes";
+import format from "human-format";
 var HttpVerbColors = {
   get: kleur.green,
   post: kleur.magenta,
@@ -900,7 +1083,7 @@ function logRoutesTable(routes, bundle) {
     headings.push("Meta");
     colAligns.push("center");
   }
-  headings.push("Size");
+  headings.push("Size/GZip");
   colAligns.push("right");
   const table = new Table({
     head: headings.map((title) => kleur.bold(kleur.white(title.toUpperCase()))),
@@ -931,7 +1114,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);
     }
   }
@@ -947,54 +1130,75 @@ 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 gzipSizeSync(chunk.source);
+    return [
+      byteSize(chunk.source),
+      gzipSizeSync(chunk.source)
+    ];
   }
-  let size = gzipSizeSync(chunk.code);
+  const size = [byteSize(chunk.code), 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 = prettyBytes(size, {
-    minimumFractionDigits: 1,
-    maximumFractionDigits: 1
-  }).replace(/\sB$/, " B ");
-  if (size < 20 * 1e3)
-    return kleur.green(_size);
-  if (size < 50 * 1e3)
-    return kleur.yellow(_size);
-  return kleur.bold(kleur.red(_size));
+function prettySize([bytes, compBytes]) {
+  if (bytes <= 0) {
+    return kleur.gray("0.0 kB");
+  }
+  const [size, prefix] = format(bytes, { decimals: 1 }).split(/\s+/);
+  const compSize = format(compBytes, { decimals: 1, prefix, unit: "B" });
+  let str = kleur.white(size) + kleur.gray("/");
+  if (compBytes < 20 * 1e3)
+    str += kleur.green(compSize);
+  else if (compBytes < 50 * 1e3)
+    str += kleur.yellow(compSize);
+  else
+    kleur.bold(kleur.red(compSize));
+  return str;
 }
 function prettyPath(path3) {
   return path3.replace(/\/\$\$(.*)$/, (_, p) => "/" + kleur.bold(kleur.dim(`*${p}`))).replace(/\/\$([^/]+)/g, (_, p) => "/" + kleur.bold(kleur.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
+import { fileURLToPath } from "url";
+var __dirname = fileURLToPath(new URL(".", import.meta.url));
 var markoExt = ".marko";
-var markoServeFilePrefix2 = "__marko-serve__";
 function isMarkoFile(id) {
   return id.endsWith(markoExt);
 }
@@ -1003,8 +1207,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;
@@ -1013,6 +1219,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();
@@ -1020,6 +1227,20 @@ function markoServe(opts = {}) {
     routesBuild: 0,
     routesRender: 0
   };
+  async function writeTypesFile() {
+    if (tsConfigExists ?? (tsConfigExists = await globFileExists(
+      root,
+      "{.tsconfig*,tsconfig*.json}"
+    ))) {
+      const filepath = path2.join(typesDir, "routes.d.ts");
+      const adapterTypeInfo = (adapter == null ? void 0 : adapter.writeTypeInfo) && await (adapter == null ? void 0 : adapter.writeTypeInfo());
+      const data = renderRouteTypeInfo(routes, path2.relative(typesDir, routesDir)) + adapterTypeInfo;
+      if (data !== typesFile || !fs2.existsSync(filepath)) {
+        await ensureDir(typesDir);
+        await fs2.promises.writeFile(filepath, typesFile = data);
+      }
+    }
+  }
   async function setVirtualFiles(render = false) {
     for (const route of routes.list) {
       if (render && route.handler) {
@@ -1032,31 +1253,37 @@ function markoServe(opts = {}) {
       }
       if (route.page) {
         virtualFiles.set(
-          path2.join(root, `${markoServeFilePrefix2}route__${route.key}.marko`),
+          path2.join(root, `${markoRunFilePrefix}route__${route.key}.marko`),
           render ? renderRouteTemplate(route) : ""
         );
       }
       virtualFiles.set(
-        path2.join(root, `${markoServeFilePrefix2}route__${route.key}.js`),
+        path2.join(root, `${markoRunFilePrefix}route__${route.key}.js`),
         render ? renderRouteEntry(route) : ""
       );
     }
     for (const route of Object.values(routes.special)) {
       virtualFiles.set(
-        path2.join(root, `${markoServeFilePrefix2}special__${route.key}.marko`),
+        path2.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(
+      path2.join(root, `${markoRunFilePrefix}middleware.js`),
+      render ? renderMiddleware(routes.middleware) : ""
     );
   }
   const buildVirtualFiles = single(async () => {
     const startTime = performance.now();
     routes = await buildRoutes(createFSWalker(resolvedRoutesDir), routesDir);
     times.routesBuild = performance.now() - startTime;
-    await setVirtualFiles(false);
+    await Promise.all([writeTypesFile(), setVirtualFiles(false)]);
     isStale = false;
     isRendered = false;
   });
@@ -1070,23 +1297,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 = mergeConfig(opts, externalPluginOptions);
         }
-        const adapterOptions = await ((_a = adapter == null ? void 0 : adapter.pluginOptions) == null ? void 0 : _a.call(adapter, opts));
-        if (adapterOptions) {
-          opts = 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 = mergeConfig(opts, adapterOptions);
+          }
         }
-        root = normalizePath(config.root || process.cwd());
+        root = normalizePath(config2.root || process.cwd());
         store = opts.store || new FileStore(
           `marko-serve-vite-${crypto.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 = path2.resolve(root, routesDir);
+        typesDir = path2.join(root, ".marko-run");
         devEntryFile = path2.join(root, "index.html");
         let pluginConfig = {
           logLevel: isBuild ? "warn" : void 0,
@@ -1097,18 +1331,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 = 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") {
@@ -1139,6 +1373,7 @@ function markoServe(opts = {}) {
             if (isStale) {
               for (const id of virtualFiles.keys()) {
                 devServer.watcher.emit("change", id);
+                break;
               }
             }
           }
@@ -1168,12 +1403,18 @@ function markoServe(opts = {}) {
       },
       async resolveId(importee, importer, { ssr }) {
         let resolved;
-        if (importee.startsWith(virtualFilePrefix)) {
+        if (importee.startsWith(virtualRuntimePrefix)) {
+          return this.resolve(
+            path2.resolve(__dirname, "../runtime/internal"),
+            importer,
+            { skipSelf: true }
+          );
+        } else if (importee.startsWith(virtualFilePrefix)) {
           importee = path2.resolve(
             root,
             importee.slice(virtualFilePrefix.length + 1)
           );
-        } else if (!isBuild && importer === devEntryFile && importee.startsWith(`/${markoServeFilePrefix2}`)) {
+        } else if (!isBuild && importer === devEntryFile && importee.startsWith(`/${markoRunFilePrefix}`)) {
           importee = path2.resolve(root, "." + importee);
         }
         if (isStale) {
@@ -1295,20 +1536,49 @@ function single(fn) {
     return result;
   };
 }
+async function globFileExists(root, pattern) {
+  return new Promise((resolve, reject) => {
+    glob(pattern, { root }, (err, matches) => {
+      if (err) {
+        reject(err);
+      }
+      resolve(matches.length > 0);
+    });
+  });
+}
+async function ensureDir(dir) {
+  if (!fs2.existsSync(dir)) {
+    await fs2.promises.mkdir(dir, { recursive: true });
+  }
+}
 
 // src/vite/utils/server.ts
 import net from "net";
 import cp from "child_process";
-async function spawnServer(cmd, port = 0, cwd = process.cwd(), wait = 3e4) {
+import { parse, config } from "dotenv";
+import fs3 from "fs";
+async function parseEnv(envFile) {
+  if (fs3.existsSync(envFile)) {
+    const content = await fs3.promises.readFile(envFile, "utf8");
+    return parse(content);
+  }
+}
+function loadEnv(envFile) {
+  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 = cp.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();
@@ -1355,5 +1625,7 @@ export {
   markoServe as default,
   getAvailablePort,
   isPortInUse,
+  loadEnv,
+  parseEnv,
   spawnServer
 };