@marko/run 0.1.15 → 0.2.0

package/dist/vite/index.js

@@ -1,3 +1,28 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+
 // src/vite/plugin.ts
 import path2 from "path";
 import crypto from "crypto";
@@ -23,236 +48,509 @@ var RoutableFileTypes = {
   Error: "500"
 };
 
+// src/vite/routes/vdir.ts
+var _dirs, _pathlessDirs;
+var _VDir = class {
+  constructor(parent, segment, source) {
+    __privateAdd(this, _dirs, void 0);
+    __privateAdd(this, _pathlessDirs, void 0);
+    __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: ""
+      };
+    } 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;
+    }
+  }
+  get pathInfo() {
+    const value = {
+      id: "/",
+      path: "/",
+      segments: []
+    };
+    let sep = "";
+    for (const { segment } of this) {
+      const { type, name, param } = segment;
+      if (name && type !== "_") {
+        value.id += sep + (type || name);
+        value.path += sep + name;
+        value.isEnd = type === "$$";
+        if (param) {
+          value.path += param;
+          let index = type === "$$" ? null : value.segments.length;
+          if (!value.params) {
+            value.params = { [param]: index };
+          } else if (!(param in value.params)) {
+            value.params[param] = index;
+          }
+        }
+        value.segments.push(name);
+        sep = "/";
+      }
+    }
+    Object.defineProperty(this, "pathInfo", {
+      value,
+      enumerable: true
+    });
+    return value;
+  }
+  addDir(path3, segment) {
+    const map = segment.type === "_" ? __privateGet(this, _pathlessDirs) ?? __privateSet(this, _pathlessDirs, /* @__PURE__ */ new Map()) : __privateGet(this, _dirs) ?? __privateSet(this, _dirs, /* @__PURE__ */ new Map());
+    if (!map.has(segment.name)) {
+      const dir = new _VDir(this, segment, path3);
+      map.set(segment.name, dir);
+      return dir;
+    }
+    return map.get(segment.name);
+  }
+  addFile(file) {
+    if (!this.files) {
+      this.files = /* @__PURE__ */ new Map();
+      this.files.set(file.type, file);
+    } else if (!this.files.has(file.type)) {
+      this.files.set(file.type, file);
+    } else {
+      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.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.filePath}`
+        );
+      }
+      throw new Error(
+        `Ambiguous path definition: file '${this.path}' is included multiple times by ${file.filePath}`
+      );
+    }
+  }
+  *dirs() {
+    if (__privateGet(this, _pathlessDirs)) {
+      yield* __privateGet(this, _pathlessDirs).values();
+    }
+    if (__privateGet(this, _dirs)) {
+      yield* __privateGet(this, _dirs).values();
+    }
+  }
+  *[Symbol.iterator]() {
+    if (this.parent) {
+      yield* this.parent;
+    }
+    yield this;
+  }
+  static addPaths(roots, paths) {
+    const dirs = [];
+    const unique = /* @__PURE__ */ new Set();
+    for (const root of roots) {
+      for (const path3 of paths) {
+        let dir = root;
+        for (const segment of path3.segments) {
+          dir = dir.addDir(path3, segment);
+        }
+        if (unique.has(dir.path)) {
+          const sources = /* @__PURE__ */ new Set();
+          let sourcePath = "";
+          for (const { source } of dir) {
+            if (source && !sources.has(source.source)) {
+              sources.add(source.source);
+              sourcePath += source.source + "/";
+            }
+          }
+          throw new Error(
+            `Ambiguous directory structure: '${sourcePath}${path3.source}' defines '${dir.path}' multiple times.`
+          );
+        } else {
+          unique.add(dir.path);
+          dirs.push(dir);
+        }
+      }
+    }
+    return dirs;
+  }
+};
+var VDir = _VDir;
+_dirs = new WeakMap();
+_pathlessDirs = new WeakMap();
+
+// src/vite/routes/parse.ts
+function parseFlatRoute(pattern) {
+  if (!pattern)
+    throw new Error("Empty pattern");
+  const len = pattern.length;
+  let i = 0;
+  return parse2([
+    {
+      id: "/",
+      segments: [],
+      source: pattern
+    }
+  ]);
+  function parse2(basePaths, group) {
+    const pathMap = /* @__PURE__ */ new Map();
+    const delimiters = group ? ").," : ".,";
+    let charCode;
+    let segmentStart = i;
+    let type;
+    let current;
+    do {
+      charCode = pattern.charCodeAt(i);
+      if (charCode === 41 && group) {
+        break;
+      } else if (charCode === 44) {
+        if (!current) {
+          segmentEnd(
+            basePaths.map((path3) => ({
+              ...path3,
+              segments: path3.segments.slice()
+            })),
+            "",
+            "_",
+            pathMap
+          );
+        } else {
+          segmentEnd(current, pattern.slice(segmentStart, i), type, pathMap);
+        }
+        current = void 0;
+        type = void 0;
+        segmentStart = ++i;
+      } else if (charCode === 46) {
+        if (current) {
+          segmentEnd(current, pattern.slice(segmentStart, i), type);
+        }
+        type = void 0;
+        segmentStart = ++i;
+      } else if (charCode === 40) {
+        const groupPaths = parse2(current || basePaths, ++i);
+        if (groupPaths.length) {
+          current = groupPaths;
+        }
+        segmentStart = ++i;
+      } else {
+        if (charCode === 95) {
+          type = "_";
+        } else if (charCode === 36) {
+          type = pattern.charCodeAt(i + 1) === 36 ? "$$" : "$";
+        }
+        current ?? (current = basePaths.map((path3) => ({
+          ...path3,
+          segments: path3.segments.slice()
+        })));
+        i = len;
+        for (const char of delimiters) {
+          const index = pattern.indexOf(char, segmentStart);
+          if (index >= 0 && index < i) {
+            i = index;
+          }
+        }
+      }
+    } while (i < len);
+    if (group && charCode !== 41) {
+      throw new Error(
+        `Invalid route pattern: group was not closed '${pattern.slice(
+          group
+        )}' in '${pattern}'`
+      );
+    }
+    if (!current) {
+      segmentEnd(
+        basePaths.map((path3) => ({
+          ...path3,
+          segments: path3.segments.slice()
+        })),
+        "",
+        "_",
+        pathMap
+      );
+    } else {
+      segmentEnd(current, pattern.slice(segmentStart, i), type, pathMap);
+    }
+    return [...pathMap.values()];
+  }
+  function segmentEnd(paths, raw, type, map) {
+    let segment;
+    if (raw) {
+      segment = {
+        raw,
+        name: raw,
+        type
+      };
+      if (type === "$" || type === "$$") {
+        segment.name = type;
+        segment.param = raw.slice(type.length);
+      }
+    }
+    for (const path3 of paths) {
+      if (segment) {
+        if (path3.isCatchall) {
+          throw new Error(
+            `Invalid route pattern: nested segments are not allowed after a catch-all parameter. Found '.' following '${pattern.slice(
+              0,
+              i
+            )}' in '${pattern}'.`
+          );
+        }
+        path3.segments.push(segment);
+        path3.id += path3.id === "/" ? segment.name : `/${segment.name}`;
+        if (type === "$$") {
+          path3.isCatchall = true;
+        }
+      }
+      if (map) {
+        if (map.has(path3.id)) {
+          const existing = map.get(path3.id);
+          const existingExpansion = existing.segments.map((s) => s.raw).join(".");
+          const currentExpansion = path3.segments.map((s) => s.raw).join(".");
+          throw new Error(
+            `Invalid route pattern: route '${path3.id}' is ambiguous. Expansion '${currentExpansion}' collides with '${existingExpansion}' in '${pattern}'.`
+          );
+        }
+        map.set(path3.id, path3);
+      }
+    }
+  }
+}
+
 // src/vite/routes/builder.ts
 var markoFiles = `(${RoutableFileTypes.Layout}|${RoutableFileTypes.Page}|${RoutableFileTypes.NotFound}|${RoutableFileTypes.Error})\\.(?:.*\\.)?(marko)`;
 var nonMarkoFiles = `(${RoutableFileTypes.Middleware}|${RoutableFileTypes.Handler}|${RoutableFileTypes.Meta})\\.(?:.*\\.)?(.+)`;
 var routeableFileRegex = new RegExp(
-  `^[+](?:${markoFiles}|${nonMarkoFiles})$`,
+  `[+](?:${markoFiles}|${nonMarkoFiles})$`,
   "i"
 );
 function matchRoutableFile(filename) {
   const match = filename.match(routeableFileRegex);
   return match && (match[1] || match[3]).toLowerCase();
 }
-function scorePath(path3, index) {
-  const [pattern, splat] = path3.split("/$$", 2);
-  const segments = pattern.split("/").filter(Boolean);
-  return segments.reduce(
-    (score, segment) => score + (segment.startsWith("$") ? 3 : 4),
-    segments.length + (splat === void 0 ? 1 : 2)
-  ) * 1e4 - index;
-}
 function isSpecialType(type) {
   return type === RoutableFileTypes.NotFound || type === RoutableFileTypes.Error;
 }
-async function buildRoutes(walk, basePath) {
+async function buildRoutes(walk, basePath = "") {
   if (basePath) {
     basePath = basePath.replace(/^\/+|\/+$/g, "");
   }
-  const dirStack = [];
-  const pathStack = [];
-  const paramStack = [];
-  const layoutsStack = [];
-  const middlewareStack = [];
-  const routes = /* @__PURE__ */ new Map();
+  const uniqueRoutes = /* @__PURE__ */ new Map();
+  const routes = [];
   const special = {};
-  const middleware = /* @__PURE__ */ new Set();
-  let isRoot = true;
+  const middlewares = /* @__PURE__ */ new Set();
+  const unusedFiles = /* @__PURE__ */ new Set();
+  const currentLayouts = /* @__PURE__ */ new Set();
+  const currentMiddleware = /* @__PURE__ */ new Set();
+  const root = new VDir();
+  const dirStack = [];
+  let activeDirs = [root];
   let nextFileId = 1;
   let nextRouteIndex = 1;
-  let current;
-  let children = [];
+  let isBaseDir = true;
   await walk({
-    onFile(entry) {
-      const type = matchRoutableFile(entry.name);
-      if (!type) {
+    onEnter({ name }) {
+      if (!name || isBaseDir) {
+        isBaseDir = false;
+        return;
+      }
+      dirStack.push(name);
+      const previousDirs = activeDirs;
+      const paths = parseFlatRoute(name);
+      activeDirs = VDir.addPaths(previousDirs, paths);
+      return () => {
+        activeDirs = previousDirs;
+        dirStack.pop();
+      };
+    },
+    onFile({ name, path: path3 }) {
+      const match = name.match(routeableFileRegex);
+      if (!match) {
         return;
       }
-      if (!isRoot && isSpecialType(type)) {
+      const type = (match[1] || match[3]).toLowerCase();
+      if (dirStack.length && isSpecialType(type)) {
         console.warn(
-          `Special pages '${RoutableFileTypes.NotFound}' and '${RoutableFileTypes.Error}' are only considered in the root directory - ignoring ${entry.path}`
+          `Special pages '${RoutableFileTypes.NotFound}' and '${RoutableFileTypes.Error}' are only considered in the root directory - ignoring ${path3}`
         );
         return;
       }
-      if (!current) {
-        current = {
-          path: "/" + pathStack.join("/"),
-          originalPath: dirStack.join("/"),
-          children: [],
-          files: /* @__PURE__ */ new Map()
-        };
-        children.push(current);
-      }
-      let entries = current.files.get(type);
-      if (!entries) {
-        current.files.set(type, entries = []);
+      let dirs = activeDirs;
+      if (match.index) {
+        const paths = parseFlatRoute(name.slice(0, match.index));
+        dirs = VDir.addPaths(activeDirs, paths);
       }
-      const relativePath = current.originalPath ? `${current.originalPath}/${entry.name}` : entry.name;
-      entries.push({
+      const dirPath = dirStack.join("/");
+      const relativePath = dirPath ? `${dirPath}/${name}` : name;
+      const file = {
         id: String(nextFileId++),
+        name,
         type,
-        filePath: entry.path,
+        filePath: path3,
         relativePath,
         importPath: `${basePath}/${relativePath}`,
-        name: entry.name,
         verbs: type === RoutableFileTypes.Page ? ["get"] : void 0
-      });
-    },
-    onDir(dir) {
-      var _a, _b, _c, _d, _e;
-      if (!current) {
-        return;
+      };
+      for (const dir of dirs) {
+        dir.addFile(file);
       }
-      const { path: path3, files } = current;
-      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;
-      if (localMiddleware) {
-        middlewareStack.push(localMiddleware);
+    }
+  });
+  traverse(root);
+  return {
+    list: routes,
+    middleware: [...middlewares],
+    special
+  };
+  function traverse(dir) {
+    let middleware;
+    let layout;
+    if (dir.files) {
+      middleware = dir.files.get(RoutableFileTypes.Middleware);
+      layout = dir.files.get(RoutableFileTypes.Layout);
+      const handler = dir.files.get(RoutableFileTypes.Handler);
+      const page = dir.files.get(RoutableFileTypes.Page);
+      let hasSpecial = false;
+      if (middleware) {
+        if (currentMiddleware.has(middleware)) {
+          middleware = void 0;
+        } else {
+          currentMiddleware.add(middleware);
+          unusedFiles.add(middleware);
+        }
       }
-      if (localLayout) {
-        layoutsStack.push(localLayout);
+      if (layout) {
+        if (currentLayouts.has(layout)) {
+          layout = void 0;
+        } else {
+          currentLayouts.add(layout);
+          unusedFiles.add(layout);
+        }
       }
-      if (handler || page) {
-        const key = path3.replace(/(\$\$?)[^\/]*/g, "$1").replace(/^\/+/, "").replace(/[^a-z0-9_$\/]+/gi, "").replace(/\//g, "__") || "index";
-        if (routes.has(key)) {
-          const existing = routes.get(key);
-          const existingFiles = [existing.handler, existing.page].filter(Boolean).map((f) => f.filePath);
+      if (page || handler) {
+        const path3 = dir.pathInfo;
+        if (uniqueRoutes.has(path3.id)) {
+          const existing = uniqueRoutes.get(path3.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 ${path3} were defined. A route established by:
-  ${existingFiles}
-    collides with
-  ${currentFiles.join(" and ")}
-  `);
-        } else {
-          const index = nextRouteIndex++;
-          routes.set(key, {
-            index,
-            key,
-            path: path3,
-            params: [...paramStack],
-            middleware: [...middlewareStack],
-            layouts: page ? [...layoutsStack] : [],
-            meta: (_e = files.get(RoutableFileTypes.Meta)) == null ? void 0 : _e[0],
-            page,
-            handler,
-            entryName: `${markoRunFilePrefix}route__${key}`,
-            score: scorePath(path3, index)
-          });
-          for (const mw of middlewareStack) {
-            middleware.add(mw);
-          }
+          throw new Error(`Duplicate routes for path '${path3.path}' were defined. A route established by:
+      ${existingFiles.join(" and ")} via '${existing.dir.path}'
+        collides with
+      ${currentFiles.join(" and ")} via '${dir.path}'
+      `);
         }
+        uniqueRoutes.set(path3.id, { dir, index: routes.length });
+        routes.push({
+          index: nextRouteIndex++,
+          key: dir.fullPath,
+          paths: [path3],
+          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, "_") : "")
+        });
       }
-      if (isRoot) {
-        for (const [type, entries] of files) {
+      if (dir === root) {
+        for (const [type, file] of dir.files) {
           if (isSpecialType(type)) {
+            hasSpecial = true;
             special[type] = {
               index: 0,
               key: type,
-              path: path3,
+              paths: [],
               middleware: [],
-              layouts: [...layoutsStack],
-              page: entries[0],
-              entryName: `${markoRunFilePrefix}special__${type}`,
-              score: 0
+              layouts: [...currentLayouts],
+              page: file,
+              entryName: `${markoRunFilePrefix}special.${type}`
             };
           }
         }
-      } else if (dir.startsWith("$$")) {
-        return false;
       }
-      return () => {
-        middlewareStack.length = middlewareStackLength;
-        layoutsStack.length = layoutsStackLength;
-      };
-    },
-    onEnter({ name }) {
-      const pathStackLength = pathStack.length;
-      const paramStackLength = paramStack.length;
-      const prevChildren = children;
-      const prevCurrent = current;
-      const prevIsRoot = isRoot;
-      if (name.charCodeAt(0) === 95) {
-      } else {
-        if (name.charCodeAt(0) === 36) {
-          if (name.charCodeAt(1) === 36) {
-            if (name.length > 2) {
-              paramStack.push({
-                name: name.slice(2),
-                index: -1
-              });
-            }
-          } else if (name.length > 1) {
-            paramStack.push({
-              name: name.slice(1),
-              index: pathStackLength
-            });
-          }
+      if (handler || page) {
+        for (const middleware2 of currentMiddleware) {
+          middlewares.add(middleware2);
+          unusedFiles.delete(middleware2);
         }
-        pathStack.push(name);
       }
-      dirStack.push(name);
-      isRoot = false;
-      if (current) {
-        children = current.children;
-        current = void 0;
+      if (page || hasSpecial) {
+        for (const layout2 of currentLayouts) {
+          unusedFiles.delete(layout2);
+        }
       }
-      return () => {
-        dirStack.pop();
-        pathStack.length = pathStackLength;
-        paramStack.length = paramStackLength;
-        children = prevChildren;
-        current = prevCurrent;
-        isRoot = prevIsRoot;
-      };
     }
-  });
-  return {
-    list: [...routes.values()],
-    special,
-    middleware: [...middleware]
-  };
+    if (dir.dirs) {
+      for (const child of dir.dirs()) {
+        traverse(child);
+      }
+    }
+    if (middleware) {
+      currentMiddleware.delete(middleware);
+    }
+    if (layout) {
+      currentLayouts.delete(layout);
+    }
+  }
 }
 
 // src/vite/routes/walk.ts
 import fs from "fs";
 import path from "path";
 function createFSWalker(dir) {
-  return async function walkFS({ onFile, onEnter, onDir, maxDepth = 50 }) {
+  return async function walkFS({
+    onEnter,
+    onFile,
+    onDir,
+    maxDepth = 50
+  }) {
     async function walk(dir2, depth) {
-      const dirs = [];
-      const entries = await fs.promises.readdir(dir2, { withFileTypes: true });
-      const prefix = dir2 + path.sep;
-      for (const dirEntry of entries) {
-        const entry = {
-          name: dirEntry.name,
-          path: prefix + dirEntry.name
-        };
-        if (dirEntry.isDirectory()) {
-          dirs.push(entry);
-        } else {
-          onFile == null ? void 0 : onFile(entry);
+      const onExit = onEnter == null ? void 0 : onEnter(dir2);
+      if (onExit !== false) {
+        const dirs = [];
+        const entries = await fs.promises.readdir(dir2.path, {
+          withFileTypes: true
+        });
+        const prefix = dir2.path + path.sep;
+        for (const entry of entries) {
+          const walkEntry = {
+            name: entry.name,
+            path: prefix + entry.name
+          };
+          if (entry.isDirectory()) {
+            dirs.push(walkEntry);
+          } else {
+            onFile == null ? void 0 : onFile(walkEntry);
+          }
         }
-      }
-      const onAfter = onDir == null ? void 0 : onDir(dir2);
-      if (onAfter !== false) {
-        if (--depth > 0) {
+        if ((onDir == null ? void 0 : onDir()) !== false && --depth > 0) {
           for (const entry of dirs) {
-            const onExit = onEnter == null ? void 0 : onEnter(entry);
-            if (onExit !== false) {
-              await walk(entry.path, depth);
-              onExit == null ? void 0 : onExit();
-            }
+            await walk(entry, depth);
           }
         }
-        onAfter == null ? void 0 : onAfter();
+        onExit == null ? void 0 : onExit();
       }
     }
-    await walk(dir, maxDepth);
+    await walk(
+      {
+        path: dir,
+        name: path.basename(dir)
+      },
+      maxDepth
+    );
   };
 }
 
@@ -344,6 +642,10 @@ function createWriter(sink, options) {
                 branches[i] = null;
                 firstOpenIndex++;
               }
+              if (!openWriters.size) {
+                sink(buffer);
+                buffer = "";
+              }
             }
           }
         )
@@ -389,49 +691,6 @@ function createStringWriter(opts) {
   });
 }
 
-// src/vite/routes/routeTrie.ts
-function createRouteTrie(routes) {
-  const root = {
-    key: ""
-  };
-  function insert(keys, value) {
-    let node = root;
-    for (const key of keys) {
-      if (key.startsWith("$$")) {
-        if (!node.catchAll) {
-          node.catchAll = value;
-          return true;
-        }
-        return false;
-      } else if (key.startsWith("$")) {
-        node = node.dynamic ?? (node.dynamic = {
-          key: ""
-        });
-      } else {
-        node.static ?? (node.static = /* @__PURE__ */ new Map());
-        let next = node.static.get(key);
-        if (!next) {
-          next = {
-            key
-          };
-          node.static.set(key, next);
-        }
-        node = next;
-      }
-    }
-    if (node.route === void 0) {
-      node.route = value;
-      return true;
-    }
-    return false;
-  }
-  for (const route of routes) {
-    const keys = route.path === "/" ? [] : route.path.split("/").slice(1);
-    insert(keys, route);
-  }
-  return root;
-}
-
 // src/vite/utils/route.ts
 function getVerbs(route) {
   var _a, _b;
@@ -452,9 +711,7 @@ function renderRouteTemplate(route) {
     throw new Error(`Route ${route.key} has no page to render`);
   }
   const writer = createStringWriter();
-  writer.writeLines(
-    `// ${virtualFilePrefix}/${route.entryName}.marko`
-  );
+  writer.writeLines(`// ${virtualFilePrefix}/${route.entryName}.marko`);
   writer.branch("imports");
   writer.writeLines("");
   writeRouteTemplateTag(writer, [...route.layouts, route.page]);
@@ -484,9 +741,7 @@ function renderRouteEntry(route) {
     );
   }
   const writer = createStringWriter();
-  writer.writeLines(
-    `// ${virtualFilePrefix}/${entryName}.js`
-  );
+  writer.writeLines(`// ${virtualFilePrefix}/${entryName}.js`);
   const imports = writer.branch("imports");
   const runtimeImports = [];
   if (handler) {
@@ -631,9 +886,7 @@ function renderRouter(routes, options = {
     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}/${route.entryName}.js';`
     );
   }
   for (const { key, entryName } of Object.values(routes.special)) {
@@ -704,7 +957,7 @@ const page404ResponseInit = {
   if (routes.special[RoutableFileTypes.Error]) {
     imports.writeLines(`
 const page500ResponseInit = {
-  status: 404,
+  status: 500,
   headers: { "content-type": "text/html;charset=UTF-8" },
 };`);
     writer.writeBlockStart(
@@ -768,7 +1021,7 @@ function writeRouterVerb(writer, trie, verb, level = 0, offset = 1) {
     writer.writeLines(`const len = pathname.length;`);
     if (route) {
       writer.writeLines(
-        `if (len === 1) return ${renderMatch(verb, route)}; // ${route.path}`
+        `if (len === 1) return ${renderMatch(verb, route, trie.path)}; // ${trie.path.path}`
       );
     } else if (trie.static || dynamic) {
       writer.writeBlockStart(`if (len > 1) {`);
@@ -805,14 +1058,14 @@ function writeRouterVerb(writer, trie, verb, level = 0, offset = 1) {
         if (useSwitch) {
           writer.writeBlockStart(`switch (${value}.toLowerCase()) {`);
         }
-        for (const { key, route: route2 } of terminal) {
+        for (const { key, path: path3, 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}
+            `return ${renderMatch(verb, route2, path3)}; // ${path3.path}
 `
           );
         }
@@ -822,7 +1075,11 @@ function writeRouterVerb(writer, trie, verb, level = 0, offset = 1) {
       }
       if (dynamic == null ? void 0 : dynamic.route) {
         writer.writeLines(
-          `if (${value}) return ${renderMatch(verb, dynamic.route)}; // ${dynamic.route.path}`
+          `if (${value}) return ${renderMatch(
+            verb,
+            dynamic.route,
+            dynamic.path
+          )}; // ${dynamic.path.path}`
         );
       }
     }
@@ -855,7 +1112,11 @@ function writeRouterVerb(writer, trie, verb, level = 0, offset = 1) {
           }
           const nextOffset = typeof offset === "string" ? index : offset + child.key.length + 1;
           writeRouterVerb(writer, child, verb, next, nextOffset);
-          writer.writeBlockEnd("}");
+          if (useSwitch) {
+            writer.writeBlockEnd("} break;");
+          } else {
+            writer.writeBlockEnd("}");
+          }
         }
         if (useSwitch) {
           writer.writeBlockEnd("}");
@@ -873,7 +1134,7 @@ function writeRouterVerb(writer, trie, verb, level = 0, offset = 1) {
   }
   if (catchAll) {
     writer.writeLines(
-      `return ${renderMatch(verb, catchAll, String(offset))}; // ${catchAll.path}`
+      `return ${renderMatch(verb, catchAll.route, catchAll.path, String(offset))}; // ${catchAll.path.path}`
     );
   } else if (level === 0) {
     writer.writeLines("return null;");
@@ -883,15 +1144,12 @@ function wrapPropertyName(name) {
   name = decodeURIComponent(name);
   return /^[^A-Za-z_$]|[^A-Za-z0-9$_]/.test(name) ? `'${name}'` : name;
 }
-function renderParamsInfo(params, pathIndex) {
-  if (!params.length) {
-    return "{}";
-  }
+function renderParams(params, pathIndex) {
   let result = "";
   let catchAll = "";
   let sep = "{";
-  for (const { name, index } of params) {
-    if (index >= 0) {
+  for (const [name, index] of Object.entries(params)) {
+    if (typeof index === "number") {
       result += `${sep} ${wrapPropertyName(name)}: s${index + 1}`;
       sep = ",";
     } else if (pathIndex) {
@@ -905,13 +1163,12 @@ function renderParamsInfo(params, pathIndex) {
   }
   return result ? result + " }" : "{}";
 }
-function renderMatch(verb, route, pathIndex) {
-  var _a;
+function renderMatch(verb, route, path3, pathIndex) {
   const handler = `${verb}${route.index}`;
-  const params = ((_a = route.params) == null ? void 0 : _a.length) ? renderParamsInfo(route.params, pathIndex) : "{}";
+  const params = path3.params ? renderParams(path3.params, pathIndex) : "{}";
   const meta = route.meta ? `meta${route.index}` : "{}";
-  const path3 = pathToURLPatternString(route.path);
-  return `{ handler: ${handler}, params: ${params}, meta: ${meta}, path: '${path3}' }`;
+  const pathPattern = pathToURLPatternString(path3.path);
+  return `{ handler: ${handler}, params: ${params}, meta: ${meta}, path: '${pathPattern}' }`;
 }
 function renderMiddleware(middleware) {
   const writer = createStringWriter();
@@ -962,37 +1219,20 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
 `);
     }
   }
+  headWriter.join();
   writer.writeBlockStart(`interface AppData extends Run.DefineApp<{`).writeBlockStart("routes: {");
   const routesWriter = writer.branch("routes");
   writer.writeBlockEnd("}").writeBlockEnd(`}> {}`).writeBlockEnd(`}`);
-  headWriter.join();
   const moduleWriter = writer.branch("module");
   const middlewareRouteTypes = /* @__PURE__ */ new Map();
   const layoutRouteTypes = /* @__PURE__ */ new Map();
   for (const route of routes.list) {
-    const { meta, handler, middleware, page, layouts } = route;
-    const pathType = `${pathToURLPatternString(route.path)}`;
-    const routeType = `"${pathType}"`;
-    let verbType = "";
-    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"`);
-      }
-      verbType = verbs.join(" | ");
-    }
-    if (meta) {
-      const path3 = stripTsExtension(`${pathPrefix}/${meta.relativePath}`);
-      let metaType = `typeof import("${path3}")`;
-      if (/\.(ts|js|mjs)$/.test(meta.relativePath)) {
-        metaType += `["default"]`;
-      }
-      routesWriter.writeBlockStart(`"${pathType}": {`).writeLines(`verb: ${verbType};`, `meta: ${metaType};`).writeBlockEnd("};");
-    } else {
-      routesWriter.writeLines(`"${pathType}": { verb: ${verbType} };`);
+    const { handler, middleware, page, layouts } = route;
+    let routeType = "";
+    for (const path3 of route.paths) {
+      const pathType = `"${pathToURLPatternString(path3.path)}"`;
+      routeType += routeType ? " | " + pathType : pathType;
+      routesWriter.writeLines(`${pathType}: Routes["${route.key}"]`);
     }
     if (handler) {
       writeModuleDeclaration(
@@ -1059,7 +1299,7 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
   }`
     );
   }
-  if ((_c = routes.special["404"]) == null ? void 0 : _c.page) {
+  if ((_a = routes.special["404"]) == null ? void 0 : _a.page) {
     writeModuleDeclaration(
       writer,
       `${pathPrefix}/${routes.special["404"].page.relativePath}`,
@@ -1068,7 +1308,7 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
   export interface Input {}`
     );
   }
-  if ((_d = routes.special["500"]) == null ? void 0 : _d.page) {
+  if ((_b = routes.special["500"]) == null ? void 0 : _b.page) {
     writeModuleDeclaration(
       writer,
       `${pathPrefix}/${routes.special["500"].page.relativePath}`,
@@ -1080,6 +1320,31 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
     );
   }
   moduleWriter.join();
+  writer.writeBlockStart(`
+type Routes = {`);
+  for (const route of routes.list) {
+    const { meta, handler, page } = route;
+    if (page || handler) {
+      const verbs = [];
+      if (page || ((_c = handler == null ? void 0 : handler.verbs) == null ? void 0 : _c.includes("get"))) {
+        verbs.push(`"get"`);
+      }
+      if ((_d = handler == null ? void 0 : handler.verbs) == null ? void 0 : _d.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.relativePath)) {
+          metaType += `["default"]`;
+        }
+        routeType += ` meta: ${metaType};`;
+      }
+      writer.writeLines(`"${route.key}": ${routeType} };`);
+    }
+  }
+  writer.writeBlockEnd("}");
   return writer.end();
 }
 function writeModuleDeclaration(writer, path3, routeType, moduleTypes) {
@@ -1107,6 +1372,42 @@ function pathToURLPatternString(path3) {
     return catchAll ? `/:${name || "rest"}*` : `/:${name}`;
   });
 }
+function createRouteTrie(routes) {
+  const root = {
+    key: ""
+  };
+  function insert(path3, route) {
+    let node = root;
+    for (const segment of path3.segments) {
+      if (segment === "$$") {
+        node.catchAll ?? (node.catchAll = { route, path: path3 });
+        return;
+      } else if (segment === "$") {
+        node = node.dynamic ?? (node.dynamic = {
+          key: ""
+        });
+      } else {
+        node.static ?? (node.static = /* @__PURE__ */ new Map());
+        let next = node.static.get(segment);
+        if (!next) {
+          next = {
+            key: segment
+          };
+          node.static.set(segment, next);
+        }
+        node = next;
+      }
+    }
+    node.path ?? (node.path = path3);
+    node.route ?? (node.route = route);
+  }
+  for (const route of routes) {
+    for (const path3 of route.paths) {
+      insert(path3, route);
+    }
+  }
+  return root;
+}
 
 // src/vite/utils/ast.ts
 import * as t from "@babel/types";
@@ -1188,31 +1489,33 @@ function logRoutesTable(routes, bundle) {
     colAligns,
     style: { compact: true }
   });
-  for (const route of routes.list.sort((a, b) => b.score - a.score)) {
-    const verbs = getVerbs(route).sort(
-      (a, b) => HttpVerbOrder[a] - HttpVerbOrder[b]
-    );
-    let firstRow = true;
-    for (const verb of verbs) {
-      let size = "";
-      const entryType = [];
-      if (route.handler) {
-        entryType.push(kleur.blue("handler"));
-      }
-      if (verb === "get" && route.page) {
-        entryType.push(kleur.yellow("page"));
-        size = prettySize(computeRouteSize(route, bundle));
-      }
-      const row = [kleur.bold(HttpVerbColors[verb](verb.toUpperCase()))];
-      if (verbs.length === 1 || firstRow) {
-        row.push({ rowSpan: verbs.length, content: prettyPath(route.path) });
-        firstRow = false;
+  for (const route of routes.list) {
+    for (const path3 of route.paths) {
+      const verbs = getVerbs(route).sort(
+        (a, b) => HttpVerbOrder[a] - HttpVerbOrder[b]
+      );
+      let firstRow = true;
+      for (const verb of verbs) {
+        let size = "";
+        const entryType = [];
+        if (route.handler) {
+          entryType.push(kleur.blue("handler"));
+        }
+        if (verb === "get" && route.page) {
+          entryType.push(kleur.yellow("page"));
+          size = prettySize(computeRouteSize(route, bundle));
+        }
+        const row = [kleur.bold(HttpVerbColors[verb](verb.toUpperCase()))];
+        if (verbs.length === 1 || firstRow) {
+          row.push({ rowSpan: verbs.length, content: prettyPath(path3.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);
       }
-      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()) {
@@ -1354,24 +1657,18 @@ function markoRun(opts = {}) {
       }
       if (route.page) {
         virtualFiles.set(
-          path2.posix.join(
-            root,
-            `${markoRunFilePrefix}route__${route.key}.marko`
-          ),
+          path2.posix.join(root, `${route.entryName}.marko`),
           render ? renderRouteTemplate(route) : ""
         );
       }
       virtualFiles.set(
-        path2.posix.join(root, `${markoRunFilePrefix}route__${route.key}.js`),
+        path2.posix.join(root, `${route.entryName}.js`),
         render ? renderRouteEntry(route) : ""
       );
     }
     for (const route of Object.values(routes.special)) {
       virtualFiles.set(
-        path2.posix.join(
-          root,
-          `${markoRunFilePrefix}special__${route.key}.marko`
-        ),
+        path2.posix.join(root, `${route.entryName}.marko`),
         render ? renderRouteTemplate(route) : ""
       );
     }
@@ -1771,10 +2068,10 @@ async function resolveAdapter(root, options, log) {
   log && console.log("Using default adapter");
   return module.default();
 }
-var markoEntryFileRegex = /__marko-run__([^_]+)__(.+)\.marko.([^.]+)$/;
+var markoEntryFileRegex = /__marko-run__([^.]+)\.(.+)\.marko\.([^.]+)$/;
 function getEntryFileName(file) {
   const match = file && markoEntryFileRegex.exec(file);
-  return match ? `${match[2].replace(/__/g, "-")}` : void 0;
+  return match ? match[2] : void 0;
 }
 
 // src/vite/utils/server.ts