@marko/run 0.5.12 → 0.5.14

package/dist/vite/index.cjs

@@ -55,14 +55,44 @@ var import_url = require("url");
 var __importMetaURL = (0, import_url.pathToFileURL)(__filename);
 
 // src/vite/plugin.ts
-var import_path3 = __toESM(require("path"), 1);
+var import_vite = __toESM(require("@marko/vite"), 1);
+var import_browserslist = __toESM(require("browserslist"), 1);
+var import_crypto = require("crypto");
+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_glob = require("glob");
+var import_path4 = __toESM(require("path"), 1);
 var import_url2 = require("url");
-var import_browserslist = __toESM(require("browserslist"), 1);
-var import_esbuild_plugin_browserslist = require("esbuild-plugin-browserslist");
-var import_vite = require("vite");
-var import_vite2 = __toESM(require("@marko/vite"), 1);
+var import_vite2 = require("vite");
+
+// src/adapter/utils.ts
+var import_kleur = __toESM(require("kleur"), 1);
+var import_supports_color = __toESM(require("supports-color"), 1);
+function stripAnsi(string) {
+  return string.replace(
+    /([\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><])/g,
+    ""
+  );
+}
+function cleanStack(stack) {
+  return stack.split(/\n/).filter((l) => /^\s*at/.test(l)).join("\n");
+}
+function prepareError(err) {
+  var _a;
+  return {
+    message: stripAnsi(err.message),
+    stack: stripAnsi(cleanStack(err.stack || "")),
+    id: err.id,
+    frame: stripAnsi(err.frame || ""),
+    plugin: err.plugin,
+    pluginCode: (_a = err.pluginCode) == null ? void 0 : _a.toString(),
+    loc: err.loc
+  };
+}
+
+// src/vite/codegen/index.ts
+var import_path = __toESM(require("path"), 1);
 
 // src/vite/constants.ts
 var markoRunFilePrefix = "__marko-run__";
@@ -79,1393 +109,1398 @@ var RoutableFileTypes = {
   Error: "500"
 };
 
-// src/vite/routes/vdir.ts
-var _dirs, _pathlessDirs;
-var _VDir = class _VDir {
-  constructor(parent, segment, source) {
-    __privateAdd(this, _dirs);
-    __privateAdd(this, _pathlessDirs);
-    __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;
+// src/vite/utils/route.ts
+function getVerbs(route) {
+  var _a, _b;
+  const verbs = ((_b = (_a = route.handler) == null ? void 0 : _a.verbs) == null ? void 0 : _b.slice()) || [];
+  if (route.page && !verbs.includes("get")) {
+    verbs.unshift("get");
   }
-  addDir(path4, 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, path4);
-      map.set(segment.name, dir);
-      return dir;
+  return verbs;
+}
+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));
+}
+
+// src/vite/codegen/writer.ts
+function createWriter(sink, options) {
+  let buffer = "";
+  let indentLevel = 0;
+  let indentString = "";
+  let firstOpenIndex = 0;
+  const branches = [];
+  const openWriters = /* @__PURE__ */ new Map();
+  function write(data) {
+    if (!writer.__isActive) {
+      throw new Error("Cannot write to branch that has been joined");
     }
-    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);
+    if (openWriters.size) {
+      buffer += data;
     } 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.importPath}' collides with '${existing.importPath}'.`
-        );
-      } 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}`
-        );
-      }
-      throw new Error(
-        `Ambiguous path definition: file '${this.path}' is included multiple times by ${file.importPath}`
-      );
-    }
-  }
-  *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;
+      sink(data);
     }
-    yield this;
+    return writer;
   }
-  static addPaths(roots, paths) {
-    const dirs = [];
-    const unique = /* @__PURE__ */ new Set();
-    for (const root of roots) {
-      for (const path4 of paths) {
-        let dir = root;
-        for (const segment of path4.segments) {
-          dir = dir.addDir(path4, segment);
+  const writer = {
+    __isActive: true,
+    get indent() {
+      return indentLevel;
+    },
+    set indent(value) {
+      if (options == null ? void 0 : options.indentWith) {
+        if (value < 0) {
+          value = 0;
         }
-        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}${path4.source}' defines '${dir.path}' multiple times.`
-          );
-        } else {
-          unique.add(dir.path);
-          dirs.push(dir);
+        if (value !== indentLevel) {
+          indentLevel = value;
+          indentString = options.indentWith.repeat(indentLevel);
         }
       }
-    }
-    return dirs;
-  }
-};
-_dirs = new WeakMap();
-_pathlessDirs = new WeakMap();
-var VDir = _VDir;
-
-// 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((path4) => ({
-              ...path4,
-              segments: path4.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);
+    },
+    write(data, indent = false) {
+      if (indent && indentString) {
+        write(indentString);
+      }
+      return write(data);
+    },
+    writeLines(...lines) {
+      for (const line of lines) {
+        if (line) {
+          writer.write(line, true);
         }
-        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((path4) => ({
-          ...path4,
-          segments: path4.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((path4) => ({
-          ...path4,
-          segments: path4.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);
+        writer.write("\n");
       }
-    }
-    for (const path4 of paths) {
-      if (segment) {
-        if (path4.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}'.`
-          );
-        }
-        path4.segments.push(segment);
-        path4.id += path4.id === "/" ? segment.name : `/${segment.name}`;
-        if (type === "$$") {
-          path4.isCatchall = true;
-        }
+      return writer;
+    },
+    writeBlockStart(data) {
+      writer.writeLines(data).indent++;
+      return writer;
+    },
+    writeBlockEnd(data = "}") {
+      writer.indent--;
+      writer.writeLines(data);
+      return writer;
+    },
+    writeBlock(start, lines, end) {
+      return writer.writeBlockStart(start).writeLines(...lines).writeBlockEnd(end);
+    },
+    branch(name) {
+      const existing = openWriters.get(name);
+      if (existing) {
+        return existing;
       }
-      if (map) {
-        if (map.has(path4.id)) {
-          const existing = map.get(path4.id);
-          const existingExpansion = existing.segments.map((s) => s.raw).join(".");
-          const currentExpansion = path4.segments.map((s) => s.raw).join(".");
-          throw new Error(
-            `Invalid route pattern: route '${path4.id}' is ambiguous. Expansion '${currentExpansion}' collides with '${existingExpansion}' in '${pattern}'.`
-          );
+      const branch = {
+        buffer,
+        writer: createWriter(
+          (data) => {
+            branch.buffer += data;
+          },
+          {
+            ...options,
+            onJoin() {
+              openWriters.delete(name);
+              for (let i = firstOpenIndex; i < branches.length; i++) {
+                const b = branches[i];
+                if (!b) {
+                  continue;
+                } else if (b.writer.__isActive) {
+                  break;
+                }
+                sink(b.buffer);
+                branches[i] = null;
+                firstOpenIndex++;
+              }
+              if (!openWriters.size) {
+                sink(buffer);
+                buffer = "";
+              }
+            }
+          }
+        )
+      };
+      branch.writer.indent = indentLevel;
+      openWriters.set(name, branch.writer);
+      branches.push(branch);
+      buffer = "";
+      return branch.writer;
+    },
+    join(recursive) {
+      var _a;
+      if (writer.__isActive) {
+        if (openWriters.size) {
+          if (recursive) {
+            for (const branch of openWriters.values()) {
+              branch.join(true);
+            }
+          } else {
+            throw new Error(
+              `Cannot join a Writer with un-joined branches - use the \`recursive\` argument to join all open branches`
+            );
+          }
         }
-        map.set(path4.id, path4);
+        buffer && sink(buffer);
+        writer.__isActive = false;
+        (_a = options == null ? void 0 : options.onJoin) == null ? void 0 : _a.call(options, writer);
       }
     }
-  }
+  };
+  return writer;
+}
+function createStringWriter(opts) {
+  let code = "";
+  const writer = createWriter(
+    (data) => {
+      code += data;
+    },
+    { indentWith: "	", ...opts }
+  );
+  return Object.assign(writer, {
+    end() {
+      writer.join(true);
+      return code;
+    }
+  });
 }
 
-// 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})$`,
-  "i"
-);
-function matchRoutableFile(filename) {
-  const match = filename.match(routeableFileRegex);
-  return match && (match[1] || match[3]).toLowerCase();
+// src/vite/codegen/index.ts
+function renderRouteTemplate(route, getRelativePath) {
+  if (!route.page) {
+    throw new Error(`Route ${route.key} has no page to render`);
+  }
+  return renderEntryTemplate(
+    route.entryName,
+    [...route.layouts, route.page].map(
+      (file) => getRelativePath(file.importPath)
+    ),
+    route.key === RoutableFileTypes.Error ? ["error"] : []
+  );
 }
-function isSpecialType(type) {
-  return type === RoutableFileTypes.NotFound || type === RoutableFileTypes.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.branch("imports");
+  writer.writeLines("");
+  writeEntryTemplateTag(writer, files, pageInputs);
+  return writer.end();
 }
-async function buildRoutes(sources) {
-  const uniqueRoutes = /* @__PURE__ */ new Map();
-  const routes = [];
-  const special = {};
-  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 basePath;
-  let importPrefix;
-  let activeDirs;
-  let isBaseDir;
-  let nextFileId = 1;
-  let nextRouteIndex = 1;
-  const walkOptions = {
-    onEnter({ name }) {
-      const prevDirStackLength = dirStack.length;
-      if (isBaseDir) {
-        isBaseDir = false;
-        if (!basePath) {
-          return;
-        }
-        name = basePath;
-      } else {
-        dirStack.push(name);
-      }
-      const previousDirs = activeDirs;
-      const paths = parseFlatRoute(name);
-      activeDirs = VDir.addPaths(previousDirs, paths);
-      return () => {
-        activeDirs = previousDirs;
-        dirStack.length = prevDirStackLength;
-      };
-    },
-    onFile({ name, path: path4 }) {
-      const match = name.match(routeableFileRegex);
-      if (!match) {
-        return;
-      }
-      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 ${path4}`
-        );
-        return;
-      }
-      let dirs = activeDirs;
-      if (match.index) {
-        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 = {
-        id: String(nextFileId++),
-        name,
-        type,
-        filePath: path4,
-        relativePath,
-        importPath: `${importPrefix}/${relativePath}`,
-        verbs: type === RoutableFileTypes.Page ? ["get"] : void 0
-      };
-      for (const dir of dirs) {
-        dir.addFile(file);
-      }
+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}';`);
+    if (isLast) {
+      const attributes = pageInputs.length ? " " + pageInputs.map((name) => `${name}=input.${name}`).join(" ") : "";
+      writer.writeLines(`<${tag}${attributes}/>`);
+    } else {
+      writer.writeBlockStart(`<${tag}>`);
+      writeEntryTemplateTag(writer, rest, pageInputs, index + 1);
+      writer.writeBlockEnd(`</>`);
     }
-  };
-  if (!Array.isArray(sources)) {
-    sources = [sources];
   }
-  for (const source of sources) {
-    importPrefix = source.importPrefix ? source.importPrefix.replace(/^\/+|\/+$/g, "") : "";
-    basePath = source.basePath || "";
-    activeDirs = [root];
-    isBaseDir = true;
-    await source.walker(walkOptions);
+}
+function renderRouteEntry(route, entriesDir) {
+  var _a;
+  const { key, index, handler, page, middleware, meta, entryName } = route;
+  const verbs = getVerbs(route);
+  if (!verbs) {
+    throw new Error(
+      `Route ${key} doesn't have a handler or page for any HTTP verbs`
+    );
   }
-  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 (layout) {
-        if (currentLayouts.has(layout)) {
-          layout = void 0;
-        } else {
-          currentLayouts.add(layout);
-          unusedFiles.add(layout);
-        }
-      }
-      if (page || handler) {
-        const path4 = dir.pathInfo;
-        if (uniqueRoutes.has(path4.id)) {
-          const existing = uniqueRoutes.get(path4.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 '${path4.path}' were defined. A route established by:
-      ${existingFiles.join(" and ")} via '${existing.dir.path}'
-        collides with
-      ${currentFiles.join(" and ")} via '${dir.path}'
-      `);
-        }
-        uniqueRoutes.set(path4.id, { dir, index: routes.length });
-        routes.push({
-          index: nextRouteIndex++,
-          key: dir.fullPath,
-          paths: [path4],
-          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 (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) {
-        for (const middleware2 of currentMiddleware) {
-          middlewares.add(middleware2);
-          unusedFiles.delete(middleware2);
-        }
-      }
-      if (page || hasSpecial) {
-        for (const layout2 of currentLayouts) {
-          unusedFiles.delete(layout2);
-        }
-      }
+  const writer = createStringWriter();
+  writer.writeLines(`// ${virtualFilePrefix}/${entryName}.js`);
+  const imports = writer.branch("imports");
+  const runtimeImports = [];
+  if (handler) {
+    runtimeImports.push("normalize");
+  }
+  if (handler || middleware.length) {
+    runtimeImports.push("call");
+  }
+  if (!page || verbs.length > 1) {
+    runtimeImports.push("noContent");
+  }
+  if (page) {
+    runtimeImports.push("pageResponse");
+  }
+  if (runtimeImports.length) {
+    imports.writeLines(
+      `import { ${runtimeImports.join(
+        ", "
+      )} } from '${virtualFilePrefix}/runtime/internal';`
+    );
+  }
+  if (middleware.length) {
+    const names = middleware.map((m) => `mware${m.id}`);
+    imports.writeLines(
+      `import { ${names.join(
+        ", "
+      )} } from '${virtualFilePrefix}/${markoRunFilePrefix}middleware.js';`
+    );
+  }
+  if ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.length) {
+    writer.writeLines("");
+    const names = [];
+    for (const verb of handler.verbs) {
+      const importName = verb.toUpperCase();
+      names.push(importName);
+      writer.writeLines(`const ${verb}Handler = normalize(${importName});`);
     }
-    if (dir.dirs) {
-      for (const child of dir.dirs()) {
-        traverse(child);
+    imports.writeLines(
+      `import { ${names.join(", ")} } from './${handler.importPath}';`
+    );
+  }
+  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}';`);
+  }
+  if (meta) {
+    imports.writeLines(
+      `export { default as meta${index} } from './${meta.importPath}';`
+    );
+  }
+  for (const verb of verbs) {
+    writeRouteEntryHandler(writer, route, verb);
+  }
+  return writer.end();
+}
+function writePageResponse(writer, wrapFn) {
+  writer.writeLines(
+    `${wrapFn ? `const ${wrapFn} = () =>` : `return`} pageResponse(page, buildInput());`
+  );
+}
+function writeMiddleware(writer, middleware, next, wrapFn) {
+  if (wrapFn) {
+    writer.writeLines(
+      `const ${wrapFn} = () => call(${middleware}, ${next}, context);`
+    );
+  } else {
+    writer.writeLines(`return call(${middleware}, ${next}, context);`);
+  }
+}
+function writeRouteEntryHandler(writer, route, verb) {
+  var _a;
+  const { key, index, page, handler, middleware } = route;
+  const len = middleware.length;
+  let nextName;
+  let currentName;
+  let hasBody = false;
+  writer.writeLines("");
+  if (page) {
+    writer.writeBlockStart(
+      `export async function ${verb}${index}(context, buildInput) {`
+    );
+  } else {
+    writer.writeBlockStart(`export async function ${verb}${index}(context) {`);
+  }
+  const continuations = writer.branch("cont");
+  if (page && verb === "get") {
+    currentName = "__page";
+    if ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.includes(verb)) {
+      const name = `${verb}Handler`;
+      writePageResponse(continuations, currentName);
+      if (len) {
+        nextName = currentName;
+        currentName = `__${name}`;
+        writeMiddleware(continuations, name, nextName, currentName);
+      } else {
+        writeMiddleware(writer, name, currentName);
+        hasBody = true;
       }
+    } else if (len) {
+      writePageResponse(continuations, currentName);
+      nextName = currentName;
+    } else {
+      writePageResponse(continuations);
+      hasBody = true;
     }
-    if (middleware) {
-      currentMiddleware.delete(middleware);
+  } else if (handler) {
+    const name = `${verb}Handler`;
+    currentName = `__${name}`;
+    nextName = "noContent";
+    if (len) {
+      writeMiddleware(continuations, name, nextName, currentName);
+    } else {
+      writeMiddleware(writer, name, nextName);
+      hasBody = true;
     }
-    if (layout) {
-      currentLayouts.delete(layout);
+  } else {
+    throw new Error(`Route ${key} has no handler for ${verb} requests`);
+  }
+  if (!hasBody) {
+    let i = len;
+    while (i--) {
+      const { id } = middleware[i];
+      const name = `mware${id}`;
+      nextName = currentName;
+      currentName = i ? `__${name}` : "";
+      writeMiddleware(continuations, name, nextName, currentName);
     }
   }
+  continuations.join();
+  writer.writeBlockEnd("}");
 }
-
-// src/vite/routes/walk.ts
-var import_fs = __toESM(require("fs"), 1);
-var import_path = __toESM(require("path"), 1);
-function createFSWalker(dir) {
-  return async function walkFS({
-    onEnter,
-    onFile,
-    onDir,
-    maxDepth = 50
-  }) {
-    async function walk(dir2, depth) {
-      const onExit = onEnter == null ? void 0 : onEnter(dir2);
-      if (onExit !== false) {
-        const dirs = [];
-        const entries = await import_fs.default.promises.readdir(dir2.path, {
-          withFileTypes: true
-        });
-        const prefix = dir2.path + import_path.default.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);
-          }
-        }
-        if ((onDir == null ? void 0 : onDir()) !== false && --depth > 0) {
-          for (const entry of dirs) {
-            await walk(entry, depth);
-          }
-        }
-        onExit == null ? void 0 : onExit();
-      }
+function renderRouter(routes, entriesDir, options = {
+  trailingSlashes: "RedirectWithout"
+}) {
+  const writer = createStringWriter();
+  writer.writeLines(`// @marko/run/router`);
+  const imports = writer.branch("imports");
+  imports.writeLines(
+    `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';`
+    );
+  }
+  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}';`
+    );
+  }
+  writer.writeLines(
+    `
+globalThis.__marko_run__ = { match, fetch, invoke };
+    `
+  ).writeBlockStart(`export function match(method, pathname) {`).writeLines(
+    `if (!pathname) {
+    pathname = '/';
+  } else if (pathname.charAt(0) !== '/') {
+    pathname = '/' + pathname;
+  }`
+  ).writeBlockStart(`switch (method) {`);
+  for (const verb of httpVerbs) {
+    const filteredRoutes = routes.list.filter((route) => hasVerb(route, verb));
+    if (filteredRoutes.length) {
+      const trie = createRouteTrie(filteredRoutes);
+      writer.writeLines(`case '${verb.toUpperCase()}':`);
+      writer.writeBlockStart(`case '${verb.toLowerCase()}': {`);
+      writeRouterVerb(writer, trie, verb);
+      writer.writeBlockEnd("}");
     }
-    await walk(
-      {
-        path: dir,
-        name: import_path.default.basename(dir)
-      },
-      maxDepth
+  }
+  writer.writeBlockEnd("}").writeLines("return null;").writeBlockEnd("}");
+  writer.writeLines("").writeBlockStart(
+    "export async function invoke(route, request, platform, url) {"
+  ).writeLines(
+    "const [context, buildInput] = createContext(route, request, platform, url);"
+  );
+  const hasErrorPage = Boolean(routes.special[RoutableFileTypes.Error]);
+  if (hasErrorPage) {
+    writer.writeBlockStart("try {");
+  }
+  writer.writeBlockStart("if (route) {").writeBlockStart("try {").writeLines(
+    "const response = await route.handler(context, buildInput);",
+    "if (response) return response;"
+  ).indent--;
+  writer.writeBlockStart("} catch (error) {").writeLines(
+    "if (error === NotHandled) return;",
+    "if (error !== NotMatched) throw error;"
+  ).writeBlockEnd("}").writeBlockEnd("}");
+  if (routes.special[RoutableFileTypes.NotFound]) {
+    imports.writeLines(
+      `
+const page404ResponseInit = {
+  status: 404,
+  headers: { "content-type": "text/html;charset=UTF-8" },
+};`
     );
-  };
+    writer.write(`    
+    if (context.request.headers.get('Accept')?.includes('text/html')) {
+      return new Response(page404.stream(buildInput()), page404ResponseInit);
+    }
+`);
+  }
+  writer.indent--;
+  if (hasErrorPage) {
+    imports.writeLines(`
+const page500ResponseInit = {
+  status: 500,
+  headers: { "content-type": "text/html;charset=UTF-8" },
+};`);
+    writer.writeBlockStart(`} catch (error) {`).writeBlockStart(
+      `if (context.request.headers.get('Accept')?.includes('text/html')) {`
+    ).writeLines(
+      `return new Response(page500.stream(buildInput({ error })), page500ResponseInit);`
+    ).writeBlockEnd("}").writeLines("throw error;").writeBlockEnd("}");
+  }
+  writer.writeBlockEnd("}");
+  renderFetch(writer, options);
+  return writer.end();
 }
+function renderFetch(writer, options) {
+  writer.write(`
+export async function fetch(request, platform) {
+  try {
+    const url = new URL(request.url);
+    let { pathname } = url;`);
+  switch (options.trailingSlashes) {
+    case "RedirectWithout":
+      writer.write(`
+    if (pathname !== '/' && pathname.endsWith('/')) {
+      url.pathname = pathname.slice(0, -1);
+      return Response.redirect(url);
+    }`);
+      break;
+    case "RedirectWith":
+      writer.write(`
+    if (pathname !== '/' && !pathname.endsWith('/')) {
+      url.pathname = pathname + '/';
+      return Response.redirect(url);
+    }`);
+      break;
+    case "RewriteWithout":
+      writer.write(`
+    if (pathname !== '/' && pathname.endsWith('/')) {
+      url.pathname = pathname = pathname.slice(0, -1);
+    }`);
+      break;
+    case "RewriteWith":
+      writer.write(`
+    if (pathname !== '/' && !pathname.endsWith('/')) {
+      url.pathname = pathname = pathname + '/';
+    }`);
+      break;
+  }
+  writer.write(`   
 
-// src/vite/codegen/writer.ts
-function createWriter(sink, options) {
-  let buffer = "";
-  let indentLevel = 0;
-  let indentString = "";
-  let firstOpenIndex = 0;
-  const branches = [];
-  const openWriters = /* @__PURE__ */ new Map();
-  function write(data) {
-    if (!writer.__isActive) {
-      throw new Error("Cannot write to branch that has been joined");
+    const route = match(request.method, pathname);
+    return await invoke(route, request, platform, url);
+  } catch (error) {
+    if (import.meta.env.DEV) {
+      throw error;
     }
-    if (openWriters.size) {
-      buffer += data;
-    } else {
-      sink(data);
+    return new Response(null, {
+      status: 500
+    });
+  }
+}`);
+}
+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}`
+      );
+    } else if (trie.static || dynamic) {
+      writer.writeBlockStart(`if (len > 1) {`);
+      closeCount++;
     }
-    return writer;
   }
-  const writer = {
-    __isActive: true,
-    get indent() {
-      return indentLevel;
-    },
-    set indent(value) {
-      if (options == null ? void 0 : options.indentWith) {
-        if (value < 0) {
-          value = 0;
+  if (trie.static || dynamic) {
+    const next = level + 1;
+    const index = `i${next}`;
+    let terminal;
+    let children;
+    writer.writeLines(`const ${index} = pathname.indexOf('/', ${offset}) + 1;`);
+    if (trie.static) {
+      for (const child of trie.static.values()) {
+        if (child.route) {
+          (terminal ?? (terminal = [])).push(child);
         }
-        if (value !== indentLevel) {
-          indentLevel = value;
-          indentString = options.indentWith.repeat(indentLevel);
+        if (child.static || child.dynamic || child.catchAll) {
+          (children ?? (children = [])).push(child);
         }
       }
-    },
-    write(data, indent = false) {
-      if (indent && indentString) {
-        write(indentString);
+    }
+    if (terminal || (dynamic == null ? void 0 : dynamic.route)) {
+      closeCount++;
+      writer.writeBlockStart(`if (!${index} || ${index} === len) {`);
+      let value = `pathname.slice(${offset}, ${index} ? -1 : len)`;
+      if (dynamic == null ? void 0 : dynamic.route) {
+        const segment = `s${next}`;
+        writer.writeLines(`const ${segment} = decodeURIComponent(${value});`);
+        value = segment;
+      } else if (terminal == null ? void 0 : terminal.some(
+        (terminal2) => decodeURIComponent(terminal2.key) !== terminal2.key
+      )) {
+        value = `decodeURIComponent(${value})`;
       }
-      return write(data);
-    },
-    writeLines(...lines) {
-      for (const line of lines) {
-        if (line) {
-          writer.write(line, true);
+      if (terminal) {
+        const useSwitch = terminal.length > 1;
+        if (useSwitch) {
+          writer.writeBlockStart(`switch (${value}) {`);
+        }
+        for (const { key, path: path5, 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}
+`
+          );
+        }
+        if (useSwitch) {
+          writer.writeBlockEnd("}");
         }
-        writer.write("\n");
       }
-      return writer;
-    },
-    writeBlockStart(data) {
-      writer.writeLines(data).indent++;
-      return writer;
-    },
-    writeBlockEnd(data = "}") {
-      writer.indent--;
-      writer.writeLines(data);
-      return writer;
-    },
-    writeBlock(start, lines, end) {
-      return writer.writeBlockStart(start).writeLines(...lines).writeBlockEnd(end);
-    },
-    branch(name) {
-      let existing = openWriters.get(name);
-      if (existing) {
-        return existing;
+      if (dynamic == null ? void 0 : dynamic.route) {
+        writer.writeLines(
+          `if (${value}) return ${renderMatch(
+            verb,
+            dynamic.route,
+            dynamic.path
+          )}; // ${dynamic.path.path}`
+        );
       }
-      const branch = {
-        buffer,
-        writer: createWriter(
-          (data) => {
-            branch.buffer += data;
-          },
-          {
-            ...options,
-            onJoin() {
-              openWriters.delete(name);
-              for (let i = firstOpenIndex; i < branches.length; i++) {
-                const b = branches[i];
-                if (!b) {
-                  continue;
-                } else if (b.writer.__isActive) {
-                  break;
-                }
-                sink(b.buffer);
-                branches[i] = null;
-                firstOpenIndex++;
-              }
-              if (!openWriters.size) {
-                sink(buffer);
-                buffer = "";
-              }
-            }
+    }
+    if (children || (dynamic == null ? void 0 : dynamic.static) || (dynamic == null ? void 0 : dynamic.dynamic) || (dynamic == null ? void 0 : dynamic.catchAll)) {
+      if (terminal || (dynamic == null ? void 0 : dynamic.route)) {
+        writer.writeBlockEnd("} else {").indent++;
+      } else {
+        writer.writeBlockStart(`if (${index} && ${index} !== len) {`);
+        closeCount++;
+      }
+      let value = `pathname.slice(${offset}, ${index} - 1)`;
+      if ((dynamic == null ? void 0 : dynamic.static) || (dynamic == null ? void 0 : dynamic.dynamic) || (dynamic == null ? void 0 : dynamic.catchAll)) {
+        const segment = `s${next}`;
+        writer.writeLines(`const ${segment} = decodeURIComponent(${value});`);
+        value = segment;
+      } else if (children == null ? void 0 : children.some((child) => decodeURIComponent(child.key) !== child.key)) {
+        value = `decodeURIComponent(${value})`;
+      }
+      if (children) {
+        const useSwitch = children.length > 1;
+        if (useSwitch) {
+          writer.writeBlockStart(`switch (${value}) {`);
+        }
+        for (const child of children) {
+          const decodedKey = decodeURIComponent(child.key);
+          if (useSwitch) {
+            writer.writeBlockStart(`case '${decodedKey}': {`);
+          } else {
+            writer.writeBlockStart(`if (${value} === '${decodedKey}') {`);
           }
-        )
-      };
-      branch.writer.indent = indentLevel;
-      openWriters.set(name, branch.writer);
-      branches.push(branch);
-      buffer = "";
-      return branch.writer;
-    },
-    join(recursive) {
-      var _a;
-      if (writer.__isActive) {
-        if (openWriters.size) {
-          if (recursive) {
-            for (const branch of openWriters.values()) {
-              branch.join(true);
-            }
+          const nextOffset = typeof offset === "string" ? index : offset + child.key.length + 1;
+          writeRouterVerb(writer, child, verb, next, nextOffset);
+          if (useSwitch) {
+            writer.writeBlockEnd("} break;");
           } else {
-            throw new Error(
-              `Cannot join a Writer with un-joined branches - use the \`recursive\` argument to join all open branches`
-            );
+            writer.writeBlockEnd("}");
           }
         }
-        buffer && sink(buffer);
-        writer.__isActive = false;
-        (_a = options == null ? void 0 : options.onJoin) == null ? void 0 : _a.call(options, writer);
+        if (useSwitch) {
+          writer.writeBlockEnd("}");
+        }
       }
-    }
-  };
-  return writer;
-}
-function createStringWriter(opts) {
-  let code = "";
-  const writer = createWriter((data) => {
-    code += data;
-  }, { indentWith: "	", ...opts });
-  return Object.assign(writer, {
-    end() {
-      writer.join(true);
-      return code;
-    }
-  });
-}
-
-// src/vite/utils/route.ts
-function getVerbs(route) {
-  var _a, _b;
-  const verbs = ((_b = (_a = route.handler) == null ? void 0 : _a.verbs) == null ? void 0 : _b.slice()) || [];
-  if (route.page && !verbs.includes("get")) {
-    verbs.unshift("get");
-  }
-  return verbs;
-}
-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));
-}
-
-// src/vite/codegen/index.ts
-function renderRouteTemplate(route, getRelativePath) {
-  if (!route.page) {
-    throw new Error(`Route ${route.key} has no page to render`);
-  }
-  return renderEntryTemplate(
-    route.entryName,
-    [...route.layouts, route.page].map(
-      (file) => getRelativePath(file.importPath)
-    ),
-    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.branch("imports");
-  writer.writeLines("");
-  writeEntryTemplateTag(writer, files, pageInputs);
-  return writer.end();
-}
-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}';`);
-    if (isLast) {
-      const attributes = pageInputs.length ? " " + pageInputs.map((name) => `${name}=input.${name}`).join(" ") : "";
-      writer.writeLines(`<${tag}${attributes}/>`);
-    } else {
-      writer.writeBlockStart(`<${tag}>`);
-      writeEntryTemplateTag(writer, rest, pageInputs, index + 1);
-      writer.writeBlockEnd(`</>`);
-    }
-  }
-}
-function renderRouteEntry(route, entriesDir) {
-  var _a;
-  const { key, index, handler, page, middleware, meta, entryName } = route;
-  const verbs = getVerbs(route);
-  if (!verbs) {
-    throw new Error(
-      `Route ${key} doesn't have a handler or page for any HTTP verbs`
-    );
-  }
-  const writer = createStringWriter();
-  writer.writeLines(`// ${virtualFilePrefix}/${entryName}.js`);
-  const imports = writer.branch("imports");
-  const runtimeImports = [];
-  if (handler) {
-    runtimeImports.push("normalize");
-  }
-  if (handler || middleware.length) {
-    runtimeImports.push("call");
-  }
-  if (!page || verbs.length > 1) {
-    runtimeImports.push("noContent");
-  }
-  if (page) {
-    runtimeImports.push("pageResponse");
+      if ((dynamic == null ? void 0 : dynamic.static) || (dynamic == null ? void 0 : dynamic.dynamic) || (dynamic == null ? void 0 : dynamic.catchAll)) {
+        writer.writeBlockStart(`if (${value}) {`);
+        writeRouterVerb(writer, dynamic, verb, next, index);
+        writer.writeBlockEnd(`}`);
+      }
+    }
   }
-  if (runtimeImports.length) {
-    imports.writeLines(
-      `import { ${runtimeImports.join(
-        ", "
-      )} } from '${virtualFilePrefix}/runtime/internal';`
-    );
+  while (closeCount--) {
+    writer.writeBlockEnd("}");
   }
-  if (middleware.length) {
-    const names = middleware.map((m) => `mware${m.id}`);
-    imports.writeLines(
-      `import { ${names.join(
-        ", "
-      )} } from '${virtualFilePrefix}/${markoRunFilePrefix}middleware.js';`
+  if (catchAll) {
+    writer.writeLines(
+      `return ${renderMatch(
+        verb,
+        catchAll.route,
+        catchAll.path,
+        String(offset)
+      )}; // ${catchAll.path.path}`
     );
+  } else if (level === 0) {
+    writer.writeLines("return null;");
   }
-  if ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.length) {
-    writer.writeLines("");
-    const names = [];
-    for (const verb of handler.verbs) {
-      const importName = verb.toUpperCase();
-      names.push(importName);
-      writer.writeLines(`const ${verb}Handler = normalize(${importName});`);
+}
+function wrapPropertyName(name) {
+  name = decodeURIComponent(name);
+  return /^[^A-Za-z_$]|[^A-Za-z0-9$_]/.test(name) ? `'${name}'` : name;
+}
+function renderParams(params, pathIndex) {
+  let result = "";
+  let catchAll = "";
+  let sep = "{";
+  for (const [name, index] of Object.entries(params)) {
+    if (typeof index === "number") {
+      result += `${sep} ${wrapPropertyName(name)}: s${index + 1}`;
+      sep = ",";
+    } else if (pathIndex) {
+      catchAll = name;
     }
-    imports.writeLines(
-      `import { ${names.join(", ")} } from './${handler.importPath}';`
-    );
-  }
-  if (page) {
-    const importPath = route.layouts.length ? `./${entriesDir}/${entryName}.marko` : `./${page.importPath}`;
-    imports.writeLines(`import page from '${importPath}${serverEntryQuery}';`);
-  }
-  if (meta) {
-    imports.writeLines(
-      `export { default as meta${index} } from './${meta.importPath}';`
-    );
   }
-  for (const verb of verbs) {
-    writeRouteEntryHandler(writer, route, verb);
+  if (catchAll) {
+    result += `${sep} ${wrapPropertyName(
+      catchAll
+    )}: pathname.slice(${pathIndex})`;
   }
-  return writer.end();
+  return result ? result + " }" : "{}";
 }
-function writePageResponse(writer, wrapFn) {
+function renderMatch(verb, route, path5, pathIndex) {
+  const handler = `${verb}${route.index}`;
+  const params = path5.params ? renderParams(path5.params, pathIndex) : "{}";
+  const meta = route.meta ? `meta${route.index}` : "{}";
+  const pathPattern = pathToURLPatternString(path5.path);
+  return `{ handler: ${handler}, params: ${params}, meta: ${meta}, path: '${pathPattern}' }`;
+}
+function renderMiddleware(middleware) {
+  const writer = createStringWriter();
   writer.writeLines(
-    `${wrapFn ? `const ${wrapFn} = () =>` : `return`} pageResponse(page, buildInput());`
+    `// ${virtualFilePrefix}/${markoRunFilePrefix}middleware.js`
+  );
+  const imports = writer.branch("imports");
+  imports.writeLines(
+    `import { normalize } from '${virtualFilePrefix}/runtime/internal';`
   );
-}
-function writeMiddleware(writer, middleware, next, wrapFn) {
-  if (wrapFn) {
-    writer.writeLines(
-      `const ${wrapFn} = () => call(${middleware}, ${next}, context);`
-    );
-  } else {
-    writer.writeLines(`return call(${middleware}, ${next}, context);`);
-  }
-}
-function writeRouteEntryHandler(writer, route, verb) {
-  var _a;
-  const { key, index, page, handler, middleware } = route;
-  const len = middleware.length;
-  let nextName;
-  let currentName;
-  let hasBody = false;
   writer.writeLines("");
-  if (page) {
-    writer.writeBlockStart(
-      `export async function ${verb}${index}(context, buildInput) {`
-    );
-  } else {
-    writer.writeBlockStart(`export async function ${verb}${index}(context) {`);
-  }
-  const continuations = writer.branch("cont");
-  if (page && verb === "get") {
-    currentName = "__page";
-    if ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.includes(verb)) {
-      const name = `${verb}Handler`;
-      writePageResponse(continuations, currentName);
-      if (len) {
-        nextName = currentName;
-        currentName = `__${name}`;
-        writeMiddleware(continuations, name, nextName, currentName);
-      } else {
-        writeMiddleware(writer, name, currentName);
-        hasBody = true;
-      }
-    } else if (len) {
-      writePageResponse(continuations, currentName);
-      nextName = currentName;
-    } else {
-      writePageResponse(continuations);
-      hasBody = true;
-    }
-  } else if (handler) {
-    const name = `${verb}Handler`;
-    currentName = `__${name}`;
-    nextName = "noContent";
-    if (len) {
-      writeMiddleware(continuations, name, nextName, currentName);
-    } else {
-      writeMiddleware(writer, name, nextName);
-      hasBody = true;
-    }
-  } else {
-    throw new Error(`Route ${key} has no handler for ${verb} requests`);
+  for (const { id, importPath } of middleware) {
+    const importName = `middleware${id}`;
+    imports.writeLines(`import ${importName} from './${importPath}';`);
+    writer.writeLines(`export const mware${id} = normalize(${importName});`);
   }
-  if (!hasBody) {
-    let i = len;
-    while (i--) {
-      const { id } = middleware[i];
-      const name = `mware${id}`;
-      nextName = currentName;
-      currentName = i ? `__${name}` : "";
-      writeMiddleware(continuations, name, nextName, currentName);
+  imports.join();
+  return writer.end();
+}
+function stripTsExtension(path5) {
+  const index = path5.lastIndexOf(".");
+  if (index !== -1) {
+    const ext = path5.slice(index + 1);
+    if (ext.toLowerCase() === "ts") {
+      return path5.slice(0, index);
     }
   }
-  continuations.join();
-  writer.writeBlockEnd("}");
+  return path5;
 }
-function renderRouter(routes, entriesDir, options = {
-  trailingSlashes: "RedirectWithout"
-}) {
+async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
+  var _a, _b;
   const writer = createStringWriter();
-  writer.writeLines(`// @marko/run/router`);
-  const imports = writer.branch("imports");
-  imports.writeLines(
-    `import { NotHandled, NotMatched, createContext } from '${virtualFilePrefix}/runtime/internal';`
+  writer.writeLines(
+    `/*
+  WARNING: This file is automatically generated and any changes made to it will be overwritten without warning.
+  Do NOT manually edit this file or your changes will be lost.
+*/
+`,
+    `import { NotHandled, NotMatched, GetPaths, PostPaths, GetablePath, GetableHref, PostablePath, PostableHref, Platform } from "@marko/run/namespace";`,
+    `import type * as Run from "@marko/run";`
   );
-  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';`
+  const headWriter = writer.branch("head");
+  writer.writeLines("\n").writeBlockStart(`declare module "@marko/run" {`);
+  if (adapter && adapter.typeInfo) {
+    const platformType = await adapter.typeInfo(
+      (data) => headWriter.write(data)
     );
+    if (platformType) {
+      writer.writeLines(`interface Platform extends ${platformType} {}
+`);
+    }
   }
-  for (const route of Object.values(routes.special)) {
-    const importPath = route.layouts.length ? `./${entriesDir}/${route.entryName}.marko` : `./${route.page.importPath}`;
-    imports.writeLines(
-      `import page${route.key} from '${importPath}${serverEntryQuery}';`
-    );
+  headWriter.join();
+  writer.writeBlockStart(`interface AppData extends Run.DefineApp<{`).writeBlockStart("routes: {");
+  const routesWriter = writer.branch("routes");
+  writer.writeBlockEnd("}").writeBlockEnd(`}> {}`).writeBlockEnd(`}`);
+  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}"];`);
+    }
+    for (const file of [route.handler, route.page]) {
+      if (file) {
+        const existing = routeTypes.get(file);
+        if (!existing) {
+          routeTypes.set(file, [routeType]);
+        } else {
+          existing.push(routeType);
+        }
+      }
+    }
+    for (const files of [route.middleware, route.layouts]) {
+      if (files) {
+        for (const file of files) {
+          const existing = routeTypes.get(file);
+          if (!existing) {
+            routeTypes.set(file, [routeType]);
+          } else {
+            existing.push(routeType);
+          }
+        }
+      }
+    }
   }
-  writer.writeLines(
-    `
-globalThis.__marko_run__ = { match, fetch, invoke };
-    `
-  ).writeBlockStart(`export function match(method, pathname) {`).writeLines(
-    `if (!pathname) {
-    pathname = '/';
-  } else if (pathname.charAt(0) !== '/') {
-    pathname = '/' + pathname;
+  for (const special of Object.values(routes.special)) {
+    routeTypes.set(special.page, []);
+  }
+  routesWriter.join();
+  const handlerWriter = writer.branch("handler");
+  const middlewareWriter = writer.branch("middleware");
+  const pageWriter = writer.branch("page");
+  const layoutWriter = writer.branch("layout");
+  for (const [file, types] of routeTypes) {
+    const path5 = `${pathPrefix}/${file.relativePath}`;
+    const routeType = `Run.Routes[${types.join(" | ")}]`;
+    switch (file.type) {
+      case RoutableFileTypes.Handler:
+        writeModuleDeclaration(handlerWriter, path5, routeType);
+        break;
+      case RoutableFileTypes.Middleware:
+        writeModuleDeclaration(middlewareWriter, path5, routeType);
+        break;
+      case RoutableFileTypes.Page:
+        writeModuleDeclaration(pageWriter, path5, routeType);
+        break;
+      case RoutableFileTypes.Layout:
+        writeModuleDeclaration(
+          layoutWriter,
+          path5,
+          routeType,
+          `
+  export interface Input {
+    renderBody: Marko.Body;
   }`
-  ).writeBlockStart(`switch (method) {`);
-  for (const verb of httpVerbs) {
-    const filteredRoutes = routes.list.filter((route) => hasVerb(route, verb));
-    if (filteredRoutes.length) {
-      const trie = createRouteTrie(filteredRoutes);
-      writer.writeLines(`case '${verb.toUpperCase()}':`);
-      writer.writeBlockStart(`case '${verb.toLowerCase()}': {`);
-      writeRouterVerb(writer, trie, verb);
-      writer.writeBlockEnd("}");
+        );
+        break;
+      case RoutableFileTypes.Error:
+        writeModuleDeclaration(
+          writer,
+          path5,
+          "globalThis.MarkoRun.Route",
+          `
+  export interface Input {
+    error: unknown;
+  }`
+        );
+        break;
+      case RoutableFileTypes.NotFound:
+        writeModuleDeclaration(writer, path5, "Run.Route");
+        break;
     }
   }
-  writer.writeBlockEnd("}").writeLines("return null;").writeBlockEnd("}");
-  writer.writeLines("").writeBlockStart(
-    "export async function invoke(route, request, platform, url) {"
-  ).writeLines(
-    "const [context, buildInput] = createContext(route, request, platform, url);"
-  );
-  const hasErrorPage = Boolean(routes.special[RoutableFileTypes.Error]);
-  if (hasErrorPage) {
-    writer.writeBlockStart("try {");
-  }
-  writer.writeBlockStart("if (route) {").writeBlockStart("try {").writeLines(
-    "const response = await route.handler(context, buildInput);",
-    "if (response) return response;"
-  ).indent--;
-  writer.writeBlockStart("} catch (error) {").writeLines(
-    "if (error === NotHandled) return;",
-    "if (error !== NotMatched) throw error;"
-  ).writeBlockEnd("}").writeBlockEnd("}");
-  if (routes.special[RoutableFileTypes.NotFound]) {
-    imports.writeLines(
-      `
-const page404ResponseInit = {
-  status: 404,
-  headers: { "content-type": "text/html;charset=UTF-8" },
-};`
-    );
-    writer.write(`    
-    if (context.request.headers.get('Accept')?.includes('text/html')) {
-      return new Response(page404.stream(buildInput()), page404ResponseInit);
+  handlerWriter.join();
+  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.indent--;
-  if (hasErrorPage) {
-    imports.writeLines(`
-const page500ResponseInit = {
-  status: 500,
-  headers: { "content-type": "text/html;charset=UTF-8" },
-};`);
-    writer.writeBlockStart(`} catch (error) {`).writeBlockStart(
-      `if (context.request.headers.get('Accept')?.includes('text/html')) {`
-    ).writeLines(
-      `return new Response(page500.stream(buildInput({ error })), page500ResponseInit);`
-    ).writeBlockEnd("}").writeLines("throw error;").writeBlockEnd("}");
   }
   writer.writeBlockEnd("}");
-  renderFetch(writer, options);
   return writer.end();
 }
-function renderFetch(writer, options) {
-  writer.write(`
-export async function fetch(request, platform) {
-  try {
-    const url = new URL(request.url);
-    let { pathname } = url;`);
-  switch (options.trailingSlashes) {
-    case "RedirectWithout":
-      writer.write(`
-    if (pathname !== '/' && pathname.endsWith('/')) {
-      url.pathname = pathname.slice(0, -1);
-      return Response.redirect(url);
-    }`);
-      break;
-    case "RedirectWith":
-      writer.write(`
-    if (pathname !== '/' && !pathname.endsWith('/')) {
-      url.pathname = pathname + '/';
-      return Response.redirect(url);
-    }`);
-      break;
-    case "RewriteWithout":
-      writer.write(`
-    if (pathname !== '/' && pathname.endsWith('/')) {
-      url.pathname = pathname = pathname.slice(0, -1);
-    }`);
-      break;
-    case "RewriteWith":
-      writer.write(`
-    if (pathname !== '/' && !pathname.endsWith('/')) {
-      url.pathname = pathname = pathname + '/';
-    }`);
-      break;
+function writeModuleDeclaration(writer, path5, routeType, moduleTypes) {
+  writer.writeLines("").write(`declare module "${stripTsExtension(path5)}" {`);
+  if (moduleTypes) {
+    writer.write(moduleTypes);
   }
-  writer.write(`   
-
-    const route = match(request.method, pathname);
-    return await invoke(route, request, platform, url);
-  } catch (error) {
-    if (import.meta.env.DEV) {
-      throw error;
-    }
-    return new Response(null, {
-      status: 500
-    });
+  if (routeType) {
+    const isMarko = path5.endsWith(".marko");
+    writer.write(`
+  namespace MarkoRun {
+    export { NotHandled, NotMatched, GetPaths, PostPaths, GetablePath, GetableHref, PostablePath, PostableHref, Platform };
+    export type Route = ${routeType};
+    export type Context = Run.MultiRouteContext<Route>${isMarko ? " & Marko.Global" : ""};
+    export type Handler = Run.HandlerLike<Route>;
+    /** @deprecated use \`((context, next) => { ... }) satisfies MarkoRun.Handler\` instead */
+    export const route: Run.HandlerTypeFn<Route>;
+  }`);
   }
+  writer.writeLines(`
 }`);
 }
-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}`
-      );
-    } else if (trie.static || dynamic) {
-      writer.writeBlockStart(`if (len > 1) {`);
-      closeCount++;
+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) {
+    let node = root;
+    for (const segment of path5.segments) {
+      if (segment === "$$") {
+        node.catchAll ?? (node.catchAll = { route, path: path5 });
+        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 = path5);
+    node.route ?? (node.route = route);
   }
-  if (trie.static || dynamic) {
-    const next = level + 1;
-    const index = `i${next}`;
-    let terminal;
-    let children;
-    writer.writeLines(`const ${index} = pathname.indexOf('/', ${offset}) + 1;`);
-    if (trie.static) {
-      for (const child of trie.static.values()) {
-        if (child.route) {
-          (terminal ?? (terminal = [])).push(child);
+  for (const route of routes) {
+    for (const path5 of route.paths) {
+      insert(path5, route);
+    }
+  }
+  return root;
+}
+
+// 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((path5) => ({
+              ...path5,
+              segments: path5.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 ? "$$" : "$";
         }
-        if (child.static || child.dynamic || child.catchAll) {
-          (children ?? (children = [])).push(child);
+        current ?? (current = basePaths.map((path5) => ({
+          ...path5,
+          segments: path5.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 (terminal || (dynamic == null ? void 0 : dynamic.route)) {
-      closeCount++;
-      writer.writeBlockStart(`if (!${index} || ${index} === len) {`);
-      let value = `pathname.slice(${offset}, ${index} ? -1 : len)`;
-      if (dynamic == null ? void 0 : dynamic.route) {
-        const segment = `s${next}`;
-        writer.writeLines(`const ${segment} = decodeURIComponent(${value});`);
-        value = segment;
-      } else if (terminal == null ? void 0 : terminal.some(
-        (terminal2) => decodeURIComponent(terminal2.key) !== terminal2.key
-      )) {
-        value = `decodeURIComponent(${value})`;
+    if (!current) {
+      segmentEnd(
+        basePaths.map((path5) => ({
+          ...path5,
+          segments: path5.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);
       }
-      if (terminal) {
-        const useSwitch = terminal.length > 1;
-        if (useSwitch) {
-          writer.writeBlockStart(`switch (${value}) {`);
-        }
-        for (const { key, path: path4, 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, path4)}; // ${path4.path}
-`
+    }
+    for (const path5 of paths) {
+      if (segment) {
+        if (path5.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}'.`
           );
         }
-        if (useSwitch) {
-          writer.writeBlockEnd("}");
+        path5.segments.push(segment);
+        path5.id += path5.id === "/" ? segment.name : `/${segment.name}`;
+        if (type === "$$") {
+          path5.isCatchall = true;
         }
       }
-      if (dynamic == null ? void 0 : dynamic.route) {
-        writer.writeLines(
-          `if (${value}) return ${renderMatch(
-            verb,
-            dynamic.route,
-            dynamic.path
-          )}; // ${dynamic.path.path}`
-        );
-      }
-    }
-    if (children || (dynamic == null ? void 0 : dynamic.static) || (dynamic == null ? void 0 : dynamic.dynamic) || (dynamic == null ? void 0 : dynamic.catchAll)) {
-      if (terminal || (dynamic == null ? void 0 : dynamic.route)) {
-        writer.writeBlockEnd("} else {").indent++;
-      } else {
-        writer.writeBlockStart(`if (${index} && ${index} !== len) {`);
-        closeCount++;
-      }
-      let value = `pathname.slice(${offset}, ${index} - 1)`;
-      if ((dynamic == null ? void 0 : dynamic.static) || (dynamic == null ? void 0 : dynamic.dynamic) || (dynamic == null ? void 0 : dynamic.catchAll)) {
-        const segment = `s${next}`;
-        writer.writeLines(`const ${segment} = decodeURIComponent(${value});`);
-        value = segment;
-      } else if (children == null ? void 0 : children.some((child) => decodeURIComponent(child.key) !== child.key)) {
-        value = `decodeURIComponent(${value})`;
-      }
-      if (children) {
-        const useSwitch = children.length > 1;
-        if (useSwitch) {
-          writer.writeBlockStart(`switch (${value}) {`);
-        }
-        for (const child of children) {
-          const decodedKey = decodeURIComponent(child.key);
-          if (useSwitch) {
-            writer.writeBlockStart(`case '${decodedKey}': {`);
-          } else {
-            writer.writeBlockStart(`if (${value} === '${decodedKey}') {`);
-          }
-          const nextOffset = typeof offset === "string" ? index : offset + child.key.length + 1;
-          writeRouterVerb(writer, child, verb, next, nextOffset);
-          if (useSwitch) {
-            writer.writeBlockEnd("} break;");
-          } else {
-            writer.writeBlockEnd("}");
-          }
-        }
-        if (useSwitch) {
-          writer.writeBlockEnd("}");
+      if (map) {
+        if (map.has(path5.id)) {
+          const existing = map.get(path5.id);
+          const existingExpansion = existing.segments.map((s) => s.raw).join(".");
+          const currentExpansion = path5.segments.map((s) => s.raw).join(".");
+          throw new Error(
+            `Invalid route pattern: route '${path5.id}' is ambiguous. Expansion '${currentExpansion}' collides with '${existingExpansion}' in '${pattern}'.`
+          );
         }
-      }
-      if ((dynamic == null ? void 0 : dynamic.static) || (dynamic == null ? void 0 : dynamic.dynamic) || (dynamic == null ? void 0 : dynamic.catchAll)) {
-        writer.writeBlockStart(`if (${value}) {`);
-        writeRouterVerb(writer, dynamic, verb, next, index);
-        writer.writeBlockEnd(`}`);
+        map.set(path5.id, path5);
       }
     }
   }
-  while (closeCount--) {
-    writer.writeBlockEnd("}");
-  }
-  if (catchAll) {
-    writer.writeLines(
-      `return ${renderMatch(
-        verb,
-        catchAll.route,
-        catchAll.path,
-        String(offset)
-      )}; // ${catchAll.path.path}`
-    );
-  } else if (level === 0) {
-    writer.writeLines("return null;");
-  }
-}
-function wrapPropertyName(name) {
-  name = decodeURIComponent(name);
-  return /^[^A-Za-z_$]|[^A-Za-z0-9$_]/.test(name) ? `'${name}'` : name;
 }
-function renderParams(params, pathIndex) {
-  let result = "";
-  let catchAll = "";
-  let sep = "{";
-  for (const [name, index] of Object.entries(params)) {
-    if (typeof index === "number") {
-      result += `${sep} ${wrapPropertyName(name)}: s${index + 1}`;
-      sep = ",";
-    } else if (pathIndex) {
-      catchAll = name;
+
+// src/vite/routes/vdir.ts
+var _dirs, _pathlessDirs;
+var _VDir = class _VDir {
+  constructor(parent, segment, source) {
+    __privateAdd(this, _dirs);
+    __privateAdd(this, _pathlessDirs);
+    __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;
     }
   }
-  if (catchAll) {
-    result += `${sep} ${wrapPropertyName(
-      catchAll
-    )}: pathname.slice(${pathIndex})`;
-  }
-  return result ? result + " }" : "{}";
-}
-function renderMatch(verb, route, path4, pathIndex) {
-  const handler = `${verb}${route.index}`;
-  const params = path4.params ? renderParams(path4.params, pathIndex) : "{}";
-  const meta = route.meta ? `meta${route.index}` : "{}";
-  const pathPattern = pathToURLPatternString(path4.path);
-  return `{ handler: ${handler}, params: ${params}, meta: ${meta}, path: '${pathPattern}' }`;
-}
-function renderMiddleware(middleware) {
-  const writer = createStringWriter();
-  writer.writeLines(
-    `// ${virtualFilePrefix}/${markoRunFilePrefix}middleware.js`
-  );
-  const imports = writer.branch("imports");
-  imports.writeLines(
-    `import { normalize } from '${virtualFilePrefix}/runtime/internal';`
-  );
-  writer.writeLines("");
-  for (const { id, importPath } of middleware) {
-    const importName = `middleware${id}`;
-    imports.writeLines(`import ${importName} from './${importPath}';`);
-    writer.writeLines(`export const mware${id} = normalize(${importName});`);
+  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;
+          const 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;
   }
-  imports.join();
-  return writer.end();
-}
-function stripTsExtension(path4) {
-  const index = path4.lastIndexOf(".");
-  if (index !== -1) {
-    const ext = path4.slice(index + 1);
-    if (ext.toLowerCase() === "ts") {
-      return path4.slice(0, index);
+  addDir(path5, 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, path5);
+      map.set(segment.name, dir);
+      return dir;
     }
+    return map.get(segment.name);
   }
-  return path4;
-}
-async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
-  var _a, _b;
-  const writer = createStringWriter();
-  writer.writeLines(
-    `/*
-  WARNING: This file is automatically generated and any changes made to it will be overwritten without warning.
-  Do NOT manually edit this file or your changes will be lost.
-*/
-`,
-    `import { NotHandled, NotMatched, GetPaths, PostPaths, GetablePath, GetableHref, PostablePath, PostableHref, Platform } from "@marko/run/namespace";`,
-    `import type * as Run from "@marko/run";`
-  );
-  const headWriter = writer.branch("head");
-  writer.writeLines("\n").writeBlockStart(`declare module "@marko/run" {`);
-  if (adapter && adapter.typeInfo) {
-    const platformType = await adapter.typeInfo(
-      (data) => headWriter.write(data)
-    );
-    if (platformType) {
-      writer.writeLines(`interface Platform extends ${platformType} {}
-`);
+  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.importPath}' collides with '${existing.importPath}'.`
+        );
+      } 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}`
+        );
+      }
+      throw new Error(
+        `Ambiguous path definition: file '${this.path}' is included multiple times by ${file.importPath}`
+      );
     }
   }
-  headWriter.join();
-  writer.writeBlockStart(`interface AppData extends Run.DefineApp<{`).writeBlockStart("routes: {");
-  const routesWriter = writer.branch("routes");
-  writer.writeBlockEnd("}").writeBlockEnd(`}> {}`).writeBlockEnd(`}`);
-  const routeTypes = /* @__PURE__ */ new Map();
-  for (const route of routes.list) {
-    let routeType = "";
-    for (const path4 of route.paths) {
-      const pathType = `"${pathToURLPatternString(path4.path)}"`;
-      routeType += routeType ? " | " + pathType : pathType;
-      routesWriter.writeLines(`${pathType}: Routes["${route.key}"];`);
+  *dirs() {
+    if (__privateGet(this, _pathlessDirs)) {
+      yield* __privateGet(this, _pathlessDirs).values();
     }
-    for (const file of [route.handler, route.page]) {
-      if (file) {
-        const existing = routeTypes.get(file);
-        if (!existing) {
-          routeTypes.set(file, [routeType]);
-        } else {
-          existing.push(routeType);
-        }
-      }
+    if (__privateGet(this, _dirs)) {
+      yield* __privateGet(this, _dirs).values();
     }
-    for (const files of [route.middleware, route.layouts]) {
-      if (files) {
-        for (const file of files) {
-          const existing = routeTypes.get(file);
-          if (!existing) {
-            routeTypes.set(file, [routeType]);
-          } else {
-            existing.push(routeType);
+  }
+  *[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 path5 of paths) {
+        let dir = root;
+        for (const segment of path5.segments) {
+          dir = dir.addDir(path5, 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}${path5.source}' defines '${dir.path}' multiple times.`
+          );
+        } else {
+          unique.add(dir.path);
+          dirs.push(dir);
         }
       }
     }
+    return dirs;
   }
-  for (const special of Object.values(routes.special)) {
-    routeTypes.set(special.page, []);
-  }
-  routesWriter.join();
-  const handlerWriter = writer.branch("handler");
-  const middlewareWriter = writer.branch("middleware");
-  const pageWriter = writer.branch("page");
-  const layoutWriter = writer.branch("layout");
-  for (const [file, types] of routeTypes) {
-    const path4 = `${pathPrefix}/${file.relativePath}`;
-    const routeType = `Run.Routes[${types.join(" | ")}]`;
-    switch (file.type) {
-      case RoutableFileTypes.Handler:
-        writeModuleDeclaration(handlerWriter, path4, routeType);
-        break;
-      case RoutableFileTypes.Middleware:
-        writeModuleDeclaration(middlewareWriter, path4, routeType);
-        break;
-      case RoutableFileTypes.Page:
-        writeModuleDeclaration(pageWriter, path4, routeType);
-        break;
-      case RoutableFileTypes.Layout:
-        writeModuleDeclaration(
-          layoutWriter,
-          path4,
-          routeType,
-          `
-  export interface Input {
-    renderBody: Marko.Body;
-  }`
-        );
-        break;
-      case RoutableFileTypes.Error:
-        writeModuleDeclaration(
-          writer,
-          path4,
-          "globalThis.MarkoRun.Route",
-          `
-  export interface Input {
-    error: unknown;
-  }`
+};
+_dirs = new WeakMap();
+_pathlessDirs = new WeakMap();
+var VDir = _VDir;
+
+// src/vite/routes/builder.ts
+var markoFiles = `(${RoutableFileTypes.Layout}|${RoutableFileTypes.Page}|${RoutableFileTypes.NotFound}|${RoutableFileTypes.Error})\\.(?:.*\\.)?(marko)`;
+var nonMarkoFiles = `(${RoutableFileTypes.Middleware}|${RoutableFileTypes.Handler}|${RoutableFileTypes.Meta})\\.(?:.*\\.)?(.+)`;
+var routeableFileRegex = new RegExp(
+  `[+](?:${markoFiles}|${nonMarkoFiles})$`,
+  "i"
+);
+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) {
+  const uniqueRoutes = /* @__PURE__ */ new Map();
+  const routes = [];
+  const special = {};
+  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 basePath;
+  let importPrefix;
+  let activeDirs;
+  let isBaseDir;
+  let nextFileId = 1;
+  let nextRouteIndex = 1;
+  const walkOptions = {
+    onEnter({ name }) {
+      const prevDirStackLength = dirStack.length;
+      if (isBaseDir) {
+        isBaseDir = false;
+        if (!basePath) {
+          return;
+        }
+        name = basePath;
+      } else {
+        dirStack.push(name);
+      }
+      const previousDirs = activeDirs;
+      const paths = parseFlatRoute(name);
+      activeDirs = VDir.addPaths(previousDirs, paths);
+      return () => {
+        activeDirs = previousDirs;
+        dirStack.length = prevDirStackLength;
+      };
+    },
+    onFile({ name, path: path5 }) {
+      const match = name.match(routeableFileRegex);
+      if (!match) {
+        return;
+      }
+      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 ${path5}`
         );
-        break;
-      case RoutableFileTypes.NotFound:
-        writeModuleDeclaration(writer, path4, "Run.Route");
-        break;
+        return;
+      }
+      let dirs = activeDirs;
+      if (match.index) {
+        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 = {
+        id: String(nextFileId++),
+        name,
+        type,
+        filePath: path5,
+        relativePath,
+        importPath: `${importPrefix}/${relativePath}`,
+        verbs: type === RoutableFileTypes.Page ? ["get"] : void 0
+      };
+      for (const dir of dirs) {
+        dir.addFile(file);
+      }
     }
+  };
+  if (!Array.isArray(sources)) {
+    sources = [sources];
   }
-  handlerWriter.join();
-  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"`);
+  for (const source of sources) {
+    importPrefix = source.importPrefix ? source.importPrefix.replace(/^\/+|\/+$/g, "") : "";
+    basePath = source.basePath || "";
+    activeDirs = [root];
+    isBaseDir = true;
+    await source.walker(walkOptions);
+  }
+  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 ((_b = handler == null ? void 0 : handler.verbs) == null ? void 0 : _b.includes("post")) {
-        verbs.push(`"post"`);
+      if (layout) {
+        if (currentLayouts.has(layout)) {
+          layout = void 0;
+        } else {
+          currentLayouts.add(layout);
+          unusedFiles.add(layout);
+        }
       }
-      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"]`;
+      if (page || handler) {
+        const path5 = dir.pathInfo;
+        if (uniqueRoutes.has(path5.id)) {
+          const existing = uniqueRoutes.get(path5.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.path}' were defined. A route established by:
+      ${existingFiles.join(" and ")} via '${existing.dir.path}'
+        collides with
+      ${currentFiles.join(" and ")} via '${dir.path}'
+      `);
+        }
+        uniqueRoutes.set(path5.id, { dir, index: routes.length });
+        routes.push({
+          index: nextRouteIndex++,
+          key: dir.fullPath,
+          paths: [path5],
+          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 (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) {
+        for (const middleware2 of currentMiddleware) {
+          middlewares.add(middleware2);
+          unusedFiles.delete(middleware2);
+        }
+      }
+      if (page || hasSpecial) {
+        for (const layout2 of currentLayouts) {
+          unusedFiles.delete(layout2);
         }
-        routeType += ` meta: ${metaType};`;
       }
-      writer.writeLines(`"${route.key}": ${routeType} };`);
+    }
+    if (dir.dirs) {
+      for (const child of dir.dirs()) {
+        traverse(child);
+      }
+    }
+    if (middleware) {
+      currentMiddleware.delete(middleware);
+    }
+    if (layout) {
+      currentLayouts.delete(layout);
     }
   }
-  writer.writeBlockEnd("}");
-  return writer.end();
-}
-function writeModuleDeclaration(writer, path4, routeType, moduleTypes) {
-  writer.writeLines("").write(`declare module "${stripTsExtension(path4)}" {`);
-  if (moduleTypes) {
-    writer.write(moduleTypes);
-  }
-  if (routeType) {
-    const isMarko = path4.endsWith(".marko");
-    writer.write(`
-  namespace MarkoRun {
-    export { NotHandled, NotMatched, GetPaths, PostPaths, GetablePath, GetableHref, PostablePath, PostableHref, Platform };
-    export type Route = ${routeType};
-    export type Context = Run.MultiRouteContext<Route>${isMarko ? " & Marko.Global" : ""};
-    export type Handler = Run.HandlerLike<Route>;
-    /** @deprecated use \`((context, next) => { ... }) satisfies MarkoRun.Handler\` instead */
-    export const route: Run.HandlerTypeFn<Route>;
-  }`);
-  }
-  writer.writeLines(`
-}`);
-}
-function pathToURLPatternString(path4) {
-  return path4.replace(/\/\$(\$?)([^\/]*)/g, (_, catchAll, name) => {
-    name = decodeURIComponent(name);
-    return catchAll ? `/:${name || "rest"}*` : `/:${name}`;
-  });
 }
-function createRouteTrie(routes) {
-  const root = {
-    key: ""
-  };
-  function insert(path4, route) {
-    let node = root;
-    for (const segment of path4.segments) {
-      if (segment === "$$") {
-        node.catchAll ?? (node.catchAll = { route, path: path4 });
-        return;
-      } else if (segment === "$") {
-        node = node.dynamic ?? (node.dynamic = {
-          key: ""
+
+// src/vite/routes/walk.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+function createFSWalker(dir) {
+  return async function walkFS({
+    onEnter,
+    onFile,
+    onDir,
+    maxDepth = 50
+  }) {
+    async function walk(dir2, depth) {
+      const onExit = onEnter == null ? void 0 : onEnter(dir2);
+      if (onExit !== false) {
+        const dirs = [];
+        const entries = await import_fs.default.promises.readdir(dir2.path, {
+          withFileTypes: true
         });
-      } else {
-        node.static ?? (node.static = /* @__PURE__ */ new Map());
-        let next = node.static.get(segment);
-        if (!next) {
-          next = {
-            key: segment
+        const prefix = dir2.path + import_path2.default.sep;
+        for (const entry of entries) {
+          const walkEntry = {
+            name: entry.name,
+            path: prefix + entry.name
           };
-          node.static.set(segment, next);
+          if (entry.isDirectory()) {
+            dirs.push(walkEntry);
+          } else {
+            onFile == null ? void 0 : onFile(walkEntry);
+          }
         }
-        node = next;
+        if ((onDir == null ? void 0 : onDir()) !== false && --depth > 0) {
+          for (const entry of dirs) {
+            await walk(entry, depth);
+          }
+        }
+        onExit == null ? void 0 : onExit();
       }
     }
-    node.path ?? (node.path = path4);
-    node.route ?? (node.route = route);
-  }
-  for (const route of routes) {
-    for (const path4 of route.paths) {
-      insert(path4, route);
-    }
-  }
-  return root;
+    await walk(
+      {
+        path: dir,
+        name: import_path2.default.basename(dir)
+      },
+      maxDepth
+    );
+  };
 }
 
 // src/vite/utils/ast.ts
@@ -1524,18 +1559,32 @@ function getViteSSRExportIdentifiers(astProgramNode, exportObjectName = "__vite_
   return result;
 }
 
+// src/vite/utils/config.ts
+var PluginConfigKey = "__MARKO_RUN_PLUGIN_CONFIG__";
+var AdapterConfigKey = "__MARKO_RUN_ADAPTER_CONFIG__";
+function getConfig(obj, key) {
+  return obj[key];
+}
+function setConfig(obj, key, value) {
+  obj[key] = value;
+  return obj;
+}
+var getExternalPluginOptions = (viteConfig) => getConfig(viteConfig, PluginConfigKey);
+var setExternalPluginOptions = (viteConfig, value) => setConfig(viteConfig, PluginConfigKey, value);
+var getExternalAdapterOptions = (viteConfig) => getConfig(viteConfig, AdapterConfigKey);
+
 // src/vite/utils/log.ts
 var import_node_zlib = __toESM(require("node:zlib"), 1);
+var import_buffer = require("buffer");
 var import_cli_table3 = __toESM(require("cli-table3"), 1);
-var import_kleur = __toESM(require("kleur"), 1);
 var import_human_format = __toESM(require("human-format"), 1);
-var import_buffer = require("buffer");
+var import_kleur2 = __toESM(require("kleur"), 1);
 var HttpVerbColors = {
-  get: import_kleur.default.green,
-  post: import_kleur.default.magenta,
-  put: import_kleur.default.cyan,
-  delete: import_kleur.default.red,
-  other: import_kleur.default.white
+  get: import_kleur2.default.green,
+  post: import_kleur2.default.magenta,
+  put: import_kleur2.default.cyan,
+  delete: import_kleur2.default.red,
+  other: import_kleur2.default.white
 };
 var HttpVerbOrder = {
   get: 0,
@@ -1562,13 +1611,13 @@ function logRoutesTable(routes, bundle, options) {
   headings.push("Size/GZip");
   colAligns.push("right");
   const table = new import_cli_table3.default({
-    head: headings.map((title) => import_kleur.default.bold(import_kleur.default.white(title.toUpperCase()))),
+    head: headings.map((title) => import_kleur2.default.bold(import_kleur2.default.white(title.toUpperCase()))),
     wordWrap: true,
     colAligns,
     style: { compact: true }
   });
   for (const route of routes.list) {
-    for (const path4 of route.paths) {
+    for (const path5 of route.paths) {
       const verbs = getVerbs(route).sort(
         (a, b) => HttpVerbOrder[a] - HttpVerbOrder[b]
       );
@@ -1577,17 +1626,17 @@ function logRoutesTable(routes, bundle, options) {
         let size = "";
         const entryType = [];
         if (route.handler) {
-          entryType.push(import_kleur.default.blue("handler"));
+          entryType.push(import_kleur2.default.blue("handler"));
         }
         if (verb === "get" && route.page) {
-          entryType.push(import_kleur.default.yellow("page"));
+          entryType.push(import_kleur2.default.yellow("page"));
           size = prettySize(computeRouteSize(getRouteChunkName(route), bundle));
         }
         const row = [
-          import_kleur.default.bold(HttpVerbColors[verb](verb.toUpperCase()))
+          import_kleur2.default.bold(HttpVerbColors[verb](verb.toUpperCase()))
         ];
         if (verbs.length === 1 || firstRow) {
-          row.push({ rowSpan: verbs.length, content: prettyPath(path4.path) });
+          row.push({ rowSpan: verbs.length, content: prettyPath(path5.path) });
           firstRow = false;
         }
         row.push(entryType.join(" -> "));
@@ -1599,7 +1648,7 @@ function logRoutesTable(routes, bundle, options) {
     }
   }
   for (const [key, route] of Object.entries(routes.special).sort()) {
-    const row = [import_kleur.default.bold(import_kleur.default.white("*")), key, import_kleur.default.yellow("page")];
+    const row = [import_kleur2.default.bold(import_kleur2.default.white("*")), key, import_kleur2.default.yellow("page")];
     hasMiddleware && row.push("");
     hasMeta && row.push("");
     row.push(prettySize(computeRouteSize(getRouteChunkName(route), bundle)));
@@ -1638,44 +1687,27 @@ function computeChunkSize(chunk, bundle, seen = /* @__PURE__ */ new Set()) {
 }
 function prettySize([bytes, compBytes]) {
   if (bytes <= 0) {
-    return import_kleur.default.gray("0.0 kB");
+    return import_kleur2.default.gray("0.0 kB");
   }
   const [size, prefix] = (0, import_human_format.default)(bytes, { decimals: 1 }).split(/\s+/);
   const compSize = (0, import_human_format.default)(compBytes, { decimals: 1, prefix, unit: "B" });
-  let str = import_kleur.default.white(size) + import_kleur.default.gray("/");
-  if (compBytes < 20 * 1e3) str += import_kleur.default.green(compSize);
-  else if (compBytes < 50 * 1e3) str += import_kleur.default.yellow(compSize);
-  else str += import_kleur.default.bold(import_kleur.default.red(compSize));
+  let str = import_kleur2.default.white(size) + import_kleur2.default.gray("/");
+  if (compBytes < 20 * 1e3) str += import_kleur2.default.green(compSize);
+  else if (compBytes < 50 * 1e3) str += import_kleur2.default.yellow(compSize);
+  else str += import_kleur2.default.bold(import_kleur2.default.red(compSize));
   return str;
 }
-function prettyPath(path4) {
-  return path4.replace(/\/\$\$(.*)$/, (_, p) => "/" + import_kleur.default.bold(import_kleur.default.dim(`*${p}`))).replace(/\/\$([^/]+)/g, (_, p) => "/" + import_kleur.default.bold(import_kleur.default.dim(`:${p}`)));
-}
-
-// src/vite/utils/config.ts
-var PluginConfigKey = "__MARKO_RUN_PLUGIN_CONFIG__";
-var AdapterConfigKey = "__MARKO_RUN_ADAPTER_CONFIG__";
-function getConfig(obj, key) {
-  return obj[key];
-}
-function setConfig(obj, key, value) {
-  obj[key] = value;
-  return obj;
+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}`)));
 }
-var getExternalPluginOptions = (viteConfig) => getConfig(viteConfig, PluginConfigKey);
-var setExternalPluginOptions = (viteConfig, value) => setConfig(viteConfig, PluginConfigKey, value);
-var getExternalAdapterOptions = (viteConfig) => getConfig(viteConfig, AdapterConfigKey);
-
-// src/vite/plugin.ts
-var import_debug = __toESM(require("debug"), 1);
 
 // src/vite/utils/read-once-persisted-store.ts
-var import_os = __toESM(require("os"), 1);
-var import_path2 = __toESM(require("path"), 1);
 var import_fs2 = require("fs");
+var import_os = __toESM(require("os"), 1);
+var import_path3 = __toESM(require("path"), 1);
 var noop = () => {
 };
-var tmpFile = import_path2.default.join(import_os.default.tmpdir(), "marko-run-storage.json");
+var tmpFile = import_path3.default.join(import_os.default.tmpdir(), "marko-run-storage.json");
 var values = /* @__PURE__ */ new Map();
 var loadedFromDisk;
 var ReadOncePersistedStore = class {
@@ -1715,35 +1747,9 @@ process.once("beforeExit", (code) => {
   }
 });
 
-// src/adapter/utils.ts
-var import_supports_color = __toESM(require("supports-color"), 1);
-var import_kleur2 = __toESM(require("kleur"), 1);
-function stripAnsi(string) {
-  return string.replace(
-    /([\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><])/g,
-    ""
-  );
-}
-function cleanStack(stack) {
-  return stack.split(/\n/).filter((l) => /^\s*at/.test(l)).join("\n");
-}
-function prepareError(err) {
-  var _a;
-  return {
-    message: stripAnsi(err.message),
-    stack: stripAnsi(cleanStack(err.stack || "")),
-    id: err.id,
-    frame: stripAnsi(err.frame || ""),
-    plugin: err.plugin,
-    pluginCode: (_a = err.pluginCode) == null ? void 0 : _a.toString(),
-    loc: err.loc
-  };
-}
-
 // src/vite/plugin.ts
-var import_crypto = require("crypto");
 var debug = (0, import_debug.default)("@marko/run");
-var __dirname = import_path3.default.dirname((0, import_url2.fileURLToPath)(__importMetaURL));
+var __dirname = import_path4.default.dirname((0, import_url2.fileURLToPath)(__importMetaURL));
 var PLUGIN_NAME_PREFIX = "marko-run-vite";
 var POSIX_SEP = "/";
 var WINDOWS_SEP = "\\";
@@ -1751,7 +1757,7 @@ 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_path3.default.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
+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 store;
@@ -1773,24 +1779,21 @@ function markoRun(opts = {}) {
   let getExportsFromFile;
   let resolvedConfig;
   let typesFile;
-  let seenErrors = /* @__PURE__ */ new Set();
+  const seenErrors = /* @__PURE__ */ new Set();
   const virtualFiles = /* @__PURE__ */ new Map();
   let times = {
     routesBuild: 0,
     routesRender: 0
   };
-  function getEntryFileRelativePath(to) {
-    return normalizePath(import_path3.default.relative(entryFilesDir, to));
-  }
   async function writeTypesFile(routes2) {
     if (routes2 && (tsConfigExists ?? (tsConfigExists = await globFileExists(
       root,
       "{.tsconfig*,tsconfig*.json}"
     )))) {
-      const filepath = import_path3.default.join(typesDir, "routes.d.ts");
+      const filepath = import_path4.default.join(typesDir, "routes.d.ts");
       const data = await renderRouteTypeInfo(
         routes2,
-        normalizePath(import_path3.default.relative(typesDir, resolvedRoutesDir)),
+        normalizePath(import_path4.default.relative(typesDir, resolvedRoutesDir)),
         adapter
       );
       if (data !== typesFile || !import_fs3.default.existsSync(filepath)) {
@@ -1801,80 +1804,94 @@ function markoRun(opts = {}) {
   }
   let buildVirtualFilesResult;
   function buildVirtualFiles() {
-    return buildVirtualFilesResult ?? (buildVirtualFilesResult = new Promise(async (resolve, reject) => {
-      try {
-        virtualFiles.clear();
-        routes = await buildRoutes({
-          walker: createFSWalker(resolvedRoutesDir),
-          importPrefix: routesDir
-        });
-        if (!routes.list.length) {
-          throw new Error("No routes generated");
-        }
-        for (const route of routes.list) {
-          virtualFiles.set(import_path3.default.posix.join(root, `${route.entryName}.js`), "");
-        }
-        if (routes.middleware.length) {
-          virtualFiles.set(import_path3.default.posix.join(root, MIDDLEWARE_FILENAME), "");
-        }
-        virtualFiles.set(import_path3.default.posix.join(root, ROUTER_FILENAME), "");
-        resolve(routes);
-      } catch (err) {
-        reject(err);
+    return buildVirtualFilesResult ?? (buildVirtualFilesResult = (async () => {
+      virtualFiles.clear();
+      routes = await buildRoutes({
+        walker: createFSWalker(resolvedRoutesDir),
+        importPrefix: routesDir
+      });
+      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`), "");
+      }
+      if (routes.middleware.length) {
+        virtualFiles.set(import_path4.default.posix.join(root, MIDDLEWARE_FILENAME), "");
+      }
+      virtualFiles.set(import_path4.default.posix.join(root, ROUTER_FILENAME), "");
+      return routes;
+    })());
   }
   let renderVirtualFilesResult;
   function renderVirtualFiles(context) {
-    return renderVirtualFilesResult ?? (renderVirtualFilesResult = new Promise(async (resolve) => {
+    return renderVirtualFilesResult ?? (renderVirtualFilesResult = (async () => {
       var _a;
       try {
         const routes2 = await buildVirtualFiles();
-        let entryFilesDirExists = false;
         if (import_fs3.default.existsSync(entryFilesDir)) {
           import_fs3.default.rmSync(entryFilesDir, { recursive: true });
         }
         for (const route of routes2.list) {
-          if (route.handler) {
-            const exports2 = await getExportsFromFile(
-              context,
-              route.handler.filePath
-            );
-            route.handler.verbs = [];
+          const { handler, page, layouts } = route;
+          if (handler) {
+            const exports2 = await getExportsFromFile(context, handler.filePath);
+            handler.verbs = [];
             for (const name of exports2) {
               const verb = name.toLowerCase();
               if (name === verb.toUpperCase() && httpVerbs.includes(verb)) {
-                route.handler.verbs.push(verb);
+                handler.verbs.push(verb);
               }
             }
-            if (!route.handler.verbs.length) {
+            if (!handler.verbs.length) {
               context.warn(
-                `Did not find any http verb exports in handler '${import_path3.default.relative(root, route.handler.filePath)}' - expected ${httpVerbs.map((v) => v.toUpperCase()).join(", ")}`
+                `Did not find any http verb exports in handler '${import_path4.default.relative(root, handler.filePath)}' - expected ${httpVerbs.map((v) => v.toUpperCase()).join(", ")}`
               );
             }
           }
-          if (route.page && route.layouts.length) {
-            entryFilesDirExists || (entryFilesDirExists = !!import_fs3.default.mkdirSync(entryFilesDir, {
-              recursive: true
-            }));
+          if (page && 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(
-              import_path3.default.join(entryFilesDir, `${route.entryName}.marko`),
-              renderRouteTemplate(route, getEntryFileRelativePath)
+              import_path4.default.join(routeFileDir, pageNamePrefix + "route.marko"),
+              renderRouteTemplate(
+                route,
+                (to) => import_path4.default.posix.join(routeFileRelativePathPosix, to)
+              )
             );
           }
           virtualFiles.set(
-            import_path3.default.posix.join(root, `${route.entryName}.js`),
+            import_path4.default.posix.join(root, `${route.entryName}.js`),
             renderRouteEntry(route, relativeEntryFilesDirPosix)
           );
         }
         for (const route of Object.values(routes2.special)) {
-          if (route.layouts.length) {
-            entryFilesDirExists || (entryFilesDirExists = !!import_fs3.default.mkdirSync(entryFilesDir, {
-              recursive: true
-            }));
+          const { page, layouts, key } = route;
+          if (page && 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(
-              import_path3.default.join(entryFilesDir, `${route.entryName}.marko`),
-              renderRouteTemplate(route, getEntryFileRelativePath)
+              import_path4.default.join(routeFileDir, `route.${key}.marko`),
+              renderRouteTemplate(
+                route,
+                (to) => import_path4.default.posix.join(routeFileRelativePathPosix, to)
+              )
             );
           }
         }
@@ -1882,17 +1899,17 @@ function markoRun(opts = {}) {
           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_path3.default.relative(root, middleware.filePath)}'`
+                `Did not find a default export in middleware '${import_path4.default.relative(root, middleware.filePath)}'`
               );
             }
           }
           virtualFiles.set(
-            import_path3.default.posix.join(root, MIDDLEWARE_FILENAME),
+            import_path4.default.posix.join(root, MIDDLEWARE_FILENAME),
             renderMiddleware(routes2.middleware)
           );
         }
         virtualFiles.set(
-          import_path3.default.posix.join(root, ROUTER_FILENAME),
+          import_path4.default.posix.join(root, ROUTER_FILENAME),
           renderRouter(routes2, relativeEntryFilesDirPosix, {
             trailingSlashes: opts.trailingSlashes || "RedirectWithout"
           })
@@ -1916,12 +1933,11 @@ function markoRun(opts = {}) {
           throw err;
         }
         virtualFiles.set(
-          import_path3.default.posix.join(root, ROUTER_FILENAME),
+          import_path4.default.posix.join(root, ROUTER_FILENAME),
           `throw ${JSON.stringify(prepareError(err))}`
         );
       }
-      resolve();
-    }));
+    })());
   }
   return [
     defaultConfigPlugin,
@@ -1932,7 +1948,7 @@ function markoRun(opts = {}) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
         const externalPluginOptions = getExternalPluginOptions(config2);
         if (externalPluginOptions) {
-          opts = (0, import_vite.mergeConfig)(opts, externalPluginOptions);
+          opts = (0, import_vite2.mergeConfig)(opts, externalPluginOptions);
         }
         root = normalizePath(config2.root || process.cwd());
         isBuild = env.command === "build";
@@ -1950,7 +1966,7 @@ function markoRun(opts = {}) {
           });
           const adapterOptions = await ((_c = adapter.pluginOptions) == null ? void 0 : _c.call(adapter, opts));
           if (adapterOptions) {
-            opts = (0, import_vite.mergeConfig)(opts, adapterOptions);
+            opts = (0, import_vite2.mergeConfig)(opts, adapterOptions);
           }
         }
         routesDir = opts.routesDir || "src/routes";
@@ -1959,23 +1975,25 @@ function markoRun(opts = {}) {
         );
         markoVitePluginOptions.runtimeId = opts.runtimeId;
         markoVitePluginOptions.basePathVar = opts.basePathVar;
-        resolvedRoutesDir = import_path3.default.resolve(root, routesDir);
-        entryFilesDir = import_path3.default.join(
+        resolvedRoutesDir = import_path4.default.resolve(root, routesDir);
+        entryFilesDir = import_path4.default.join(
           getModulesDir(root),
           ".marko",
           (0, import_crypto.createHash)("shake256", { outputLength: 4 }).update(root).digest("hex")
         );
         entryFilesDirPosix = normalizePath(entryFilesDir);
-        relativeEntryFilesDirPosix = normalizePath(import_path3.default.relative(root, entryFilesDir));
-        typesDir = import_path3.default.join(root, ".marko-run");
-        devEntryFile = import_path3.default.join(root, "index.html");
+        relativeEntryFilesDirPosix = normalizePath(
+          import_path4.default.relative(root, entryFilesDir)
+        );
+        typesDir = import_path4.default.join(root, ".marko-run");
+        devEntryFile = import_path4.default.join(root, "index.html");
         devEntryFilePosix = normalizePath(devEntryFile);
         let outDir = ((_d = config2.build) == null ? void 0 : _d.outDir) || "dist";
         const assetsDir = ((_e = config2.build) == null ? void 0 : _e.assetsDir) || "assets";
         let rollupOutputOptions = (_g = (_f = config2.build) == null ? void 0 : _f.rollupOptions) == null ? void 0 : _g.output;
         if (isBuild) {
           if (!isSSRBuild) {
-            outDir = import_path3.default.join(outDir, CLIENT_OUT_DIR);
+            outDir = import_path4.default.join(outDir, CLIENT_OUT_DIR);
           }
           const defaultRollupOutputOptions = {
             assetFileNames({ name }) {
@@ -1987,7 +2005,7 @@ function markoRun(opts = {}) {
             entryFileNames(info) {
               let name = getEntryFileName(info.facadeModuleId);
               if (!name) {
-                for (let id of info.moduleIds) {
+                for (const id of info.moduleIds) {
                   name = getEntryFileName(id);
                   if (name) {
                     break;
@@ -2069,7 +2087,7 @@ function markoRun(opts = {}) {
         if (adapter == null ? void 0 : adapter.viteConfig) {
           const adapterConfig = await adapter.viteConfig(config2);
           if (adapterConfig) {
-            pluginConfig = (0, import_vite.mergeConfig)(pluginConfig, adapterConfig);
+            pluginConfig = (0, import_vite2.mergeConfig)(pluginConfig, adapterConfig);
           }
         }
         return setExternalPluginOptions(pluginConfig, opts);
@@ -2098,7 +2116,7 @@ function markoRun(opts = {}) {
             baseError.call(this, msg, options);
           } else if (!seenErrors.has(options.error.message)) {
             seenErrors.add(options.error.message);
-            console.error((0, import_vite.buildErrorMessage)(options.error));
+            console.error((0, import_vite2.buildErrorMessage)(options.error));
           }
         };
       },
@@ -2107,7 +2125,7 @@ function markoRun(opts = {}) {
         devServer.watcher.on("all", async (type, filename) => {
           seenErrors.clear();
           const routableFileType = matchRoutableFile(
-            import_path3.default.parse(filename).base
+            import_path4.default.parse(filename).base
           );
           if (filename.startsWith(resolvedRoutesDir) && routableFileType) {
             if (type === "add" || type === "unlink" || type === "change" && (routableFileType === RoutableFileTypes.Handler || routableFileType === RoutableFileTypes.Middleware)) {
@@ -2152,19 +2170,20 @@ function markoRun(opts = {}) {
       },
       async resolveId(importee, importer) {
         if (importee === "@marko/run/router") {
-          return import_path3.default.resolve(root, ROUTER_FILENAME);
+          console.log("plugin resolveId router");
+          return import_path4.default.resolve(root, ROUTER_FILENAME);
         } else if (importee.endsWith(".marko") && importee.includes(relativeEntryFilesDirPosix)) {
           if (!importee.startsWith(root)) {
-            importee = import_path3.default.resolve(root, "." + importee);
+            importee = import_path4.default.resolve(root, "." + importee);
           }
           return normalizePath(importee);
         }
         let virtualFilePath;
         if (importee.startsWith(virtualFilePrefix)) {
           virtualFilePath = importee.slice(virtualFilePrefix.length + 1);
-          importee = import_path3.default.resolve(root, virtualFilePath);
+          importee = import_path4.default.resolve(root, virtualFilePath);
         } else if (!isBuild && importer && (importer === devEntryFile || normalizePath(importer) === devEntryFilePosix) && importee.startsWith(`/${markoRunFilePrefix}`)) {
-          importee = import_path3.default.resolve(root, "." + importee);
+          importee = import_path4.default.resolve(root, "." + importee);
         }
         importee = normalizePath(importee);
         if (!buildVirtualFilesResult) {
@@ -2173,7 +2192,7 @@ function markoRun(opts = {}) {
         if (virtualFiles.has(importee)) {
           return importee;
         } else if (virtualFilePath) {
-          const filePath = import_path3.default.resolve(__dirname, "..", virtualFilePath);
+          const filePath = import_path4.default.resolve(__dirname, "..", virtualFilePath);
           return await this.resolve(filePath, importer, {
             skipSelf: true
           });
@@ -2193,7 +2212,7 @@ function markoRun(opts = {}) {
         }
       }
     },
-    ...(0, import_vite2.default)(markoVitePluginOptions),
+    ...(0, import_vite.default)(markoVitePluginOptions),
     {
       name: `${PLUGIN_NAME_PREFIX}:post`,
       enforce: "post",
@@ -2212,7 +2231,7 @@ function markoRun(opts = {}) {
           const builtEntries = Object.values(bundle).reduce(
             (acc, item) => {
               if (item.type === "chunk" && item.isEntry) {
-                acc.push(import_path3.default.join(options.dir, item.fileName));
+                acc.push(import_path4.default.join(options.dir, item.fileName));
               }
               return acc;
             },
@@ -2272,11 +2291,11 @@ async function ensureDir(dir) {
 }
 async function getPackageData(dir) {
   do {
-    const pkgPath = import_path3.default.join(dir, "package.json");
+    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"));
     }
-  } while (dir !== (dir = import_path3.default.dirname(dir)));
+  } while (dir !== (dir = import_path4.default.dirname(dir)));
   return null;
 }
 async function resolveAdapter(root, options, log) {
@@ -2292,7 +2311,10 @@ async function resolveAdapter(root, options, log) {
     for (const name of dependecies) {
       if (name.startsWith("@marko/run-adapter") || name.indexOf("marko-run-adapter") !== -1) {
         try {
-          const module3 = await import(name);
+          const module3 = await import(
+            /* @vite-ignore */
+            name
+          );
           log && debug(
             `Using adapter ${name} listed in your package.json dependecies`
           );
@@ -2304,7 +2326,10 @@ async function resolveAdapter(root, options, log) {
     }
   }
   const defaultAdapter = "@marko/run/adapter";
-  const module2 = await import(defaultAdapter);
+  const module2 = await import(
+    /* @vite-ignore */
+    defaultAdapter
+  );
   log && debug("Using default adapter");
   return module2.default();
 }
@@ -2329,7 +2354,7 @@ function getModulesDir(root, dir = __dirname) {
       return dir.slice(0, index + 12);
     }
   }
-  return import_path3.default.join(root, "node_modules");
+  return import_path4.default.join(root, "node_modules");
 }
 var defaultConfigPlugin = {
   name: `${PLUGIN_NAME_PREFIX}:defaults`,
@@ -2348,11 +2373,11 @@ var defaultConfigPlugin = {
 };
 
 // src/vite/utils/server.ts
-var import_net = __toESM(require("net"), 1);
 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_cluster = __toESM(require("cluster"), 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");