@marko/run 0.6.6 → 0.7.0

package/dist/vite/index.cjs

@@ -59,9 +59,9 @@ var import_vite = __toESM(require("@marko/vite"), 1);
 var import_browserslist = __toESM(require("browserslist"), 1);
 var import_debug = __toESM(require("debug"), 1);
 var import_esbuild_plugin_browserslist = require("esbuild-plugin-browserslist");
-var import_fs3 = __toESM(require("fs"), 1);
+var import_fs4 = __toESM(require("fs"), 1);
 var import_glob = require("glob");
-var import_path4 = __toESM(require("path"), 1);
+var import_path6 = __toESM(require("path"), 1);
 var import_url2 = require("url");
 var import_vite2 = require("vite");
 
@@ -91,7 +91,7 @@ function prepareError(err) {
 }
 
 // src/vite/codegen/index.ts
-var import_path = __toESM(require("path"), 1);
+var import_path2 = __toESM(require("path"), 1);
 
 // src/vite/constants.ts
 var markoRunFilePrefix = "__marko-run__";
@@ -116,6 +116,12 @@ var RoutableFileTypes = {
   Error: "500"
 };
 
+// src/vite/utils/fs.ts
+var import_path = __toESM(require("path"), 1);
+var POSIX_SEP = "/";
+var WINDOWS_SEP = "\\";
+var normalizePath = import_path.default.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
+
 // src/vite/utils/route.ts
 var httpVerbOrder = httpVerbs.reduce(
   (order, verb, index) => {
@@ -139,6 +145,9 @@ function hasVerb(route, verb) {
   var _a, _b;
   return verb === "get" && !!route.page || ((_b = (_a = route.handler) == null ? void 0 : _a.verbs) == null ? void 0 : _b.includes(verb)) || verb === "head" && hasVerb(route, "get");
 }
+function getRouteVirtualFileName(route) {
+  return `${markoRunFilePrefix}${route.key.replace(/\//g, ".")}.js`;
+}
 
 // src/vite/codegen/writer.ts
 function createWriter(sink, options) {
@@ -281,27 +290,34 @@ function createStringWriter(opts) {
 }
 
 // src/vite/codegen/index.ts
-function renderRouteTemplate(route, getRelativePath) {
+function normalizedRelativePath(from, to) {
+  const relativePath = normalizePath(import_path2.default.relative(from, to));
+  return relativePath.startsWith(".") ? relativePath : "./" + relativePath;
+}
+function renderRouteTemplate(route, rootDir) {
   if (!route.page) {
     throw new Error(`Route ${route.key} has no page to render`);
   }
+  if (!route.templateFilePath) {
+    throw new Error(`Route ${route.key} has no template file path`);
+  }
   return renderEntryTemplate(
-    route.entryName,
+    normalizedRelativePath(rootDir, route.templateFilePath),
     [...route.layouts, route.page].map(
-      (file) => getRelativePath(file.importPath)
+      (file) => normalizedRelativePath(
+        import_path2.default.dirname(route.templateFilePath),
+        file.filePath
+      )
     ),
     route.key === RoutableFileTypes.Error ? ["error"] : []
   );
 }
 function renderEntryTemplate(name, files, pageInputs = []) {
-  if (!name) {
-    throw new Error(`Invalid argument - 'name' cannot be empty`);
-  }
   if (!files.length) {
     throw new Error(`Invalid argument - 'files' cannot be empty`);
   }
   const writer = createStringWriter();
-  writer.writeLines(`// ${name}.marko`);
+  writer.writeLines(`// ${name}`);
   writer.branch("imports");
   writer.writeLines("");
   writeEntryTemplateTag(writer, files, pageInputs);
@@ -311,7 +327,7 @@ function writeEntryTemplateTag(writer, [file, ...rest], pageInputs, index = 1) {
   if (file) {
     const isLast = !rest.length;
     const tag = isLast ? "Page" : `Layout${index}`;
-    writer.branch("imports").writeLines(`import ${tag} from '${file}';`);
+    writer.branch("imports").writeLines(`import ${tag} from "${file}";`);
     if (isLast) {
       const attributes = pageInputs.length ? " " + pageInputs.map((name) => `${name}=input.${name}`).join(" ") : "";
       writer.writeLines(`<${tag}${attributes}/>`);
@@ -322,9 +338,9 @@ function writeEntryTemplateTag(writer, [file, ...rest], pageInputs, index = 1) {
     }
   }
 }
-function renderRouteEntry(route, entriesDir) {
+function renderRouteEntry(route, rootDir) {
   var _a;
-  const { key, index, handler, page, middleware, meta, entryName } = route;
+  const { key, index, handler, page, middleware, meta } = route;
   const verbs = getVerbs(route);
   if (!verbs) {
     throw new Error(
@@ -332,7 +348,7 @@ function renderRouteEntry(route, entriesDir) {
     );
   }
   const writer = createStringWriter();
-  writer.writeLines(`// ${virtualFilePrefix}/${entryName}.js`);
+  writer.writeLines(`// ${virtualFilePrefix}${getRouteVirtualFileName(route)}`);
   const imports = writer.branch("imports");
   const runtimeImports = [];
   if (handler) {
@@ -344,9 +360,6 @@ function renderRouteEntry(route, entriesDir) {
   if (!page || verbs.some((verb) => verb !== "get" && verb !== "head")) {
     runtimeImports.push("noContent");
   }
-  if (page) {
-    runtimeImports.push("pageResponse");
-  }
   if (verbs.includes("head")) {
     runtimeImports.push("stripResponseBody");
   }
@@ -354,7 +367,7 @@ function renderRouteEntry(route, entriesDir) {
     imports.writeLines(
       `import { ${runtimeImports.join(
         ", "
-      )} } from '${virtualFilePrefix}/runtime/internal';`
+      )} } from "${virtualFilePrefix}/runtime/internal";`
     );
   }
   if (middleware.length) {
@@ -362,7 +375,7 @@ function renderRouteEntry(route, entriesDir) {
     imports.writeLines(
       `import { ${names.join(
         ", "
-      )} } from '${virtualFilePrefix}/${markoRunFilePrefix}middleware.js';`
+      )} } from "${virtualFilePrefix}/${markoRunFilePrefix}middleware.js";`
     );
   }
   if ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.length) {
@@ -374,18 +387,17 @@ function renderRouteEntry(route, entriesDir) {
       writer.writeLines(`const ${verb}Handler = normalize(${importName});`);
     }
     imports.writeLines(
-      `import { ${names.join(", ")} } from './${handler.importPath}';`
+      `import { ${names.join(", ")} } from "${normalizedRelativePath(rootDir, handler.filePath)}";`
     );
   }
   if (page) {
-    const pageNameIndex = page.name.indexOf("+page");
-    const pageNamePrefix = pageNameIndex > 0 ? `${page.name.slice(0, pageNameIndex)}.` : "";
-    const importPath = route.layouts.length ? `./${import_path.default.posix.join(entriesDir, page.relativePath, "..", pageNamePrefix + "route.marko")}` : `./${page.importPath}`;
-    imports.writeLines(`import page from '${importPath}${serverEntryQuery}';`);
+    imports.writeLines(
+      `import page from "${normalizedRelativePath(rootDir, route.templateFilePath || page.filePath)}${serverEntryQuery}";`
+    );
   }
   if (meta) {
     imports.writeLines(
-      `export { default as meta${index} } from './${meta.importPath}';`
+      `export { default as meta${index} } from "${normalizedRelativePath(rootDir, meta.filePath)}";`
     );
   }
   for (const verb of verbs) {
@@ -402,9 +414,7 @@ function writeRouteEntryHandler(writer, route, verb) {
   let hasBody = false;
   writer.writeLines("");
   if (page && (verb === "get" || verb === "head")) {
-    writer.writeBlockStart(
-      `export function ${verb}${index}(context, buildInput) {`
-    );
+    writer.writeBlockStart(`export function ${verb}${index}(context) {`);
   } else {
     writer.writeBlockStart(`export function ${verb}${index}(context) {`);
   }
@@ -414,7 +424,7 @@ function writeRouteEntryHandler(writer, route, verb) {
     if ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.includes(verb)) {
       const name = `${verb}Handler`;
       continuations.writeLines(
-        `const ${currentName} = () => pageResponse(page, buildInput());`
+        `const ${currentName} = () => context.render(page, {});`
       );
       if (len) {
         nextName = currentName;
@@ -433,17 +443,15 @@ function writeRouteEntryHandler(writer, route, verb) {
         hasBody = true;
       }
     } else if (verb === "head") {
-      writer.writeLines(
-        `return stripResponseBody(get${index}(context, buildInput));`
-      );
+      writer.writeLines(`return stripResponseBody(get${index}(context));`);
       hasBody = true;
     } else if (len) {
       continuations.writeLines(
-        `const ${currentName} = () => pageResponse(page, buildInput());`
+        `const ${currentName} = () => context.render(page, {});`
       );
       nextName = currentName;
     } else {
-      writer.writeLines(`return pageResponse(page, buildInput());`);
+      writer.writeLines(`return context.render(page, {});`);
       hasBody = true;
     }
   } else if ((_b = handler == null ? void 0 : handler.verbs) == null ? void 0 : _b.includes(verb)) {
@@ -493,7 +501,7 @@ function writeRouteEntryHandler(writer, route, verb) {
   continuations.join();
   writer.writeBlockEnd("}");
 }
-function renderRouter(routes, entriesDir, options = {
+function renderRouter(routes, rootDir, options = {
   trailingSlashes: "RedirectWithout"
 }) {
   const writer = createStringWriter();
@@ -502,20 +510,19 @@ function renderRouter(routes, entriesDir, options = {
   writer.writeLines(`// @marko/run/router`);
   const imports = writer.branch("imports");
   imports.writeLines(
-    `import { NotHandled, NotMatched, createContext${hasErrorPage || hasNotFoundPage ? ", pageResponse" : ""} } from '${virtualFilePrefix}/runtime/internal';`
+    `import { NotHandled, NotMatched, createContext } from "${virtualFilePrefix}/runtime/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}`);
     imports.writeLines(
-      `import { ${names.join(", ")} } from '${virtualFilePrefix}/${route.entryName}.js';`
+      `import { ${names.join(", ")} } from "${virtualFilePrefix}/${getRouteVirtualFileName(route)}";`
     );
   }
   for (const route of Object.values(routes.special)) {
-    const importPath = route.layouts.length ? `./${import_path.default.posix.join(entriesDir, route.page.relativePath, "..", `route.${route.key}.marko`)}` : `./${route.page.importPath}`;
     imports.writeLines(
-      `import page${route.key} from '${importPath}${serverEntryQuery}';`
+      `import page${route.key} from "${normalizedRelativePath(rootDir, route.templateFilePath || route.page.filePath)}${serverEntryQuery}";`
     );
   }
   writer.writeLines(
@@ -523,11 +530,12 @@ function renderRouter(routes, entriesDir, options = {
 globalThis.__marko_run__ = { match, fetch, invoke };
     `
   ).writeBlockStart(`export function match(method, pathname) {`).writeLines(
-    `if (!pathname) {
-    pathname = '/';
-  } else if (pathname.charAt(0) !== '/') {
-    pathname = '/' + pathname;
-  }`
+    `const last = pathname.length - 1;
+  return match_internal(method, last && pathname.charAt(last) === '/' ? pathname.slice(0, last) : pathname)
+};
+  
+function match_internal(method, pathname) {
+  const len = pathname.length;`
   ).writeBlockStart(`switch (method) {`);
   for (const verb of httpVerbs) {
     const filteredRoutes = routes.list.filter((route) => hasVerb(route, verb));
@@ -543,13 +551,13 @@ globalThis.__marko_run__ = { match, fetch, invoke };
   writer.writeLines("").writeBlockStart(
     "export async function invoke(route, request, platform, url) {"
   ).writeLines(
-    "const [context, buildInput] = createContext(route, request, platform, url);"
+    "const context = createContext(route, request, platform, url);"
   );
   if (hasErrorPage) {
     writer.writeBlockStart("try {");
   }
   writer.writeBlockStart("if (route) {").writeBlockStart("try {").writeLines(
-    "const response = await route.handler(context, buildInput);",
+    "const response = await route.handler(context);",
     "if (response) return response;"
   ).indent--;
   writer.writeBlockStart("} catch (error) {").writeLines(
@@ -566,7 +574,7 @@ const page404ResponseInit = {
     );
     writer.write(`    
     if (context.request.headers.get('Accept')?.includes('text/html')) {
-      return pageResponse(page404, buildInput(), page404ResponseInit);
+      return context.render(page404, {}, page404ResponseInit);
     }`);
   }
   writer.indent--;
@@ -583,7 +591,7 @@ const page500ResponseInit = {
     writer.writeBlockStart(`} catch (error) {`).writeBlockStart(
       `if (context.request.headers.get('Accept')?.includes('text/html')) {`
     ).writeLines(
-      `return pageResponse(page500, buildInput({ error }), page500ResponseInit);`
+      `return context.render(page500, { error }, page500ResponseInit);`
     ).writeBlockEnd("}").writeLines("throw error;").writeBlockEnd("}");
   }
   writer.writeBlockEnd("}");
@@ -595,38 +603,40 @@ function renderFetch(writer, options) {
 export async function fetch(request, platform) {
   try {
     const url = new URL(request.url);
-    let { pathname } = url;`);
+    const { pathname } = url;
+    const last = pathname.length - 1;
+    const hasTrailingSlash = last && pathname.charAt(last) === '/';
+    const normalizedPathname = hasTrailingSlash ? pathname.slice(0, last) : pathname;
+    const route = match_internal(request.method, normalizedPathname);`);
   switch (options.trailingSlashes) {
     case "RedirectWithout":
       writer.write(`
-    if (pathname !== '/' && pathname.endsWith('/')) {
-      url.pathname = pathname.slice(0, -1);
+    if (route && hasTrailingSlash) {
+      url.pathname = normalizedPathname
       return Response.redirect(url);
     }`);
       break;
     case "RedirectWith":
       writer.write(`
-    if (pathname !== '/' && !pathname.endsWith('/')) {
-      url.pathname = pathname + '/';
+    if (route && pathname !== '/' && !hasTrailingSlash) {
+      url.pathname += '/';
       return Response.redirect(url);
     }`);
       break;
     case "RewriteWithout":
       writer.write(`
-    if (pathname !== '/' && pathname.endsWith('/')) {
-      url.pathname = pathname = pathname.slice(0, -1);
+    if (route && hasTrailingSlash) {
+      url.pathname = normalizedPathname;
     }`);
       break;
     case "RewriteWith":
       writer.write(`
-    if (pathname !== '/' && !pathname.endsWith('/')) {
-      url.pathname = pathname = pathname + '/';
+    if (route && pathname !== '/' && !hasTrailingSlash) {
+      url.pathname += '/';
     }`);
       break;
   }
   writer.write(`   
-
-    const route = match(request.method, pathname);
     return await invoke(route, request, platform, url);
   } catch (error) {
     if (import.meta.env.DEV) {
@@ -642,10 +652,9 @@ 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 === 1) return ${renderMatch(verb, route, trie.path)}; // ${trie.path.path}`
+        `if (len === 1) return ${renderMatch(verb, route, trie.path)};`
       );
     } else if (trie.static || dynamic) {
       writer.writeBlockStart(`if (len > 1) {`);
@@ -686,17 +695,15 @@ function writeRouterVerb(writer, trie, verb, level = 0, offset = 1) {
         if (useSwitch) {
           writer.writeBlockStart(`switch (${value}) {`);
         }
-        for (const { key, path: path5, route: route2 } of terminal) {
+        for (const { key, path: path7, route: route2 } of terminal) {
           const decodedKey = decodeURIComponent(key);
           if (useSwitch) {
             writer.write(`case '${decodedKey}': `, true);
           } else {
             writer.write(`if (${value} === '${decodedKey}') `, true);
           }
-          writer.write(
-            `return ${renderMatch(verb, route2, path5)}; // ${path5.path}
-`
-          );
+          writer.write(`return ${renderMatch(verb, route2, path7)};
+`);
         }
         if (useSwitch) {
           writer.writeBlockEnd("}");
@@ -708,7 +715,7 @@ function writeRouterVerb(writer, trie, verb, level = 0, offset = 1) {
             verb,
             dynamic.route,
             dynamic.path
-          )}; // ${dynamic.path.path}`
+          )};`
         );
       }
     }
@@ -768,7 +775,7 @@ function writeRouterVerb(writer, trie, verb, level = 0, offset = 1) {
         catchAll.route,
         catchAll.path,
         String(offset)
-      )}; // ${catchAll.path.path}`
+      )};`
     );
   } else if (level === 0) {
     writer.writeLines("return null;");
@@ -797,43 +804,47 @@ function renderParams(params, pathIndex) {
   }
   return result ? result + " }" : "{}";
 }
-function renderMatch(verb, route, path5, pathIndex) {
+function renderMatch(verb, route, path7, pathIndex) {
   const handler = `${verb}${route.index}`;
-  const params = path5.params ? renderParams(path5.params, pathIndex) : "{}";
+  const params = path7.params ? renderParams(path7.params, pathIndex) : "{}";
   const meta = route.meta ? `meta${route.index}` : "{}";
-  const pathPattern = pathToURLPatternString(path5.path);
-  return `{ handler: ${handler}, params: ${params}, meta: ${meta}, path: '${pathPattern}' }`;
+  return `{ handler: ${handler}, params: ${params}, meta: ${meta}, path: '${path7.path}' }`;
 }
-function renderMiddleware(middleware) {
+function renderMiddleware(middleware, rootDir) {
   const writer = createStringWriter();
   writer.writeLines(
     `// ${virtualFilePrefix}/${markoRunFilePrefix}middleware.js`
   );
   const imports = writer.branch("imports");
   imports.writeLines(
-    `import { normalize } from '${virtualFilePrefix}/runtime/internal';`
+    `import { normalize } from "${virtualFilePrefix}/runtime/internal";`
   );
   writer.writeLines("");
-  for (const { id, importPath } of middleware) {
+  for (const { id, filePath } of middleware) {
     const importName = `middleware${id}`;
-    imports.writeLines(`import ${importName} from './${importPath}';`);
+    imports.writeLines(
+      `import ${importName} from "${normalizedRelativePath(rootDir, filePath)}";`
+    );
     writer.writeLines(`export const mware${id} = normalize(${importName});`);
   }
   imports.join();
   return writer.end();
 }
-function stripTsExtension(path5) {
-  const index = path5.lastIndexOf(".");
+function stripTsExtension(path7) {
+  const index = path7.lastIndexOf(".");
   if (index !== -1) {
-    const ext = path5.slice(index + 1);
+    const ext = path7.slice(index + 1);
     if (ext.toLowerCase() === "ts") {
-      return path5.slice(0, index);
+      return path7.slice(0, index);
     }
   }
-  return path5;
+  return path7;
 }
-async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
-  var _a, _b;
+function decodePath(path7) {
+  return path7;
+}
+async function renderRouteTypeInfo(routes, outDir, adapter) {
+  var _a, _b, _c, _d;
   const writer = createStringWriter();
   writer.writeLines(
     `/*
@@ -862,11 +873,31 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
   const routeTypes = /* @__PURE__ */ new Map();
   for (const route of routes.list) {
     let routeType = "";
-    for (const path5 of route.paths) {
-      const pathType = `"${pathToURLPatternString(path5.path)}"`;
-      routeType += routeType ? " | " + pathType : pathType;
-      routesWriter.writeLines(`${pathType}: Routes["${route.key}"];`);
+    let routeDefinition = "";
+    if (route.page || route.handler) {
+      const verbs = [];
+      if (route.page || ((_b = (_a = route.handler) == null ? void 0 : _a.verbs) == null ? void 0 : _b.includes("get"))) {
+        verbs.push(`"get"`);
+      }
+      if ((_d = (_c = route.handler) == null ? void 0 : _c.verbs) == null ? void 0 : _d.includes("post")) {
+        verbs.push(`"post"`);
+      }
+      routeDefinition = `{ verb: ${verbs.join(" | ")};`;
+      if (route.meta) {
+        const metaPath = stripTsExtension(
+          normalizedRelativePath(outDir, route.meta.filePath)
+        );
+        let metaType = `typeof import("${metaPath}")`;
+        if (/\.(ts|js|mjs)$/.test(route.meta.name)) {
+          metaType += `["default"]`;
+        }
+        routeDefinition += ` meta: ${metaType};`;
+      }
+      routeDefinition += " }";
     }
+    const pathType = `"${decodePath(route.path.path)}"`;
+    routeType += routeType ? " | " + pathType : pathType;
+    routesWriter.writeLines(`${pathType}: ${routeDefinition};`);
     for (const file of [route.handler, route.page]) {
       if (file) {
         const existing = routeTypes.get(file);
@@ -899,31 +930,33 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
   const pageWriter = writer.branch("page");
   const layoutWriter = writer.branch("layout");
   for (const [file, types] of routeTypes) {
-    const path5 = `${pathPrefix}/${file.relativePath}`;
+    const modulePath = stripTsExtension(
+      normalizedRelativePath(outDir, file.filePath)
+    );
     const routeType = `Run.Routes[${types.join(" | ")}]`;
     switch (file.type) {
       case RoutableFileTypes.Handler:
-        writeModuleDeclaration(handlerWriter, path5, routeType);
+        writeModuleDeclaration(handlerWriter, modulePath, routeType);
         break;
       case RoutableFileTypes.Middleware:
-        writeModuleDeclaration(middlewareWriter, path5, routeType);
+        writeModuleDeclaration(middlewareWriter, modulePath, routeType);
         break;
       case RoutableFileTypes.Page:
-        writeModuleDeclaration(pageWriter, path5, routeType);
+        writeModuleDeclaration(pageWriter, modulePath, routeType);
         break;
       case RoutableFileTypes.Layout:
         writeModuleDeclaration(
           layoutWriter,
-          path5,
+          modulePath,
           routeType,
           `
-  export interface Input extends Run.LayoutInput<typeof import('${path5}')> {}`
+  export interface Input extends Run.LayoutInput<typeof import("${modulePath}")> {}`
         );
         break;
       case RoutableFileTypes.Error:
         writeModuleDeclaration(
           writer,
-          path5,
+          modulePath,
           "globalThis.MarkoRun.Route",
           `
   export interface Input {
@@ -932,7 +965,7 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
         );
         break;
       case RoutableFileTypes.NotFound:
-        writeModuleDeclaration(writer, path5, "Run.Route");
+        writeModuleDeclaration(writer, modulePath, "Run.Route");
         break;
     }
   }
@@ -940,40 +973,15 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
   middlewareWriter.join();
   pageWriter.join();
   layoutWriter.join();
-  writer.writeBlockStart(`
-type Routes = {`);
-  for (const route of routes.list) {
-    const { meta, handler, page } = route;
-    if (page || handler) {
-      const verbs = [];
-      if (page || ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.includes("get"))) {
-        verbs.push(`"get"`);
-      }
-      if ((_b = handler == null ? void 0 : handler.verbs) == null ? void 0 : _b.includes("post")) {
-        verbs.push(`"post"`);
-      }
-      let routeType = `{ verb: ${verbs.join(" | ")};`;
-      if (meta) {
-        const metaPath = stripTsExtension(`${pathPrefix}/${meta.relativePath}`);
-        let metaType = `typeof import("${metaPath}")`;
-        if (/\.(ts|js|mjs)$/.test(meta.name)) {
-          metaType += `["default"]`;
-        }
-        routeType += ` meta: ${metaType};`;
-      }
-      writer.writeLines(`"${route.key}": ${routeType} };`);
-    }
-  }
-  writer.writeBlockEnd("}");
   return writer.end();
 }
-function writeModuleDeclaration(writer, path5, routeType, moduleTypes) {
-  writer.writeLines("").write(`declare module "${stripTsExtension(path5)}" {`);
+function writeModuleDeclaration(writer, name, routeType, moduleTypes) {
+  writer.writeLines("").write(`declare module "${name}" {`);
   if (moduleTypes) {
     writer.write(moduleTypes);
   }
   if (routeType) {
-    const isMarko = path5.endsWith(".marko");
+    const isMarko = name.endsWith(".marko");
     writer.write(`
   namespace MarkoRun {
     export { NotHandled, NotMatched, GetPaths, PostPaths, GetablePath, GetableHref, PostablePath, PostableHref, Platform };
@@ -987,21 +995,15 @@ function writeModuleDeclaration(writer, path5, routeType, moduleTypes) {
   writer.writeLines(`
 }`);
 }
-function pathToURLPatternString(path5) {
-  return path5.replace(/\/\$(\$?)([^/]*)/g, (_, catchAll, name) => {
-    name = decodeURIComponent(name);
-    return catchAll ? `/:${name || "rest"}*` : `/:${name}`;
-  });
-}
 function createRouteTrie(routes) {
   const root = {
     key: ""
   };
-  function insert(path5, route) {
+  function insert(path7, route) {
     let node = root;
-    for (const segment of path5.segments) {
+    for (const segment of path7.segments) {
       if (segment === "$$") {
-        node.catchAll ?? (node.catchAll = { route, path: path5 });
+        node.catchAll ?? (node.catchAll = { route, path: path7 });
         return;
       } else if (segment === "$") {
         node = node.dynamic ?? (node.dynamic = {
@@ -1019,17 +1021,18 @@ function createRouteTrie(routes) {
         node = next;
       }
     }
-    node.path ?? (node.path = path5);
+    node.path ?? (node.path = path7);
     node.route ?? (node.route = route);
   }
   for (const route of routes) {
-    for (const path5 of route.paths) {
-      insert(path5, route);
-    }
+    insert(route.path, route);
   }
   return root;
 }
 
+// src/vite/routes/builder.ts
+var import_path3 = __toESM(require("path"), 1);
+
 // src/vite/routes/parse.ts
 function parseFlatRoute(pattern) {
   if (!pattern) throw new Error("Empty pattern");
@@ -1044,53 +1047,72 @@ function parseFlatRoute(pattern) {
   ]);
   function parse2(basePaths, group) {
     const pathMap = /* @__PURE__ */ new Map();
-    const delimiters = group ? ").," : ".,";
+    const delimiters = group ? "`).," : "`.,";
     let charCode;
     let segmentStart = i;
     let type;
     let current;
+    let escaped = "";
+    let escapeStart = 0;
     do {
       charCode = pattern.charCodeAt(i);
-      if (charCode === 41 && group) {
+      if (charCode === 96 /* Escape */) {
+        if (escapeStart) {
+          escaped += pattern.slice(segmentStart, escapeStart - 1) + pattern.slice(escapeStart, i);
+          escapeStart = 0;
+          segmentStart = ++i;
+        } else {
+          escapeStart = i + 1;
+          i = pattern.indexOf("`", escapeStart);
+          if (i < 0) break;
+        }
+      } else if (charCode === 41 /* GroupEnd */ && group) {
         break;
-      } else if (charCode === 44) {
+      } else if (charCode === 44 /* Alternate */) {
         if (!current) {
           segmentEnd(
-            basePaths.map((path5) => ({
-              ...path5,
-              segments: path5.segments.slice()
+            basePaths.map((path7) => ({
+              ...path7,
+              segments: path7.segments.slice()
             })),
-            "",
+            escaped,
             "_",
             pathMap
           );
         } else {
-          segmentEnd(current, pattern.slice(segmentStart, i), type, pathMap);
+          segmentEnd(
+            current,
+            escaped + pattern.slice(segmentStart, i),
+            type,
+            pathMap
+          );
         }
         current = void 0;
         type = void 0;
+        escaped = "";
         segmentStart = ++i;
-      } else if (charCode === 46) {
+      } else if (charCode === 46 /* Directory */) {
         if (current) {
-          segmentEnd(current, pattern.slice(segmentStart, i), type);
+          segmentEnd(current, escaped + pattern.slice(segmentStart, i), type);
         }
         type = void 0;
+        escaped = "";
         segmentStart = ++i;
-      } else if (charCode === 40) {
+      } else if (charCode === 40 /* GroupStart */) {
         const groupPaths = parse2(current || basePaths, ++i);
         if (groupPaths.length) {
           current = groupPaths;
         }
         segmentStart = ++i;
       } else {
-        if (charCode === 95) {
+        if (charCode === 95 /* Pathless */) {
           type = "_";
-        } else if (charCode === 36) {
+        } else if (charCode === 36 /* Dynamic */) {
           type = pattern.charCodeAt(i + 1) === 36 ? "$$" : "$";
         }
-        current ?? (current = basePaths.map((path5) => ({
-          ...path5,
-          segments: path5.segments.slice()
+        current ?? (current = basePaths.map((path7) => ({
+          ...path7,
+          segments: path7.segments.slice()
         })));
         i = len;
         for (const char of delimiters) {
@@ -1101,7 +1123,12 @@ function parseFlatRoute(pattern) {
         }
       }
     } while (i < len);
-    if (group && charCode !== 41) {
+    if (escapeStart) {
+      throw new Error(
+        `Invalid route pattern: unclosed escape '${pattern.slice(escapeStart)}' in '${pattern}'`
+      );
+    }
+    if (group && charCode !== 41 /* GroupEnd */) {
       throw new Error(
         `Invalid route pattern: group was not closed '${pattern.slice(
           group
@@ -1110,16 +1137,21 @@ function parseFlatRoute(pattern) {
     }
     if (!current) {
       segmentEnd(
-        basePaths.map((path5) => ({
-          ...path5,
-          segments: path5.segments.slice()
+        basePaths.map((path7) => ({
+          ...path7,
+          segments: path7.segments.slice()
         })),
-        "",
-        "_",
+        escaped,
+        void 0,
         pathMap
       );
     } else {
-      segmentEnd(current, pattern.slice(segmentStart, i), type, pathMap);
+      segmentEnd(
+        current,
+        escaped + pattern.slice(segmentStart, i),
+        type,
+        pathMap
+      );
     }
     return [...pathMap.values()];
   }
@@ -1128,17 +1160,17 @@ function parseFlatRoute(pattern) {
     if (raw) {
       segment = {
         raw,
-        name: raw,
+        name: normalizeSegment(raw),
         type
       };
       if (type === "$" || type === "$$") {
         segment.name = type;
-        segment.param = raw.slice(type.length);
+        segment.param = normalizeParam(raw.slice(type.length));
       }
     }
-    for (const path5 of paths) {
+    for (const path7 of paths) {
       if (segment) {
-        if (path5.isCatchall) {
+        if (path7.isCatchall) {
           throw new Error(
             `Invalid route pattern: nested segments are not allowed after a catch-all parameter. Found '.' following '${pattern.slice(
               0,
@@ -1146,26 +1178,36 @@ function parseFlatRoute(pattern) {
             )}' in '${pattern}'.`
           );
         }
-        path5.segments.push(segment);
-        path5.id += path5.id === "/" ? segment.name : `/${segment.name}`;
+        path7.segments.push(segment);
+        path7.id += path7.id === "/" ? segment.name : `/${segment.name}`;
         if (type === "$$") {
-          path5.isCatchall = true;
+          path7.isCatchall = true;
         }
       }
       if (map) {
-        if (map.has(path5.id)) {
-          const existing = map.get(path5.id);
+        if (map.has(path7.id)) {
+          const existing = map.get(path7.id);
           const existingExpansion = existing.segments.map((s) => s.raw).join(".");
-          const currentExpansion = path5.segments.map((s) => s.raw).join(".");
+          const currentExpansion = path7.segments.map((s) => s.raw).join(".");
           throw new Error(
-            `Invalid route pattern: route '${path5.id}' is ambiguous. Expansion '${currentExpansion}' collides with '${existingExpansion}' in '${pattern}'.`
+            `Invalid route pattern: route '${path7.id}' is ambiguous. Expansion '${currentExpansion}' collides with '${existingExpansion}' in '${pattern}'.`
           );
         }
-        map.set(path5.id, path5);
+        map.set(path7.id, path7);
       }
     }
   }
 }
+function normalizeParam(segment) {
+  const normalized = normalizeSegment(segment);
+  return /^\$/.test(normalized) ? `\`${normalized}\`` : normalized;
+}
+function normalizeSegment(segment) {
+  return decodeURIComponent(segment).replace(
+    /[/?#]/g,
+    (char) => "%" + char.charCodeAt(0).toString(16)
+  );
+}
 
 // src/vite/routes/vdir.ts
 var _dirs, _pathlessDirs;
@@ -1176,14 +1218,12 @@ var _VDir = class _VDir {
     __publicField(this, "parent");
     __publicField(this, "source");
     __publicField(this, "path");
-    __publicField(this, "fullPath");
     __publicField(this, "segment");
     __publicField(this, "files");
     if (!parent || !segment) {
       this.parent = null;
       this.source = null;
       this.path = "/";
-      this.fullPath = "/";
       this.segment = {
         raw: "",
         name: ""
@@ -1191,12 +1231,8 @@ var _VDir = class _VDir {
     } else {
       this.parent = parent;
       this.source = source;
-      this.path = parent.path + (parent.path === "/" ? segment.name : `/${segment.name}`);
-      this.fullPath = parent.fullPath + (parent.fullPath === "/" ? segment.name : `/${segment.name}`);
-      if (segment.param) {
-        this.fullPath += segment.param;
-      }
       this.segment = segment;
+      this.path = parent.path + (parent.path === "/" ? "" : "/") + segment.name;
     }
   }
   get pathInfo() {
@@ -1209,17 +1245,18 @@ var _VDir = class _VDir {
     for (const { segment } of this) {
       const { type, name, param } = segment;
       if (name && type !== "_") {
-        value.id += sep + (type || name);
+        value.id += sep + name;
         value.path += sep + name;
         value.isEnd = type === "$$";
         if (param) {
-          value.path += param;
+          const unescapedParam = param.charAt(0) === "`" ? param.slice(1, -1) : param;
           const index = type === "$$" ? null : value.segments.length;
           if (!value.params) {
-            value.params = { [param]: index };
+            value.params = { [unescapedParam]: index };
           } else if (!(param in value.params)) {
-            value.params[param] = index;
+            value.params[unescapedParam] = index;
           }
+          value.path += param;
         }
         value.segments.push(name);
         sep = "/";
@@ -1231,11 +1268,11 @@ var _VDir = class _VDir {
     });
     return value;
   }
-  addDir(path5, segment) {
+  addDir(path7, segment) {
     const map = segment.type === "_" ? __privateGet(this, _pathlessDirs) ?? __privateSet(this, _pathlessDirs, /* @__PURE__ */ new Map()) : __privateGet(this, _dirs) ?? __privateSet(this, _dirs, /* @__PURE__ */ new Map());
     const key = segment.type === "$" ? segment.raw : segment.name;
     if (!map.has(key)) {
-      const dir = new _VDir(this, segment, path5);
+      const dir = new _VDir(this, segment, path7);
       map.set(key, dir);
       return dir;
     }
@@ -1251,15 +1288,15 @@ var _VDir = class _VDir {
       const existing = this.files.get(file.type);
       if (existing !== file) {
         throw new Error(
-          `Duplicate file type '${file.type}' added at path '${this.path}'. File '${file.importPath}' collides with '${existing.importPath}'.`
+          `Duplicate file type ${file.type} added at path ${this.path}. File ${file.filePath} collides with ${existing.filePath}.`
         );
       } else if (file.type === RoutableFileTypes.Page || file.type === RoutableFileTypes.Handler) {
         throw new Error(
-          `Ambiguous path definition: route '${this.path}' is defined multiple times by ${file.importPath}`
+          `Ambiguous path definition: route ${this.path} is defined multiple times by ${file.filePath}`
         );
       }
       throw new Error(
-        `Ambiguous path definition: file '${this.path}' is included multiple times by ${file.importPath}`
+        `Ambiguous path definition: file ${this.path} is included multiple times by ${file.filePath}`
       );
     }
   }
@@ -1281,10 +1318,10 @@ var _VDir = class _VDir {
     const dirs = [];
     const unique = /* @__PURE__ */ new Map();
     for (const root of roots) {
-      for (const path5 of paths) {
+      for (const path7 of paths) {
         let dir = root;
-        for (const segment of path5.segments) {
-          dir = dir.addDir(path5, segment);
+        for (const segment of path7.segments) {
+          dir = dir.addDir(path7, segment);
         }
         const existing = unique.get(dir.path);
         if (existing) {
@@ -1297,7 +1334,7 @@ var _VDir = class _VDir {
             }
           }
           throw new Error(
-            `Ambiguous directory structure: '${sourcePath}${path5.source}' defines '${dir.path}' multiple times.`
+            `Ambiguous directory structure: ${sourcePath}${path7.source} defines ${dir.path} multiple times.`
           );
         } else {
           unique.set(dir.path, dir);
@@ -1323,13 +1360,11 @@ function matchRoutableFile(filename) {
   const match = filename.match(routeableFileRegex);
   return match && (match[1] || match[3]).toLowerCase();
 }
-function isSpecialType(type) {
-  return type === RoutableFileTypes.NotFound || type === RoutableFileTypes.Error;
-}
-async function buildRoutes(sources) {
+async function buildRoutes(sources, outDir) {
   const uniqueRoutes = /* @__PURE__ */ new Map();
   const routes = [];
   const special = {};
+  const seenKeys = /* @__PURE__ */ new Map();
   const middlewares = /* @__PURE__ */ new Set();
   const unusedFiles = /* @__PURE__ */ new Set();
   const currentLayouts = /* @__PURE__ */ new Set();
@@ -1337,13 +1372,13 @@ async function buildRoutes(sources) {
   const root = new VDir();
   const dirStack = [];
   let basePath;
-  let importPrefix;
   let activeDirs;
   let isBaseDir;
   let nextFileId = 1;
   let nextRouteIndex = 1;
   const walkOptions = {
-    onEnter({ name }) {
+    onEnter(dir) {
+      let { name } = dir;
       const prevDirStackLength = dirStack.length;
       if (isBaseDir) {
         isBaseDir = false;
@@ -1362,15 +1397,16 @@ async function buildRoutes(sources) {
         dirStack.length = prevDirStackLength;
       };
     },
-    onFile({ name, path: path5 }) {
+    onFile(file) {
+      const { name } = file;
       const match = name.match(routeableFileRegex);
       if (!match) {
         return;
       }
       const type = (match[1] || match[3]).toLowerCase();
-      if (dirStack.length && isSpecialType(type)) {
+      if (dirStack.length && (type === RoutableFileTypes.NotFound || type === RoutableFileTypes.Error)) {
         console.warn(
-          `Special pages '${RoutableFileTypes.NotFound}' and '${RoutableFileTypes.Error}' are only considered in the root directory - ignoring ${path5}`
+          `Special pages '${RoutableFileTypes.NotFound}' and '${RoutableFileTypes.Error}' are only considered in the root directory - ignoring ${file.path}`
         );
         return;
       }
@@ -1379,19 +1415,15 @@ async function buildRoutes(sources) {
         const paths = parseFlatRoute(name.slice(0, match.index));
         dirs = VDir.addPaths(activeDirs, paths);
       }
-      const dirPath = dirStack.join("/");
-      const relativePath = dirPath ? `${dirPath}/${name}` : name;
-      const file = {
+      const routableFile = {
         id: String(nextFileId++),
         name,
         type,
-        filePath: path5,
-        relativePath,
-        importPath: `${importPrefix}/${relativePath}`,
+        filePath: file.path,
         verbs: type === RoutableFileTypes.Page ? ["get", "head"] : void 0
       };
       for (const dir of dirs) {
-        dir.addFile(file);
+        dir.addFile(routableFile);
       }
     }
   };
@@ -1399,7 +1431,6 @@ async function buildRoutes(sources) {
     sources = [sources];
   }
   for (const source of sources) {
-    importPrefix = source.importPrefix ? source.importPrefix.replace(/^\/+|\/+$/g, "") : "";
     basePath = source.basePath || "";
     activeDirs = [root];
     isBaseDir = true;
@@ -1419,7 +1450,8 @@ async function buildRoutes(sources) {
       layout = dir.files.get(RoutableFileTypes.Layout);
       const handler = dir.files.get(RoutableFileTypes.Handler);
       const page = dir.files.get(RoutableFileTypes.Page);
-      let hasSpecial = false;
+      const pathInfo = dir.pathInfo;
+      let layoutsUsed = false;
       if (middleware) {
         if (currentMiddleware.has(middleware)) {
           middleware = void 0;
@@ -1436,64 +1468,64 @@ async function buildRoutes(sources) {
           unusedFiles.add(layout);
         }
       }
+      if (dir === root) {
+        for (const [type, file] of dir.files) {
+          if (type === RoutableFileTypes.NotFound || type === RoutableFileTypes.Error) {
+            special[type] = {
+              index: nextRouteIndex++,
+              key: type,
+              path: dir.pathInfo,
+              middleware: [],
+              layouts: [...currentLayouts],
+              page: file,
+              templateFilePath: currentLayouts.size ? import_path3.default.join(outDir, `${type}.marko`) : void 0
+            };
+            layoutsUsed = true;
+          }
+        }
+      }
       if (page || handler) {
-        const path5 = dir.pathInfo;
-        if (uniqueRoutes.has(path5.id)) {
-          const existing = uniqueRoutes.get(path5.id);
+        if (uniqueRoutes.has(pathInfo.id)) {
+          const existing = uniqueRoutes.get(pathInfo.id);
           const route = routes[existing.index];
           const existingFiles = [route.handler, route.page].filter(Boolean).map((f) => f.filePath);
           const currentFiles = [handler, page].filter(Boolean).map((f) => f.filePath);
-          throw new Error(`Duplicate routes for path '${path5.id}' were defined. A route established by:
-      ${existingFiles.join(" and ")} via '${existing.dir.fullPath}'
-        collides with
-      ${currentFiles.join(" and ")} via '${dir.fullPath}'
-      `);
+          throw new Error(
+            `Duplicate routes for path ${pathInfo.id} were defined. A route established by: "${existingFiles.join(" and ")}" collides with "${currentFiles.join(" and ")}"`
+          );
+        }
+        uniqueRoutes.set(pathInfo.id, { dir, index: routes.length });
+        let key = pathInfo.segments.map(replaceInvalidFilenameChars).concat("route").join("/");
+        const keyCount = (seenKeys.get(key) || 0) + 1;
+        seenKeys.set(key, keyCount);
+        if (keyCount > 1) {
+          key += keyCount;
         }
-        uniqueRoutes.set(path5.id, { dir, index: routes.length });
         routes.push({
           index: nextRouteIndex++,
-          key: dir.fullPath,
-          paths: [path5],
+          key,
+          path: pathInfo,
           middleware: [...currentMiddleware],
           layouts: page ? [...currentLayouts] : [],
           meta: dir.files.get(RoutableFileTypes.Meta),
           page,
           handler,
-          entryName: `${markoRunFilePrefix}route` + (dir.path !== "/" ? dir.fullPath.replace(/\//g, ".").replace(/(%[A-Fa-f0-9]{2})+/g, "_") : "")
+          templateFilePath: page && currentLayouts.size ? import_path3.default.join(outDir, key + ".marko") : void 0
         });
-      }
-      if (dir === root) {
-        for (const [type, file] of dir.files) {
-          if (isSpecialType(type)) {
-            hasSpecial = true;
-            special[type] = {
-              index: 0,
-              key: type,
-              paths: [],
-              middleware: [],
-              layouts: [...currentLayouts],
-              page: file,
-              entryName: `${markoRunFilePrefix}special.${type}`
-            };
-          }
-        }
-      }
-      if (handler || page) {
+        layoutsUsed = !!page;
         for (const middleware2 of currentMiddleware) {
           middlewares.add(middleware2);
           unusedFiles.delete(middleware2);
         }
       }
-      if (page || hasSpecial) {
+      if (layoutsUsed) {
         for (const layout2 of currentLayouts) {
           unusedFiles.delete(layout2);
         }
       }
     }
-    if (dir.dirs) {
-      for (const child of dir.dirs()) {
-        traverse(child);
-      }
+    for (const childDir of dir.dirs()) {
+      traverse(childDir);
     }
     if (middleware) {
       currentMiddleware.delete(middleware);
@@ -1503,10 +1535,13 @@ async function buildRoutes(sources) {
     }
   }
 }
+function replaceInvalidFilenameChars(str) {
+  return str.replace(/[<>:"/\\|?*]+/g, "_");
+}
 
 // src/vite/routes/walk.ts
-var import_fs = __toESM(require("fs"), 1);
-var import_path2 = __toESM(require("path"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path4 = __toESM(require("path"), 1);
 function createFSWalker(dir) {
   return async function walkFS({
     onEnter,
@@ -1518,10 +1553,10 @@ function createFSWalker(dir) {
       const onExit = onEnter == null ? void 0 : onEnter(dir2);
       if (onExit !== false) {
         const dirs = [];
-        const entries = await import_fs.default.promises.readdir(dir2.path, {
+        const entries = await import_fs2.default.promises.readdir(dir2.path, {
           withFileTypes: true
         });
-        const prefix = dir2.path + import_path2.default.sep;
+        const prefix = dir2.path + import_path4.default.sep;
         for (const entry of entries) {
           const walkEntry = {
             name: entry.name,
@@ -1544,7 +1579,7 @@ function createFSWalker(dir) {
     await walk(
       {
         path: dir,
-        name: import_path2.default.basename(dir)
+        name: import_path4.default.basename(dir)
       },
       maxDepth
     );
@@ -1661,36 +1696,34 @@ function logRoutesTable(routes, bundle) {
     style: { compact: true }
   });
   for (const route of routes.list) {
-    for (const path5 of route.paths) {
-      const verbs = getVerbs(route, true);
-      let firstRow = true;
-      for (const verb of verbs) {
-        const entryType = [];
-        let size = "";
-        let verbCell = verbColor(verb)(verb.toUpperCase());
-        if (verb === "get" && !verbs.includes("head")) {
-          verbCell += import_kleur2.default.dim(`,${verbColor(verb)("HEAD")}`);
-        }
-        if (route.handler) {
-          entryType.push(import_kleur2.default.blue("handler"));
-        }
-        if (route.page && (verb === "get" || verb === "head")) {
-          entryType.push(import_kleur2.default.yellow("page"));
-          if (verb === "get") {
-            size = prettySize(computeRouteSize(route, bundle));
-          }
-        }
-        const row = [verbCell];
-        if (verbs.length === 1 || firstRow) {
-          row.push({ rowSpan: verbs.length, content: prettyPath(path5.path) });
-          firstRow = false;
+    const verbs = getVerbs(route, true);
+    let firstRow = true;
+    for (const verb of verbs) {
+      const entryType = [];
+      let size = "";
+      const verbCell = verbColor(verb)(verb.toUpperCase());
+      if (route.handler) {
+        entryType.push(import_kleur2.default.blue("handler"));
+      }
+      if (route.page && (verb === "get" || verb === "head")) {
+        entryType.push(import_kleur2.default.yellow("page"));
+        if (verb === "get") {
+          size = prettySize(computeRouteSize(route, bundle));
         }
-        row.push(entryType.join(" -> "));
-        hasMiddleware && row.push(route.middleware.length || "");
-        hasMeta && row.push(route.meta ? "\u2713" : "");
-        row.push(size || "");
-        table.push(row);
       }
+      const row = [verbCell];
+      if (verbs.length === 1 || firstRow) {
+        row.push({
+          rowSpan: verbs.length,
+          content: prettyPath(route.path.path)
+        });
+        firstRow = false;
+      }
+      row.push(entryType.join(" -> "));
+      hasMiddleware && row.push(route.middleware.length || "");
+      hasMeta && row.push(route.meta ? "\u2713" : "");
+      row.push(size || "");
+      table.push(row);
     }
   }
   for (const [key, route] of Object.entries(routes.special).sort()) {
@@ -1746,17 +1779,20 @@ function prettySize([bytes, compBytes]) {
   else str += import_kleur2.default.bold(import_kleur2.default.red(compSize));
   return str;
 }
-function prettyPath(path5) {
-  return path5.replace(/\/\$\$(.*)$/, (_, p) => "/" + import_kleur2.default.bold(import_kleur2.default.dim(`*${p}`))).replace(/\/\$([^/]+)/g, (_, p) => "/" + import_kleur2.default.bold(import_kleur2.default.dim(`:${p}`)));
+function prettyPath(path7) {
+  return path7.replace(
+    /\/(\$\$?)(`?)([^/`]+)\2/g,
+    (_, type, tick, key) => "/" + type + tick + import_kleur2.default.bold(import_kleur2.default.dim(key)) + tick
+  );
 }
 
 // src/vite/utils/read-once-persisted-store.ts
-var import_fs2 = require("fs");
+var import_fs3 = require("fs");
 var import_os = __toESM(require("os"), 1);
-var import_path3 = __toESM(require("path"), 1);
+var import_path5 = __toESM(require("path"), 1);
 var noop = () => {
 };
-var tmpFile = import_path3.default.join(import_os.default.tmpdir(), "marko-run-storage.json");
+var tmpFile = import_path5.default.join(import_os.default.tmpdir(), "marko-run-storage.json");
 var values = /* @__PURE__ */ new Map();
 var loadedFromDisk;
 var ReadOncePersistedStore = class {
@@ -1776,13 +1812,13 @@ var ReadOncePersistedStore = class {
     if (loadedFromDisk === true) {
       throw new Error(`Value for ${uid} could not be loaded.`);
     }
-    await (loadedFromDisk || (loadedFromDisk = import_fs2.promises.readFile(tmpFile, "utf-8").then(syncDataFromDisk).catch(finishLoadFromDisk)));
+    await (loadedFromDisk || (loadedFromDisk = import_fs3.promises.readFile(tmpFile, "utf-8").then(syncDataFromDisk).catch(finishLoadFromDisk)));
     return this.read();
   }
 };
 function syncDataFromDisk(data) {
   finishLoadFromDisk();
-  import_fs2.promises.unlink(tmpFile).catch(noop);
+  import_fs3.promises.unlink(tmpFile).catch(noop);
   for (const [k, v] of JSON.parse(data)) {
     values.set(k, v);
   }
@@ -1792,23 +1828,23 @@ function finishLoadFromDisk() {
 }
 process.once("beforeExit", (code) => {
   if (code === 0 && values.size) {
-    import_fs2.promises.writeFile(tmpFile, JSON.stringify([...values])).catch(noop);
+    import_fs3.promises.writeFile(tmpFile, JSON.stringify([...values])).catch(noop);
   }
 });
 
 // src/vite/plugin.ts
 var debug = (0, import_debug.default)("@marko/run");
-var __dirname = import_path4.default.dirname((0, import_url2.fileURLToPath)(__importMetaURL));
+var __dirname = import_path6.default.dirname((0, import_url2.fileURLToPath)(__importMetaURL));
 var PLUGIN_NAME_PREFIX = "marko-run-vite";
-var POSIX_SEP = "/";
-var WINDOWS_SEP = "\\";
 var CLIENT_OUT_DIR = "public";
 var MIDDLEWARE_FILENAME = `${markoRunFilePrefix}middleware.js`;
 var ROUTER_FILENAME = `${markoRunFilePrefix}router.js`;
 var defaultPort = Number(process.env.PORT || 3e3);
-var normalizePath = import_path4.default.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
 function markoRun(opts = {}) {
-  let { routesDir, adapter, ...markoVitePluginOptions } = opts;
+  let routesDir;
+  let adapter;
+  let trailingSlashes;
+  const { ...markoVitePluginOptions } = opts;
   let store;
   let root;
   let shouldEmptyOutDir = false;
@@ -1841,15 +1877,11 @@ function markoRun(opts = {}) {
       root,
       "{.tsconfig*,tsconfig*.json}"
     )))) {
-      const filepath = import_path4.default.join(typesDir, "routes.d.ts");
-      const data = await renderRouteTypeInfo(
-        routes2,
-        normalizePath(import_path4.default.relative(typesDir, resolvedRoutesDir)),
-        adapter
-      );
-      if (data !== typesFile || !import_fs3.default.existsSync(filepath)) {
+      const filepath = import_path6.default.join(typesDir, "routes.d.ts");
+      const data = await renderRouteTypeInfo(routes2, typesDir, adapter);
+      if (data !== typesFile || !import_fs4.default.existsSync(filepath)) {
         await ensureDir(typesDir);
-        await import_fs3.default.promises.writeFile(filepath, typesFile = data);
+        await import_fs4.default.promises.writeFile(filepath, typesFile = data);
       }
     }
   }
@@ -1857,20 +1889,25 @@ function markoRun(opts = {}) {
   function buildVirtualFiles() {
     return buildVirtualFilesResult ?? (buildVirtualFilesResult = (async () => {
       virtualFiles.clear();
-      routes = await buildRoutes({
-        walker: createFSWalker(resolvedRoutesDir),
-        importPrefix: routesDir
-      });
+      routes = await buildRoutes(
+        {
+          walker: createFSWalker(resolvedRoutesDir)
+        },
+        entryFilesDir
+      );
       if (!routes.list.length) {
         throw new Error("No routes generated");
       }
       for (const route of routes.list) {
-        virtualFiles.set(import_path4.default.posix.join(root, `${route.entryName}.js`), "");
+        virtualFiles.set(
+          import_path6.default.posix.join(root, getRouteVirtualFileName(route)),
+          ""
+        );
       }
       if (routes.middleware.length) {
-        virtualFiles.set(import_path4.default.posix.join(root, MIDDLEWARE_FILENAME), "");
+        virtualFiles.set(import_path6.default.posix.join(root, MIDDLEWARE_FILENAME), "");
       }
-      virtualFiles.set(import_path4.default.posix.join(root, ROUTER_FILENAME), "");
+      virtualFiles.set(import_path6.default.posix.join(root, ROUTER_FILENAME), "");
       return routes;
     })());
   }
@@ -1880,115 +1917,82 @@ function markoRun(opts = {}) {
       var _a;
       try {
         const routes2 = await buildVirtualFiles();
-        if (import_fs3.default.existsSync(entryFilesDir)) {
-          import_fs3.default.rmSync(entryFilesDir, { recursive: true });
+        if (import_fs4.default.existsSync(entryFilesDir)) {
+          import_fs4.default.rmSync(entryFilesDir, { recursive: true });
         }
         for (const route of routes2.list) {
-          const { handler, page, layouts } = route;
-          if (handler) {
-            const exports2 = await getExportsFromFile(context, handler.filePath);
-            handler.verbs = [];
+          if (route.handler) {
+            const exports2 = await getExportsFromFile(
+              context,
+              route.handler.filePath
+            );
+            route.handler.verbs = [];
             for (const name of exports2) {
               const verb = name.toLowerCase();
               if (name === verb.toUpperCase() && httpVerbs.includes(verb)) {
-                handler.verbs.push(verb);
+                route.handler.verbs.push(verb);
               }
             }
-            if (!handler.verbs.length) {
+            if (!route.handler.verbs.length) {
               context.warn(
-                `Did not find any http verb exports in handler '${import_path4.default.relative(root, handler.filePath)}' - expected ${httpVerbs.map((v) => v.toUpperCase()).join(", ")}`
+                `Did not find any http verb exports in ${import_path6.default.relative(root, route.handler.filePath)} - expected ${httpVerbs.map((v) => v.toUpperCase()).join(", ")}`
               );
             }
           }
-          if (page) {
-            if (layouts.length) {
-              const relativePath = import_path4.default.relative(
-                resolvedRoutesDir,
-                page.filePath
-              );
-              const routeFileDir = import_path4.default.join(entryFilesDir, relativePath, "..");
-              const routeFileRelativePathPosix = normalizePath(
-                import_path4.default.relative(routeFileDir, root)
-              );
-              import_fs3.default.mkdirSync(routeFileDir, { recursive: true });
-              const pageNameIndex = page.name.indexOf("+page");
-              const pageNamePrefix = pageNameIndex > 0 ? `${page.name.slice(0, pageNameIndex)}.` : "";
-              import_fs3.default.writeFileSync(
-                route.templateFilePath = import_path4.default.join(
-                  routeFileDir,
-                  pageNamePrefix + "route.marko"
-                ),
-                renderRouteTemplate(
-                  route,
-                  (to) => import_path4.default.posix.join(routeFileRelativePathPosix, to)
-                )
-              );
-            } else {
-              route.templateFilePath = page.filePath;
-            }
+          if (route.templateFilePath) {
+            import_fs4.default.mkdirSync(import_path6.default.dirname(route.templateFilePath), {
+              recursive: true
+            });
+            import_fs4.default.writeFileSync(
+              route.templateFilePath,
+              renderRouteTemplate(route, root)
+            );
           }
           virtualFiles.set(
-            import_path4.default.posix.join(root, `${route.entryName}.js`),
-            renderRouteEntry(route, relativeEntryFilesDirPosix)
+            import_path6.default.posix.join(root, getRouteVirtualFileName(route)),
+            renderRouteEntry(route, root)
           );
         }
         for (const route of Object.values(routes2.special)) {
-          const { page, layouts, key } = route;
-          if (page) {
-            if (layouts.length) {
-              const relativePath = import_path4.default.relative(
-                resolvedRoutesDir,
-                page.filePath
-              );
-              const routeFileDir = import_path4.default.join(entryFilesDir, relativePath, "..");
-              const routeFileRelativePathPosix = normalizePath(
-                import_path4.default.relative(routeFileDir, root)
-              );
-              import_fs3.default.mkdirSync(routeFileDir, { recursive: true });
-              import_fs3.default.writeFileSync(
-                route.templateFilePath = import_path4.default.join(
-                  routeFileDir,
-                  `route.${key}.marko`
-                ),
-                renderRouteTemplate(
-                  route,
-                  (to) => import_path4.default.posix.join(routeFileRelativePathPosix, to)
-                )
-              );
-            } else {
-              route.templateFilePath = page.filePath;
-            }
+          if (route.templateFilePath) {
+            import_fs4.default.mkdirSync(import_path6.default.dirname(route.templateFilePath), {
+              recursive: true
+            });
+            import_fs4.default.writeFileSync(
+              route.templateFilePath,
+              renderRouteTemplate(route, root)
+            );
           }
         }
         if (routes2.middleware.length) {
           for (const middleware of routes2.middleware) {
             if (!(await getExportsFromFile(context, middleware.filePath)).includes("default")) {
               context.warn(
-                `Did not find a default export in middleware '${import_path4.default.relative(root, middleware.filePath)}'`
+                `Did not find a default export in middleware '${import_path6.default.relative(root, middleware.filePath)}'`
               );
             }
           }
           virtualFiles.set(
-            import_path4.default.posix.join(root, MIDDLEWARE_FILENAME),
-            renderMiddleware(routes2.middleware)
+            import_path6.default.posix.join(root, MIDDLEWARE_FILENAME),
+            renderMiddleware(routes2.middleware, root)
           );
         }
         virtualFiles.set(
-          import_path4.default.posix.join(root, ROUTER_FILENAME),
-          renderRouter(routes2, relativeEntryFilesDirPosix, {
-            trailingSlashes: opts.trailingSlashes || "RedirectWithout"
+          import_path6.default.posix.join(root, ROUTER_FILENAME),
+          renderRouter(routes2, root, {
+            trailingSlashes
           })
         );
         await writeTypesFile(routes2);
         if (adapter == null ? void 0 : adapter.routesGenerated) {
-          await adapter.routesGenerated(
-            routes2,
-            new Map(virtualFiles.entries()),
-            {
+          await adapter.routesGenerated({
+            routes: routes2,
+            virtualFiles: new Map(virtualFiles.entries()),
+            meta: {
               buildTime: times.routesBuild,
               renderTime: times.routesRender
             }
-          );
+          });
           if (!isBuild) {
             await ((_a = opts == null ? void 0 : opts.emitRoutes) == null ? void 0 : _a.call(opts, routes2.list));
           }
@@ -1998,7 +2002,7 @@ function markoRun(opts = {}) {
           throw err;
         }
         virtualFiles.set(
-          import_path4.default.posix.join(root, ROUTER_FILENAME),
+          import_path6.default.posix.join(root, ROUTER_FILENAME),
           `throw ${JSON.stringify(prepareError(err))}`
         );
       }
@@ -2035,27 +2039,28 @@ function markoRun(opts = {}) {
           }
         }
         routesDir = opts.routesDir || "src/routes";
+        trailingSlashes = opts.trailingSlashes || "RedirectWithout";
         store = new ReadOncePersistedStore(
           `vite-marko-run${opts.runtimeId ? `-${opts.runtimeId}` : ""}`
         );
         markoVitePluginOptions.runtimeId = opts.runtimeId;
         markoVitePluginOptions.basePathVar = opts.basePathVar;
-        resolvedRoutesDir = import_path4.default.resolve(root, routesDir);
-        outputDir = import_path4.default.join(root, ((_d = config2.build) == null ? void 0 : _d.outDir) || "dist");
-        entryFilesDir = import_path4.default.join(outputDir, ".marko-run");
+        resolvedRoutesDir = import_path6.default.resolve(root, routesDir);
+        outputDir = import_path6.default.join(root, ((_d = config2.build) == null ? void 0 : _d.outDir) || "dist");
+        entryFilesDir = import_path6.default.join(outputDir, ".marko-run");
         entryFilesDirPosix = normalizePath(entryFilesDir);
         relativeEntryFilesDirPosix = normalizePath(
-          import_path4.default.relative(root, entryFilesDir)
+          import_path6.default.relative(root, entryFilesDir)
         );
-        typesDir = import_path4.default.join(root, ".marko-run");
-        devEntryFile = import_path4.default.join(root, "index.html");
+        typesDir = import_path6.default.join(root, ".marko-run");
+        devEntryFile = import_path6.default.join(root, "index.html");
         devEntryFilePosix = normalizePath(devEntryFile);
         let outDir = ((_e = config2.build) == null ? void 0 : _e.outDir) || "dist";
         const assetsDir = ((_f = config2.build) == null ? void 0 : _f.assetsDir) || "assets";
         let rollupOutputOptions = (_h = (_g = config2.build) == null ? void 0 : _g.rollupOptions) == null ? void 0 : _h.output;
         if (isBuild) {
           if (!isSSRBuild) {
-            outDir = import_path4.default.join(outDir, CLIENT_OUT_DIR);
+            outDir = import_path6.default.join(outDir, CLIENT_OUT_DIR);
           }
           const defaultRollupOutputOptions = {
             assetFileNames({ name }) {
@@ -2180,7 +2185,7 @@ function markoRun(opts = {}) {
         devServer.watcher.on("all", async (type, filename) => {
           seenErrors.clear();
           const routableFileType = matchRoutableFile(
-            import_path4.default.parse(filename).base
+            import_path6.default.parse(filename).base
           );
           if (filename.startsWith(resolvedRoutesDir) && routableFileType) {
             if (type === "add" || type === "unlink" || type === "change" && (routableFileType === RoutableFileTypes.Handler || routableFileType === RoutableFileTypes.Middleware)) {
@@ -2205,8 +2210,8 @@ function markoRun(opts = {}) {
       },
       async buildStart(_options) {
         if (isSSRBuild && shouldEmptyOutDir) {
-          if (import_fs3.default.existsSync(outputDir)) {
-            import_fs3.default.rmSync(outputDir, { recursive: true });
+          if (import_fs4.default.existsSync(outputDir)) {
+            import_fs4.default.rmSync(outputDir, { recursive: true });
           }
         }
         if (isBuild && !isSSRBuild) {
@@ -2230,19 +2235,19 @@ function markoRun(opts = {}) {
       },
       async resolveId(importee, importer) {
         if (importee === "@marko/run/router") {
-          return normalizePath(import_path4.default.resolve(root, ROUTER_FILENAME));
+          return normalizePath(import_path6.default.resolve(root, ROUTER_FILENAME));
         } else if (importee.endsWith(".marko") && importee.includes(relativeEntryFilesDirPosix)) {
           if (!importee.startsWith(root)) {
-            importee = import_path4.default.resolve(root, "." + importee);
+            importee = import_path6.default.resolve(root, "." + importee);
           }
           return normalizePath(importee);
         }
         let virtualFilePath;
         if (importee.startsWith(virtualFilePrefix)) {
           virtualFilePath = importee.slice(virtualFilePrefix.length + 1);
-          importee = import_path4.default.resolve(root, virtualFilePath);
+          importee = import_path6.default.resolve(root, virtualFilePath);
         } else if (!isBuild && importer && (importer === devEntryFile || normalizePath(importer) === devEntryFilePosix) && importee.startsWith(`/${markoRunFilePrefix}`)) {
-          importee = import_path4.default.resolve(root, "." + importee);
+          importee = import_path6.default.resolve(root, "." + importee);
         }
         importee = normalizePath(importee);
         if (!buildVirtualFilesResult) {
@@ -2251,7 +2256,7 @@ function markoRun(opts = {}) {
         if (virtualFiles.has(importee)) {
           return importee;
         } else if (virtualFilePath) {
-          const filePath = import_path4.default.resolve(__dirname, "..", virtualFilePath);
+          const filePath = import_path6.default.resolve(__dirname, "..", virtualFilePath);
           return await this.resolve(filePath, importer, {
             skipSelf: true
           });
@@ -2290,7 +2295,7 @@ function markoRun(opts = {}) {
           const builtEntries = Object.values(bundle).reduce(
             (acc, item) => {
               if (item.type === "chunk" && item.isEntry) {
-                acc.push(import_path4.default.join(options.dir, item.fileName));
+                acc.push(import_path6.default.join(options.dir, item.fileName));
               }
               return acc;
             },
@@ -2314,16 +2319,16 @@ function markoRun(opts = {}) {
       },
       async closeBundle() {
         if (isBuild && !isSSRBuild) {
-          if (import_fs3.default.existsSync(entryFilesDir)) {
-            import_fs3.default.rmSync(entryFilesDir, { recursive: true });
+          if (import_fs4.default.existsSync(entryFilesDir)) {
+            import_fs4.default.rmSync(entryFilesDir, { recursive: true });
           }
           if ((adapter == null ? void 0 : adapter.buildEnd) && routes) {
-            await adapter.buildEnd(
-              resolvedConfig,
-              routes.list,
-              routeData.builtEntries,
-              routeData.sourceEntries
-            );
+            await adapter.buildEnd({
+              routes,
+              config: resolvedConfig,
+              builtEntries: routeData.builtEntries,
+              sourceEntries: routeData.sourceEntries
+            });
           }
         }
       }
@@ -2349,17 +2354,17 @@ async function globFileExists(root, pattern) {
   return (await (0, import_glob.glob)(pattern, { root })).length > 0;
 }
 async function ensureDir(dir) {
-  if (!import_fs3.default.existsSync(dir)) {
-    await import_fs3.default.promises.mkdir(dir, { recursive: true });
+  if (!import_fs4.default.existsSync(dir)) {
+    await import_fs4.default.promises.mkdir(dir, { recursive: true });
   }
 }
 async function getPackageData(dir) {
   do {
-    const pkgPath = import_path4.default.join(dir, "package.json");
-    if (import_fs3.default.existsSync(pkgPath)) {
-      return JSON.parse(await import_fs3.default.promises.readFile(pkgPath, "utf-8"));
+    const pkgPath = import_path6.default.join(dir, "package.json");
+    if (import_fs4.default.existsSync(pkgPath)) {
+      return JSON.parse(await import_fs4.default.promises.readFile(pkgPath, "utf-8"));
     }
-  } while (dir !== (dir = import_path4.default.dirname(dir)));
+  } while (dir !== (dir = import_path6.default.dirname(dir)));
   return null;
 }
 async function resolveAdapter(root, options, log) {
@@ -2431,11 +2436,11 @@ var defaultConfigPlugin = {
 var import_child_process = __toESM(require("child_process"), 1);
 var import_cluster = __toESM(require("cluster"), 1);
 var import_dotenv = require("dotenv");
-var import_fs4 = __toESM(require("fs"), 1);
+var import_fs6 = __toESM(require("fs"), 1);
 var import_net = __toESM(require("net"), 1);
 async function parseEnv(envFile) {
-  if (import_fs4.default.existsSync(envFile)) {
-    const content = await import_fs4.default.promises.readFile(envFile, "utf8");
+  if (import_fs6.default.existsSync(envFile)) {
+    const content = await import_fs6.default.promises.readFile(envFile, "utf8");
     return (0, import_dotenv.parse)(content);
   }
 }