@marko/run 0.2.3 → 0.2.5

package/dist/cli/index.mjs

@@ -29,7 +29,7 @@ import sade from "sade";
 
 // src/cli/commands.ts
 import path3 from "path";
-import fs3 from "fs";
+import fs4 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { build as viteBuild, resolveConfig } from "vite";
 
@@ -45,23 +45,58 @@ function setConfig(obj, key, value) {
 }
 var getExternalPluginOptions = (viteConfig) => getConfig(viteConfig, PluginConfigKey);
 var setExternalPluginOptions = (viteConfig, value) => setConfig(viteConfig, PluginConfigKey, value);
+var getExternalAdapterOptions = (viteConfig) => getConfig(viteConfig, AdapterConfigKey);
 var setExternalAdapterOptions = (viteConfig, value) => setConfig(viteConfig, AdapterConfigKey, value);
 
 // src/cli/commands.ts
 import { MemoryStore } from "@marko/vite";
 
+// src/vite/utils/server.ts
+import net from "net";
+import cp from "child_process";
+import { parse, config } from "dotenv";
+import fs from "fs";
+import cluster from "cluster";
+async function getConnection(port) {
+  return new Promise((resolve) => {
+    const connection = net.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => {
+      connection.end();
+      resolve(null);
+    }).on("connect", () => {
+      resolve(connection);
+    });
+  });
+}
+async function isPortInUse(port) {
+  return Boolean(await getConnection(port));
+}
+async function getAvailablePort(port) {
+  if (port && !await isPortInUse(port)) {
+    return port;
+  }
+  return new Promise((resolve) => {
+    const server = net.createServer().listen(0, () => {
+      const { port: port2 } = server.address();
+      server.close(() => resolve(port2));
+    });
+  });
+}
+
 // src/vite/plugin.ts
 import path2 from "path";
 import crypto from "crypto";
-import fs2 from "fs";
+import fs3 from "fs";
 import glob from "glob";
 import { mergeConfig } from "vite";
 import markoVitePlugin, { FileStore } from "@marko/vite";
 
 // src/vite/constants.ts
+var markoRunFilePrefix = "__marko-run__";
 var virtualFilePrefix = "virtual:marko-run";
 var virtualRoutesPrefix = `${virtualFilePrefix}/routes`;
 var virtualRuntimePrefix = `${virtualFilePrefix}/internal`;
+var httpVerbs = ["get", "post", "put", "delete"];
+var serverEntryQuery = "?marko-server-entry";
 var RoutableFileTypes = {
   Page: "page",
   Layout: "layout",
@@ -215,6 +250,144 @@ var VDir = _VDir;
 _dirs = new WeakMap();
 _pathlessDirs = new WeakMap();
 
+// src/vite/routes/parse.ts
+function parseFlatRoute(pattern) {
+  if (!pattern)
+    throw new Error("Empty pattern");
+  const len = pattern.length;
+  let i = 0;
+  return parse2([
+    {
+      id: "/",
+      segments: [],
+      source: pattern
+    }
+  ]);
+  function parse2(basePaths, group) {
+    const pathMap = /* @__PURE__ */ new Map();
+    const delimiters = group ? ").," : ".,";
+    let charCode;
+    let segmentStart = i;
+    let type;
+    let current;
+    do {
+      charCode = pattern.charCodeAt(i);
+      if (charCode === 41 && group) {
+        break;
+      } else if (charCode === 44) {
+        if (!current) {
+          segmentEnd(
+            basePaths.map((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);
+        }
+        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);
+      }
+    }
+    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;
+        }
+      }
+      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}'.`
+          );
+        }
+        map.set(path4.id, path4);
+      }
+    }
+  }
+}
+
 // src/vite/routes/builder.ts
 var markoFiles = `(${RoutableFileTypes.Layout}|${RoutableFileTypes.Page}|${RoutableFileTypes.NotFound}|${RoutableFileTypes.Error})\\.(?:.*\\.)?(marko)`;
 var nonMarkoFiles = `(${RoutableFileTypes.Middleware}|${RoutableFileTypes.Handler}|${RoutableFileTypes.Meta})\\.(?:.*\\.)?(.+)`;
@@ -222,13 +395,1104 @@ 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(walk, basePath = "") {
+  if (basePath) {
+    basePath = basePath.replace(/^\/+|\/+$/g, "");
+  }
+  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 activeDirs = [root];
+  let nextFileId = 1;
+  let nextRouteIndex = 1;
+  let isBaseDir = true;
+  await walk({
+    onEnter({ name }) {
+      if (!name || isBaseDir) {
+        isBaseDir = false;
+        return;
+      }
+      dirStack.push(name);
+      const previousDirs = activeDirs;
+      const paths = parseFlatRoute(name);
+      activeDirs = VDir.addPaths(previousDirs, paths);
+      return () => {
+        activeDirs = previousDirs;
+        dirStack.pop();
+      };
+    },
+    onFile({ name, path: 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: `${basePath}/${relativePath}`,
+        verbs: type === RoutableFileTypes.Page ? ["get"] : void 0
+      };
+      for (const dir of dirs) {
+        dir.addFile(file);
+      }
+    }
+  });
+  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);
+        }
+      }
+    }
+    if (dir.dirs) {
+      for (const child of dir.dirs()) {
+        traverse(child);
+      }
+    }
+    if (middleware) {
+      currentMiddleware.delete(middleware);
+    }
+    if (layout) {
+      currentLayouts.delete(layout);
+    }
+  }
+}
 
 // src/vite/routes/walk.ts
-import fs from "fs";
+import fs2 from "fs";
 import path from "path";
+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 fs2.promises.readdir(dir2.path, {
+          withFileTypes: true
+        });
+        const prefix = dir2.path + path.sep;
+        for (const entry of entries) {
+          const walkEntry = {
+            name: entry.name,
+            path: prefix + entry.name
+          };
+          if (entry.isDirectory()) {
+            dirs.push(walkEntry);
+          } else {
+            onFile == null ? void 0 : onFile(walkEntry);
+          }
+        }
+        if ((onDir == null ? void 0 : onDir()) !== false && --depth > 0) {
+          for (const entry of dirs) {
+            await walk(entry, depth);
+          }
+        }
+        onExit == null ? void 0 : onExit();
+      }
+    }
+    await walk(
+      {
+        path: dir,
+        name: path.basename(dir)
+      },
+      maxDepth
+    );
+  };
+}
+
+// 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");
+    }
+    if (openWriters.size) {
+      buffer += data;
+    } else {
+      sink(data);
+    }
+    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 (value !== indentLevel) {
+          indentLevel = value;
+          indentString = options.indentWith.repeat(indentLevel);
+        }
+      }
+    },
+    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);
+        }
+        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;
+      }
+      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`
+            );
+          }
+        }
+        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/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) {
+  if (!route.page) {
+    throw new Error(`Route ${route.key} has no page to render`);
+  }
+  const writer = createStringWriter();
+  writer.writeLines(`// ${virtualFilePrefix}/${route.entryName}.marko`);
+  writer.branch("imports");
+  writer.writeLines("");
+  writeRouteTemplateTag(writer, [...route.layouts, route.page]);
+  return writer.end();
+}
+function writeRouteTemplateTag(writer, [file, ...rest], index = 1) {
+  if (file) {
+    const isLast = !rest.length;
+    const tag = isLast ? "page" : `layout${index}`;
+    writer.branch("imports").writeLines(`import ${tag} from './${file.importPath}';`);
+    if (isLast) {
+      writer.writeLines(`<${tag} ...input />`);
+    } else {
+      writer.writeBlockStart(`<${tag} ...input>`);
+      writeRouteTemplateTag(writer, rest, index + 1);
+      writer.writeBlockEnd(`</>`);
+    }
+  }
+}
+function renderRouteEntry(route) {
+  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 (runtimeImports.length) {
+    imports.writeLines(
+      `import { ${runtimeImports.join(", ")} } from '${virtualRuntimePrefix}';`
+    );
+  }
+  if (middleware.length) {
+    const names = middleware.map((m) => `mware${m.id}`);
+    imports.writeLines(
+      `import { ${names.join(
+        ", "
+      )} } from '${virtualFilePrefix}/${markoRunFilePrefix}middleware.js';`
+    );
+  }
+  if ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.length) {
+    writer.writeLines("");
+    const names = [];
+    for (const verb of handler.verbs) {
+      const importName = verb.toUpperCase();
+      names.push(importName);
+      writer.writeLines(`const ${verb}Handler = normalize(${importName});`);
+    }
+    imports.writeLines(
+      `import { ${names.join(", ")} } from './${handler.importPath}';`
+    );
+  }
+  if (page) {
+    imports.writeLines(
+      `import page from '${virtualFilePrefix}/${entryName}.marko${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;
+    }
+  } 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`);
+  }
+  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("}");
+}
+function renderRouter(routes, options = {
+  trailingSlashes: "RedirectWithout"
+}) {
+  const writer = createStringWriter();
+  writer.writeLines(`// @marko/run/router`);
+  const imports = writer.branch("imports");
+  imports.writeLines(
+    `import { NotHandled, NotMatched, createContext } from 'virtual:marko-run/internal';`
+  );
+  for (const route of routes.list) {
+    const verbs = getVerbs(route);
+    const names = verbs.map((verb) => `${verb}${route.index}`);
+    route.meta && names.push(`meta${route.index}`);
+    imports.writeLines(
+      `import { ${names.join(", ")} } from '${virtualFilePrefix}/${route.entryName}.js';`
+    );
+  }
+  for (const { key, entryName } of Object.values(routes.special)) {
+    imports.writeLines(
+      `import page${key} from '${virtualFilePrefix}/${entryName}.marko${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.toLowerCase()) {`);
+  for (const verb of httpVerbs) {
+    const filteredRoutes = routes.list.filter((route) => hasVerb(route, verb));
+    if (filteredRoutes.length) {
+      const trie = createRouteTrie(filteredRoutes);
+      writer.writeBlockStart(`case '${verb}': {`);
+      writeRouterVerb(writer, trie, verb);
+      writer.writeBlockEnd("}");
+    }
+  }
+  writer.writeBlockEnd("}").writeLines("return null;").writeBlockEnd("}");
+  writer.write(`
+export async function invoke(route, request, platform, url) {
+  const [context, buildInput] = createContext(route, request, platform, url);
+	try {
+		if (route) {
+      try {
+				const response = await route.handler(context, buildInput);
+				if (response) return response;
+			} catch (error) {
+				if (error === NotHandled) {
+					return;
+				} else if (error !== NotMatched) {
+					throw error;
+				}
+			}
+`);
+  if (routes.special[RoutableFileTypes.NotFound]) {
+    writer.indent = 2;
+    imports.writeLines(
+      `
+const page404ResponseInit = {
+  status: 404,
+  headers: { "content-type": "text/html;charset=UTF-8" },
+};`
+    );
+    writer.write(
+      `    } else {
+    }
+    if (context.request.headers.get('Accept')?.includes('text/html')) {
+      return new Response(page404.stream(buildInput()), page404ResponseInit);
+    }
+`
+    );
+  } else {
+    writer.indent = 3;
+    writer.writeBlockEnd("}");
+  }
+  writer.indent--;
+  writer.writeBlockStart(`} catch (error) {`);
+  if (routes.special[RoutableFileTypes.Error]) {
+    imports.writeLines(`
+const page500ResponseInit = {
+  status: 500,
+  headers: { "content-type": "text/html;charset=UTF-8" },
+};`);
+    writer.writeBlockStart(
+      `if (context.request.headers.get('Accept')?.includes('text/html')) {`
+    ).writeLines(
+      `return new Response(page500.stream(buildInput({ error })), page500ResponseInit);`
+    ).writeBlockEnd("}");
+  }
+  writer.writeLines(`throw error;`).writeBlockEnd("}").writeBlockEnd("}").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(`   
+
+    const route = match(request.method, pathname);
+    return await invoke(route, request, platform, url);
+  } catch (error) {
+    const body = import.meta.env.DEV
+      ? error.stack || error.message || "Internal Server Error"
+      : null;
+    return new Response(body, {
+      status: 500
+    });
+  }
+}`);
+  return writer.end();
+}
+function writeRouterVerb(writer, trie, verb, level = 0, 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++;
+    }
+  }
+  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 (child.static || child.dynamic || child.catchAll) {
+          (children ?? (children = [])).push(child);
+        }
+      }
+    }
+    if (terminal || (dynamic == null ? void 0 : dynamic.route)) {
+      closeCount++;
+      writer.writeBlockStart(`if (!${index} || ${index} === len) {`);
+      let value = `decodeURIComponent(pathname.slice(${offset}, ${index} ? -1 : len))`;
+      if (dynamic == null ? void 0 : dynamic.route) {
+        const segment = `s${next}`;
+        writer.writeLines(`const ${segment} = ${value};`);
+        value = segment;
+      }
+      if (terminal) {
+        const useSwitch = terminal.length > 1;
+        if (useSwitch) {
+          writer.writeBlockStart(`switch (${value}.toLowerCase()) {`);
+        }
+        for (const { key, path: path4, route: route2 } of terminal) {
+          if (useSwitch) {
+            writer.write(`case '${key}': `, true);
+          } else {
+            writer.write(`if (${value}.toLowerCase() === '${key}') `, true);
+          }
+          writer.write(
+            `return ${renderMatch(verb, route2, path4)}; // ${path4.path}
+`
+          );
+        }
+        if (useSwitch) {
+          writer.writeBlockEnd("}");
+        }
+      }
+      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 = `decodeURIComponent(pathname.slice(${offset}, ${index} - 1))`;
+      if ((dynamic == null ? void 0 : dynamic.static) || (dynamic == null ? void 0 : dynamic.dynamic)) {
+        const segment = `s${next}`;
+        writer.writeLines(`const ${segment} = ${value};`);
+        value = segment;
+      }
+      if (children) {
+        const useSwitch = children.length > 1;
+        if (useSwitch) {
+          writer.writeBlockStart(`switch (${value}.toLowerCase()) {`);
+        }
+        for (const child of children) {
+          const decodedKey = decodeURIComponent(child.key);
+          if (useSwitch) {
+            writer.writeBlockStart(`case '${decodedKey}': {`);
+          } else {
+            writer.writeBlockStart(
+              `if (${value}.toLowerCase() === '${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 ((dynamic == null ? void 0 : dynamic.static) || (dynamic == null ? void 0 : dynamic.dynamic) || (dynamic == null ? void 0 : dynamic.catchAll)) {
+        writer.writeBlockStart(`if (${value}) {`);
+        writeRouterVerb(writer, dynamic, verb, next, index);
+        writer.writeBlockEnd(`}`);
+      }
+    }
+  }
+  while (closeCount--) {
+    writer.writeBlockEnd("}");
+  }
+  if (catchAll) {
+    writer.writeLines(
+      `return ${renderMatch(verb, catchAll.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;
+    }
+  }
+  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 'virtual:marko-run/internal';`);
+  writer.writeLines("");
+  for (const { id, importPath } of middleware) {
+    const importName = `middleware${id}`;
+    imports.writeLines(`import ${importName} from './${importPath}';`);
+    writer.writeLines(`export const mware${id} = normalize(${importName});`);
+  }
+  imports.join();
+  return writer.end();
+}
+function stripTsExtension(path4) {
+  const index = path4.lastIndexOf(".");
+  if (index !== -1) {
+    const ext = path4.slice(index + 1);
+    if (ext.toLowerCase() === "ts") {
+      return path4.slice(0, index);
+    }
+  }
+  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 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} {}
+`);
+    }
+  }
+  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}"];`);
+    }
+    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);
+          }
+        }
+      }
+    }
+  }
+  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;
+  }`
+        );
+        break;
+      case RoutableFileTypes.NotFound:
+        writeModuleDeclaration(writer, path4, "Run.Route");
+        break;
+    }
+  }
+  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.relativePath)) {
+          metaType += `["default"]`;
+        }
+        routeType += ` meta: ${metaType};`;
+      }
+      writer.writeLines(`"${route.key}": ${routeType} };`);
+    }
+  }
+  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>;
+    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: ""
+        });
+      } 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 = path4);
+    node.route ?? (node.route = route);
+  }
+  for (const route of routes) {
+    for (const path4 of route.paths) {
+      insert(path4, route);
+    }
+  }
+  return root;
+}
 
 // src/vite/utils/ast.ts
 import * as t from "@babel/types";
+function getExportIdentifiers(astProgramNode) {
+  const result = [];
+  if (t.isProgram(astProgramNode)) {
+    for (const node of astProgramNode.body) {
+      if (t.isExportNamedDeclaration(node)) {
+        const { declaration, specifiers } = node;
+        if (declaration) {
+          if (t.isFunctionDeclaration(declaration) && declaration.id) {
+            result.push(declaration.id.name);
+          } else if (t.isVariableDeclaration(declaration)) {
+            for (const declarator of declaration.declarations) {
+              if (t.isIdentifier(declarator.id)) {
+                result.push(declarator.id.name);
+              }
+            }
+          }
+        } else if (specifiers) {
+          for (const specifier of specifiers) {
+            if (t.isExportSpecifier(specifier) && t.isIdentifier(specifier.exported)) {
+              result.push(specifier.exported.name);
+            }
+          }
+        }
+      } else if (t.isExportDefaultDeclaration(node)) {
+        const { declaration } = node;
+        if (t.isObjectExpression(declaration)) {
+          for (const property of declaration.properties) {
+            if (t.isObjectMember(property) && t.isIdentifier(property.key)) {
+              result.push(property.key.name);
+            }
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
 
 // src/vite/utils/log.ts
 import zlib from "node:zlib";
@@ -243,26 +1507,585 @@ var HttpVerbColors = {
   delete: kleur.red,
   other: kleur.white
 };
+var HttpVerbOrder = {
+  get: 0,
+  post: 1,
+  put: 2,
+  delete: 3
+};
+function logRoutesTable(routes, bundle, options) {
+  function getRouteChunkName(route) {
+    return options.sanitizeFileName(`${route.entryName}.marko`);
+  }
+  const hasMiddleware = routes.list.some((route) => route.middleware.length);
+  const hasMeta = routes.list.some((route) => route.meta);
+  const headings = ["Method", "Path", "Entry"];
+  const colAligns = ["left", "left", "left"];
+  if (hasMiddleware) {
+    headings.push("MW");
+    colAligns.push("right");
+  }
+  if (hasMeta) {
+    headings.push("Meta");
+    colAligns.push("center");
+  }
+  headings.push("Size/GZip");
+  colAligns.push("right");
+  const table = new Table({
+    head: headings.map((title) => kleur.bold(kleur.white(title.toUpperCase()))),
+    wordWrap: true,
+    colAligns,
+    style: { compact: true }
+  });
+  for (const route of routes.list) {
+    for (const path4 of route.paths) {
+      const verbs = getVerbs(route).sort(
+        (a, b) => HttpVerbOrder[a] - HttpVerbOrder[b]
+      );
+      let firstRow = true;
+      for (const verb of verbs) {
+        let size = "";
+        const entryType = [];
+        if (route.handler) {
+          entryType.push(kleur.blue("handler"));
+        }
+        if (verb === "get" && route.page) {
+          entryType.push(kleur.yellow("page"));
+          size = prettySize(computeRouteSize(getRouteChunkName(route), bundle));
+        }
+        const row = [kleur.bold(HttpVerbColors[verb](verb.toUpperCase()))];
+        if (verbs.length === 1 || firstRow) {
+          row.push({ rowSpan: verbs.length, content: prettyPath(path4.path) });
+          firstRow = false;
+        }
+        row.push(entryType.join(" -> "));
+        hasMiddleware && row.push(route.middleware.length || "");
+        hasMeta && row.push(route.meta ? "\u2713" : "");
+        row.push(size || "");
+        table.push(row);
+      }
+    }
+  }
+  for (const [key, route] of Object.entries(routes.special).sort()) {
+    const row = [kleur.bold(kleur.white("*")), key, kleur.yellow("page")];
+    hasMiddleware && row.push("");
+    hasMeta && row.push("");
+    row.push(prettySize(computeRouteSize(getRouteChunkName(route), bundle)));
+    table.push(row);
+  }
+  console.log(table.toString());
+}
+function computeRouteSize(entryName, bundle) {
+  for (const chunk of Object.values(bundle)) {
+    if (chunk.type === "chunk" && chunk.isEntry && chunk.name === entryName) {
+      return computeChunkSize(chunk, bundle);
+    }
+  }
+  return [0, 0];
+}
+function gzipSize(source) {
+  return zlib.gzipSync(source, { level: 9 }).length;
+}
+function byteSize(source) {
+  return new Blob([source]).size;
+}
+function computeChunkSize(chunk, bundle, seen = /* @__PURE__ */ new Set()) {
+  if (chunk.type === "asset") {
+    return [
+      byteSize(chunk.source),
+      gzipSize(chunk.source)
+    ];
+  }
+  const size = [byteSize(chunk.code), gzipSize(chunk.code)];
+  for (const id of chunk.imports) {
+    if (!seen.has(id)) {
+      const [bytes, compBytes] = computeChunkSize(bundle[id], bundle, seen);
+      size[0] += bytes;
+      size[1] += compBytes;
+      seen.add(id);
+    }
+  }
+  return size;
+}
+function prettySize([bytes, compBytes]) {
+  if (bytes <= 0) {
+    return kleur.gray("0.0 kB");
+  }
+  const [size, prefix] = format(bytes, { decimals: 1 }).split(/\s+/);
+  const compSize = format(compBytes, { decimals: 1, prefix, unit: "B" });
+  let str = kleur.white(size) + kleur.gray("/");
+  if (compBytes < 20 * 1e3)
+    str += kleur.green(compSize);
+  else if (compBytes < 50 * 1e3)
+    str += kleur.yellow(compSize);
+  else
+    str += kleur.bold(kleur.red(compSize));
+  return str;
+}
+function prettyPath(path4) {
+  return path4.replace(/\/\$\$(.*)$/, (_, p) => "/" + kleur.bold(kleur.dim(`*${p}`))).replace(/\/\$([^/]+)/g, (_, p) => "/" + kleur.bold(kleur.dim(`:${p}`)));
+}
 
 // src/vite/plugin.ts
 import { fileURLToPath } from "url";
 var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var PLUGIN_NAME_PREFIX = "marko-run-vite";
 var POSIX_SEP = "/";
 var WINDOWS_SEP = "\\";
 var normalizePath = path2.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
+function markoRun(opts = {}) {
+  let { routesDir, adapter, ...markoVitePluginOptions } = opts;
+  let compiler;
+  let store;
+  let root;
+  let resolvedRoutesDir;
+  let typesDir;
+  let isBuild = false;
+  let isSSRBuild = false;
+  let tsConfigExists;
+  let ssrEntryFiles;
+  let devEntryFile;
+  let devEntryFilePosix;
+  let devServer;
+  let routes;
+  let routeData;
+  let routeDataFilename = "routes.json";
+  let extractVerbs;
+  let resolvedConfig;
+  let typesFile;
+  let isStale = true;
+  let isRendered = false;
+  const virtualFiles = /* @__PURE__ */ new Map();
+  let times = {
+    routesBuild: 0,
+    routesRender: 0
+  };
+  async function writeTypesFile() {
+    if (tsConfigExists ?? (tsConfigExists = await globFileExists(
+      root,
+      "{.tsconfig*,tsconfig*.json}"
+    ))) {
+      const filepath = path2.join(typesDir, "routes.d.ts");
+      const data = await renderRouteTypeInfo(
+        routes,
+        normalizePath(path2.relative(typesDir, resolvedRoutesDir)),
+        adapter
+      );
+      if (data !== typesFile || !fs3.existsSync(filepath)) {
+        await ensureDir(typesDir);
+        await fs3.promises.writeFile(filepath, typesFile = data);
+      }
+    }
+  }
+  async function setVirtualFiles(render = false) {
+    for (const route of routes.list) {
+      if (render && route.handler) {
+        route.handler.verbs = await extractVerbs(route.handler.filePath);
+        if (!route.handler.verbs.length) {
+          console.warn(
+            `Did not find any valid exports in middleware entry file:'${route.handler.filePath}' - expected to find any of 'GET', 'POST', 'PUT' or 'DELETE'`
+          );
+        }
+      }
+      if (route.page) {
+        virtualFiles.set(
+          path2.posix.join(root, `${route.entryName}.marko`),
+          render ? renderRouteTemplate(route) : ""
+        );
+      }
+      virtualFiles.set(
+        path2.posix.join(root, `${route.entryName}.js`),
+        render ? renderRouteEntry(route) : ""
+      );
+    }
+    for (const route of Object.values(routes.special)) {
+      virtualFiles.set(
+        path2.posix.join(root, `${route.entryName}.marko`),
+        render ? renderRouteTemplate(route) : ""
+      );
+    }
+    virtualFiles.set(
+      "@marko/run/router",
+      render ? renderRouter(routes, {
+        trailingSlashes: opts.trailingSlashes || "RedirectWithout"
+      }) : ""
+    );
+    virtualFiles.set(
+      path2.posix.join(root, `${markoRunFilePrefix}middleware.js`),
+      render ? renderMiddleware(routes.middleware) : ""
+    );
+  }
+  const buildVirtualFiles = single(async () => {
+    const startTime = performance.now();
+    routes = await buildRoutes(createFSWalker(resolvedRoutesDir), routesDir);
+    times.routesBuild = performance.now() - startTime;
+    await setVirtualFiles(false);
+    isStale = false;
+    isRendered = false;
+  });
+  const renderVirtualFiles = single(async () => {
+    const startTime = performance.now();
+    await setVirtualFiles(true);
+    await writeTypesFile();
+    times.routesRender = performance.now() - startTime;
+    isRendered = true;
+  });
+  return [
+    {
+      name: `${PLUGIN_NAME_PREFIX}:pre`,
+      enforce: "pre",
+      async config(config2, env) {
+        var _a, _b, _c, _d, _e, _f;
+        const externalPluginOptions = getExternalPluginOptions(config2);
+        if (externalPluginOptions) {
+          opts = mergeConfig(opts, externalPluginOptions);
+        }
+        root = normalizePath(config2.root || process.cwd());
+        isBuild = env.command === "build";
+        isSSRBuild = isBuild && Boolean((_a = config2.build) == null ? void 0 : _a.ssr);
+        adapter = await resolveAdapter(
+          root,
+          opts,
+          config2.logLevel !== "silent" && !isBuild || isSSRBuild
+        );
+        if (adapter) {
+          (_b = adapter.configure) == null ? void 0 : _b.call(adapter, {
+            ...getExternalAdapterOptions(config2),
+            root,
+            isBuild
+          });
+          const adapterOptions = await ((_c = adapter.pluginOptions) == null ? void 0 : _c.call(adapter, opts));
+          if (adapterOptions) {
+            opts = mergeConfig(opts, adapterOptions);
+          }
+        }
+        compiler ?? (compiler = await import(opts.compiler || "@marko/compiler"));
+        compiler.taglib.register("@marko/run", {
+          "<*>": {
+            transform: path2.resolve(
+              __dirname,
+              "../components/src-attributes-transformer.cjs"
+            )
+          }
+        });
+        routesDir = opts.routesDir || "src/routes";
+        markoVitePluginOptions.store = store = opts.store || new FileStore(
+          `marko-serve-vite-${crypto.createHash("SHA1").update(root).digest("hex")}`
+        );
+        markoVitePluginOptions.runtimeId = opts.runtimeId;
+        markoVitePluginOptions.basePathVar = opts.basePathVar;
+        resolvedRoutesDir = path2.resolve(root, routesDir);
+        typesDir = path2.join(root, ".marko-run");
+        devEntryFile = path2.join(root, "index.html");
+        devEntryFilePosix = normalizePath(devEntryFile);
+        const assetsDir = ((_d = config2.build) == null ? void 0 : _d.assetsDir) || "assets";
+        let rollupOutputOptions = (_f = (_e = config2.build) == null ? void 0 : _e.rollupOptions) == null ? void 0 : _f.output;
+        if (isBuild) {
+          const defaultRollupOutputOptions = {
+            assetFileNames({ name }) {
+              if (name && name.indexOf("_marko-virtual_id_") < 0) {
+                return `${assetsDir}/${getEntryFileName(name) || "[name]"}-[hash].[ext]`;
+              }
+              return `${assetsDir}/_[hash].[ext]`;
+            },
+            entryFileNames(info) {
+              let name = getEntryFileName(info.facadeModuleId);
+              if (!name) {
+                for (let id of info.moduleIds) {
+                  name = getEntryFileName(id);
+                  if (name) {
+                    break;
+                  }
+                }
+              }
+              return `${assetsDir}/${name || "[name]"}-[hash].js`;
+            },
+            chunkFileNames: isSSRBuild ? `_[hash].js` : `${assetsDir}/_[hash].js`
+          };
+          if (!rollupOutputOptions) {
+            rollupOutputOptions = defaultRollupOutputOptions;
+          } else if (!Array.isArray(rollupOutputOptions)) {
+            rollupOutputOptions = {
+              ...defaultRollupOutputOptions,
+              ...rollupOutputOptions
+            };
+          } else {
+            rollupOutputOptions = rollupOutputOptions.map((options) => ({
+              ...defaultRollupOutputOptions,
+              ...options
+            }));
+          }
+        }
+        let pluginConfig = {
+          logLevel: isBuild ? "warn" : void 0,
+          define: isBuild ? {
+            "process.env.NODE_ENV": "'production'"
+          } : void 0,
+          ssr: {
+            noExternal: /@marko\/run/
+          },
+          build: {
+            emptyOutDir: isSSRBuild,
+            rollupOptions: {
+              output: rollupOutputOptions
+            }
+          },
+          resolve: isBuild ? {
+            browserField: isSSRBuild ? false : void 0,
+            conditions: [
+              isSSRBuild ? "node" : "browser",
+              "import",
+              "require",
+              "production",
+              "default"
+            ]
+          } : void 0
+        };
+        if (adapter == null ? void 0 : adapter.viteConfig) {
+          const adapterConfig = await adapter.viteConfig(config2);
+          if (adapterConfig) {
+            pluginConfig = mergeConfig(pluginConfig, adapterConfig);
+          }
+        }
+        return setExternalPluginOptions(pluginConfig, opts);
+      },
+      configResolved(config2) {
+        resolvedConfig = config2;
+        const {
+          ssr,
+          rollupOptions: { input }
+        } = config2.build;
+        if (typeof ssr === "string") {
+          ssrEntryFiles = [ssr];
+        } else if (typeof input === "string") {
+          ssrEntryFiles = [input];
+        } else if (Array.isArray(input)) {
+          ssrEntryFiles = input;
+        } else if (input) {
+          ssrEntryFiles = Object.values(input);
+        } else {
+          ssrEntryFiles = [];
+        }
+      },
+      configureServer(_server) {
+        devServer = _server;
+        devServer.watcher.on("all", async (type, filename) => {
+          const routableFileType = matchRoutableFile(path2.parse(filename).base);
+          if (filename.startsWith(resolvedRoutesDir) && routableFileType) {
+            if (type === "add") {
+              isStale = true;
+            } else if (type === "unlink") {
+              isStale = true;
+            } else if (type === "change") {
+              if (routableFileType === RoutableFileTypes.Handler) {
+                isStale = true;
+              }
+            }
+            if (isStale) {
+              for (const id of virtualFiles.keys()) {
+                devServer.watcher.emit("change", id);
+                break;
+              }
+            }
+          }
+        });
+      },
+      async buildStart(_options) {
+        if (isBuild && !isSSRBuild) {
+          try {
+            routeData = JSON.parse(
+              await store.get(routeDataFilename)
+            );
+          } catch {
+            this.error(
+              `You must run the "ssr" build before the "browser" build.`
+            );
+          }
+          routes = routeData.routes;
+          times = routeData.times;
+          for (const { key, code } of routeData.files) {
+            virtualFiles.set(key, code);
+          }
+          isStale = false;
+          isRendered = true;
+        } else {
+          extractVerbs = isBuild ? getVerbsFromFileBuild.bind(null, this) : getVerbsFromFileDev.bind(null, devServer);
+        }
+      },
+      async resolveId(importee, importer) {
+        let resolved;
+        if (importee.startsWith(virtualRuntimePrefix)) {
+          return this.resolve(
+            path2.resolve(__dirname, "../runtime/internal"),
+            importer,
+            { skipSelf: true }
+          );
+        } else if (importee.startsWith(virtualFilePrefix)) {
+          importee = path2.resolve(
+            root,
+            importee.slice(virtualFilePrefix.length + 1)
+          );
+        } else if (!isBuild && importer && (importer === devEntryFile || normalizePath(importer) === devEntryFilePosix) && importee.startsWith(`/${markoRunFilePrefix}`)) {
+          importee = path2.resolve(root, "." + importee);
+        }
+        importee = normalizePath(importee);
+        if (isStale) {
+          await buildVirtualFiles();
+        }
+        if (virtualFiles.has(importee)) {
+          resolved = importee;
+        }
+        return resolved || null;
+      },
+      async load(id) {
+        var _a;
+        if (id.endsWith(serverEntryQuery)) {
+          id = id.slice(0, -serverEntryQuery.length);
+        }
+        if (virtualFiles.has(id)) {
+          if (!isRendered) {
+            await renderVirtualFiles();
+            if (!isBuild) {
+              await ((_a = opts == null ? void 0 : opts.emitRoutes) == null ? void 0 : _a.call(opts, routes.list));
+            }
+          }
+          return virtualFiles.get(id);
+        }
+      }
+    },
+    ...markoVitePlugin(markoVitePluginOptions),
+    {
+      name: `${PLUGIN_NAME_PREFIX}:post`,
+      enforce: "post",
+      generateBundle(options, bundle) {
+        if (options.sourcemap && options.sourcemap !== "inline") {
+          for (const key of Object.keys(bundle)) {
+            if (key.endsWith(".map") && !bundle[key.slice(0, -4)]) {
+              delete bundle[key];
+            }
+          }
+        }
+      },
+      async writeBundle(options, bundle) {
+        var _a;
+        if (isSSRBuild) {
+          const builtEntries = Object.values(bundle).reduce(
+            (acc, item) => {
+              if (item.type === "chunk" && item.isEntry) {
+                acc.push(path2.join(options.dir, item.fileName));
+              }
+              return acc;
+            },
+            []
+          );
+          routeData = {
+            routes,
+            files: [],
+            times,
+            builtEntries,
+            sourceEntries: ssrEntryFiles
+          };
+          for (const [key, code] of virtualFiles) {
+            routeData.files.push({ key, code });
+          }
+          await store.set(routeDataFilename, JSON.stringify(routeData));
+          await ((_a = opts == null ? void 0 : opts.emitRoutes) == null ? void 0 : _a.call(opts, routes.list));
+        } else if (isBuild) {
+          logRoutesTable(routes, bundle, options);
+        }
+      },
+      async closeBundle() {
+        if (isBuild && !isSSRBuild && (adapter == null ? void 0 : adapter.buildEnd)) {
+          await adapter.buildEnd(
+            resolvedConfig,
+            routes.list,
+            routeData.builtEntries,
+            routeData.sourceEntries
+          );
+        }
+      }
+    }
+  ];
+}
+async function getVerbsFromFileBuild(context, filePath) {
+  const verbs = [];
+  const result = await context.load({
+    id: filePath,
+    resolveDependencies: false
+  });
+  if (result) {
+    const exportIds = getExportIdentifiers(result.ast);
+    for (const id of exportIds) {
+      const verb = id.toLowerCase();
+      if (id === verb.toUpperCase() && httpVerbs.includes(verb)) {
+        verbs.push(verb);
+      }
+    }
+  }
+  return verbs;
+}
+async function getVerbsFromFileDev(devServer, filePath) {
+  const verbs = [];
+  const result = await devServer.transformRequest(filePath, { ssr: true });
+  if (result && result.code) {
+    const verbMatchReg = /__vite_ssr_exports__,\s+["'](GET|POST|PUT|DELETE)["']/gi;
+    let match = verbMatchReg.exec(result.code);
+    while (match) {
+      const id = match[1];
+      const verb = id.toLowerCase();
+      if (httpVerbs.includes(verb)) {
+        if (id === verb.toUpperCase()) {
+          verbs.push(verb);
+        } else {
+          console.warn(
+            `Found export '${id}' in handler ${filePath} which is close to '${verb.toUpperCase()}'. Exported handlers need to be uppercase: GET, POST, PUT or DELETE.`
+          );
+        }
+      }
+      match = verbMatchReg.exec(result.code);
+    }
+  }
+  return verbs;
+}
+function single(fn) {
+  let promise;
+  return async (...args) => {
+    if (promise) {
+      return promise;
+    }
+    promise = fn(...args);
+    const result = await promise;
+    promise = void 0;
+    return result;
+  };
+}
+async function globFileExists(root, pattern) {
+  return new Promise((resolve, reject) => {
+    glob(pattern, { root }, (err, matches) => {
+      if (err) {
+        reject(err);
+      }
+      resolve(matches.length > 0);
+    });
+  });
+}
+async function ensureDir(dir) {
+  if (!fs3.existsSync(dir)) {
+    await fs3.promises.mkdir(dir, { recursive: true });
+  }
+}
 async function getPackageData(dir) {
   do {
     const pkgPath = path2.join(dir, "package.json");
-    if (fs2.existsSync(pkgPath)) {
-      return JSON.parse(await fs2.promises.readFile(pkgPath, "utf-8"));
+    if (fs3.existsSync(pkgPath)) {
+      return JSON.parse(await fs3.promises.readFile(pkgPath, "utf-8"));
     }
   } while (dir !== (dir = path2.dirname(dir)));
   return null;
 }
 async function resolveAdapter(root, options, log) {
-  const { adapter } = options;
-  if (adapter !== void 0) {
-    return adapter;
+  if (options && options.adapter !== void 0) {
+    return options.adapter;
   }
   const pkg = await getPackageData(root);
   if (pkg) {
@@ -289,10 +2112,20 @@ async function resolveAdapter(root, options, log) {
   log && console.log("Using default adapter");
   return module.default();
 }
+var markoEntryFileRegex = /__marko-run__([^.]+)\.(.+)\.marko\.([^.]+)$/;
+function getEntryFileName(file) {
+  const match = file && markoEntryFileRegex.exec(file);
+  return match ? match[2] : void 0;
+}
+function isPluginIncluded(config2) {
+  return config2.plugins.some((plugin) => {
+    return plugin.name.startsWith(PLUGIN_NAME_PREFIX);
+  });
+}
 
 // src/cli/commands.ts
 var __dirname2 = path3.dirname(fileURLToPath2(import.meta.url));
-var defaultPort = +process.env.PORT || 3e3;
+var defaultPort = Number(process.env.PORT || 3e3);
 var defaultConfigFileBases = ["serve.config", "vite.config"];
 var defaultConfigFileExts = [".js", ".cjs", ".mjs", ".ts", ".mts"];
 async function preview(entry, cwd, configFile, port, outDir, envFile, args = []) {
@@ -300,10 +2133,10 @@ async function preview(entry, cwd, configFile, port, outDir, envFile, args = [])
     { root: cwd, configFile, logLevel: "silent", build: { outDir } },
     "serve"
   );
-  if (port === void 0) {
-    port = resolvedConfig.preview.port ?? defaultPort;
-  }
-  const adapter = await resolveAdapter2(resolvedConfig);
+  const [availablePort, adapter] = await Promise.all([
+    getAvailablePort(port ?? resolvedConfig.preview.port ?? resolvedConfig.server.port ?? defaultPort),
+    resolveAdapter2(resolvedConfig)
+  ]);
   if (!adapter) {
     throw new Error("No adapter specified for 'serve' command");
   } else if (!adapter.startPreview) {
@@ -318,7 +2151,7 @@ async function preview(entry, cwd, configFile, port, outDir, envFile, args = [])
     cwd,
     dir,
     args,
-    port,
+    port: availablePort,
     envFile
   };
   return await adapter.startPreview(entryFile, options);
@@ -328,13 +2161,13 @@ async function dev(entry, cwd, configFile, port, envFile, args = []) {
     { root: cwd, configFile, logLevel: "silent" },
     "build"
   );
-  if (port === void 0) {
-    port = resolvedConfig.preview.port ?? defaultPort;
-  }
   if (envFile) {
     envFile = path3.resolve(cwd, envFile);
   }
-  const adapter = await resolveAdapter2(resolvedConfig);
+  const [availablePort, adapter] = await Promise.all([
+    getAvailablePort(port ?? resolvedConfig.server.port ?? resolvedConfig.preview.port ?? defaultPort),
+    resolveAdapter2(resolvedConfig)
+  ]);
   if (!adapter) {
     throw new Error(
       "No adapter specified for 'dev' command without custom target"
@@ -344,18 +2177,24 @@ async function dev(entry, cwd, configFile, port, envFile, args = []) {
       `Adapter '${adapter.name}' does not support 'serve' command`
     );
   }
+  const config2 = {
+    root: cwd,
+    configFile,
+    plugins: isPluginIncluded(resolvedConfig) ? void 0 : [markoRun()]
+  };
   const options = {
     cwd,
     args,
-    port,
+    port: availablePort,
     envFile
   };
-  return await adapter.startDev(entry, { root: cwd, configFile }, options);
+  return await adapter.startDev(entry, config2, options);
 }
 async function build(entry, cwd, configFile, outDir, envFile) {
   var _a;
+  const root = cwd;
   const resolvedConfig = await resolveConfig(
-    { root: cwd, configFile, logLevel: "silent" },
+    { root, configFile, logLevel: "silent" },
     "build"
   );
   const adapter = await resolveAdapter2(resolvedConfig);
@@ -374,7 +2213,7 @@ async function build(entry, cwd, configFile, outDir, envFile) {
     envFile = path3.resolve(cwd, envFile);
   }
   let buildConfig = {
-    root: cwd,
+    root,
     configFile,
     build: {
       ssr: false,
@@ -385,10 +2224,14 @@ async function build(entry, cwd, configFile, outDir, envFile) {
     store: new MemoryStore()
   });
   buildConfig = setExternalAdapterOptions(buildConfig, {
+    root,
+    isBuild: true,
     envFile
   });
+  const hasPlugin = isPluginIncluded(resolvedConfig);
   await viteBuild({
     ...buildConfig,
+    plugins: hasPlugin ? void 0 : [markoRun()],
     build: {
       target: "esnext",
       ...buildConfig.build,
@@ -402,6 +2245,7 @@ async function build(entry, cwd, configFile, outDir, envFile) {
   });
   await viteBuild({
     ...buildConfig,
+    plugins: hasPlugin ? void 0 : [markoRun()],
     build: {
       ...buildConfig.build,
       sourcemap: true
@@ -411,7 +2255,7 @@ async function build(entry, cwd, configFile, outDir, envFile) {
 function findFileWithExt(dir, base, extensions = defaultConfigFileExts) {
   for (const ext of extensions) {
     const filePath = path3.join(dir, base + ext);
-    if (fs3.existsSync(filePath)) {
+    if (fs4.existsSync(filePath)) {
       return filePath;
     }
   }
@@ -420,7 +2264,7 @@ function findFileWithExt(dir, base, extensions = defaultConfigFileExts) {
 async function getViteConfig(dir, configFile, bases = defaultConfigFileBases) {
   if (configFile) {
     const configFilePath = path3.join(dir, configFile);
-    if (!fs3.existsSync(configFilePath)) {
+    if (!fs4.existsSync(configFilePath)) {
       throw new Error(`No config file found at '${configFilePath}'`);
     }
     return configFile;
@@ -433,12 +2277,9 @@ async function getViteConfig(dir, configFile, bases = defaultConfigFileBases) {
   }
   return path3.join(__dirname2, "default.config.mjs");
 }
-async function resolveAdapter2(config) {
-  const options = getExternalPluginOptions(config);
-  if (!options) {
-    throw new Error("Unable to resolve @marko/run options");
-  }
-  return resolveAdapter(config.root, options);
+async function resolveAdapter2(config2) {
+  const options = getExternalPluginOptions(config2);
+  return resolveAdapter(config2.root, options);
 }
 
 // src/cli/index.ts
@@ -458,12 +2299,12 @@ prog.command("preview [entry]").describe("Start a production-like server for alr
   process.env.NODE_ENV = "production";
   const cwd = process.cwd();
   const args = process.argv.slice(entry ? 4 : 3);
-  const config = await getViteConfig(cwd, opts.config);
-  await build(entry, cwd, config, opts.output, opts.env);
+  const config2 = await getViteConfig(cwd, opts.config);
+  await build(entry, cwd, config2, opts.output, opts.env);
   await preview(
     opts.file,
     cwd,
-    config,
+    config2,
     opts.port,
     opts.output,
     opts.env,
@@ -476,15 +2317,15 @@ prog.command("dev [entry]", "", { default: true }).describe("Start development s
 ).example("dev --config vite.config.js").action(async (entry, opts) => {
   const cwd = process.cwd();
   const args = process.argv.slice(entry ? 4 : 3);
-  const config = await getViteConfig(cwd, opts.config);
-  await dev(entry, cwd, config, opts.port, opts.env, args);
+  const config2 = await getViteConfig(cwd, opts.config);
+  await dev(entry, cwd, config2, opts.port, opts.env, args);
 });
 prog.command("build [entry]").describe("Build the application (without serving it)").option(
   "-o, --output",
   "Directory to write built files (default: 'build.outDir' in Vite config)"
 ).example("build --config vite.config.js").action(async (entry, opts) => {
   const cwd = process.cwd();
-  const config = await getViteConfig(cwd, opts.config);
-  await build(entry, cwd, config, opts.ouput, opts.env);
+  const config2 = await getViteConfig(cwd, opts.config);
+  await build(entry, cwd, config2, opts.ouput, opts.env);
 });
 prog.parse(process.argv);