@marko/run 0.2.18 → 0.3.1

package/dist/vite/index.cjs

@@ -68,9 +68,8 @@ var import_url = require("url");
 var __importMetaURL = (0, import_url.pathToFileURL)(__filename);
 
 // src/vite/plugin.ts
-var import_path2 = __toESM(require("path"), 1);
-var import_crypto = __toESM(require("crypto"), 1);
-var import_fs2 = __toESM(require("fs"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var import_fs3 = __toESM(require("fs"), 1);
 var import_glob = require("glob");
 var import_url2 = require("url");
 var import_browserslist = __toESM(require("browserslist"), 1);
@@ -157,10 +156,10 @@ var _VDir = class _VDir {
     });
     return value;
   }
-  addDir(path3, segment) {
+  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, path3);
+      const dir = new _VDir(this, segment, path4);
       map.set(segment.name, dir);
       return dir;
     }
@@ -206,10 +205,10 @@ var _VDir = class _VDir {
     const dirs = [];
     const unique = /* @__PURE__ */ new Set();
     for (const root of roots) {
-      for (const path3 of paths) {
+      for (const path4 of paths) {
         let dir = root;
-        for (const segment of path3.segments) {
-          dir = dir.addDir(path3, segment);
+        for (const segment of path4.segments) {
+          dir = dir.addDir(path4, segment);
         }
         if (unique.has(dir.path)) {
           const sources = /* @__PURE__ */ new Set();
@@ -221,7 +220,7 @@ var _VDir = class _VDir {
             }
           }
           throw new Error(
-            `Ambiguous directory structure: '${sourcePath}${path3.source}' defines '${dir.path}' multiple times.`
+            `Ambiguous directory structure: '${sourcePath}${path4.source}' defines '${dir.path}' multiple times.`
           );
         } else {
           unique.add(dir.path);
@@ -263,9 +262,9 @@ function parseFlatRoute(pattern) {
       } else if (charCode === 44) {
         if (!current) {
           segmentEnd(
-            basePaths.map((path3) => ({
-              ...path3,
-              segments: path3.segments.slice()
+            basePaths.map((path4) => ({
+              ...path4,
+              segments: path4.segments.slice()
             })),
             "",
             "_",
@@ -295,9 +294,9 @@ function parseFlatRoute(pattern) {
         } else if (charCode === 36) {
           type = pattern.charCodeAt(i + 1) === 36 ? "$$" : "$";
         }
-        current ?? (current = basePaths.map((path3) => ({
-          ...path3,
-          segments: path3.segments.slice()
+        current ?? (current = basePaths.map((path4) => ({
+          ...path4,
+          segments: path4.segments.slice()
         })));
         i = len;
         for (const char of delimiters) {
@@ -317,9 +316,9 @@ function parseFlatRoute(pattern) {
     }
     if (!current) {
       segmentEnd(
-        basePaths.map((path3) => ({
-          ...path3,
-          segments: path3.segments.slice()
+        basePaths.map((path4) => ({
+          ...path4,
+          segments: path4.segments.slice()
         })),
         "",
         "_",
@@ -343,9 +342,9 @@ function parseFlatRoute(pattern) {
         segment.param = raw.slice(type.length);
       }
     }
-    for (const path3 of paths) {
+    for (const path4 of paths) {
       if (segment) {
-        if (path3.isCatchall) {
+        if (path4.isCatchall) {
           throw new Error(
             `Invalid route pattern: nested segments are not allowed after a catch-all parameter. Found '.' following '${pattern.slice(
               0,
@@ -353,22 +352,22 @@ function parseFlatRoute(pattern) {
             )}' in '${pattern}'.`
           );
         }
-        path3.segments.push(segment);
-        path3.id += path3.id === "/" ? segment.name : `/${segment.name}`;
+        path4.segments.push(segment);
+        path4.id += path4.id === "/" ? segment.name : `/${segment.name}`;
         if (type === "$$") {
-          path3.isCatchall = true;
+          path4.isCatchall = true;
         }
       }
       if (map) {
-        if (map.has(path3.id)) {
-          const existing = map.get(path3.id);
+        if (map.has(path4.id)) {
+          const existing = map.get(path4.id);
           const existingExpansion = existing.segments.map((s) => s.raw).join(".");
-          const currentExpansion = path3.segments.map((s) => s.raw).join(".");
+          const currentExpansion = path4.segments.map((s) => s.raw).join(".");
           throw new Error(
-            `Invalid route pattern: route '${path3.id}' is ambiguous. Expansion '${currentExpansion}' collides with '${existingExpansion}' in '${pattern}'.`
+            `Invalid route pattern: route '${path4.id}' is ambiguous. Expansion '${currentExpansion}' collides with '${existingExpansion}' in '${pattern}'.`
           );
         }
-        map.set(path3.id, path3);
+        map.set(path4.id, path4);
       }
     }
   }
@@ -424,7 +423,7 @@ async function buildRoutes(sources) {
         dirStack.length = prevDirStackLength;
       };
     },
-    onFile({ name, path: path3 }) {
+    onFile({ name, path: path4 }) {
       const match = name.match(routeableFileRegex);
       if (!match) {
         return;
@@ -432,7 +431,7 @@ async function buildRoutes(sources) {
       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 ${path3}`
+          `Special pages '${RoutableFileTypes.NotFound}' and '${RoutableFileTypes.Error}' are only considered in the root directory - ignoring ${path4}`
         );
         return;
       }
@@ -447,7 +446,7 @@ async function buildRoutes(sources) {
         id: String(nextFileId++),
         name,
         type,
-        filePath: path3,
+        filePath: path4,
         relativePath,
         importPath: `${importPrefix}/${relativePath}`,
         verbs: type === RoutableFileTypes.Page ? ["get"] : void 0
@@ -499,23 +498,23 @@ async function buildRoutes(sources) {
         }
       }
       if (page || handler) {
-        const path3 = dir.pathInfo;
-        if (uniqueRoutes.has(path3.id)) {
-          const existing = uniqueRoutes.get(path3.id);
+        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 '${path3.path}' were defined. A route established by:
+          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(path3.id, { dir, index: routes.length });
+        uniqueRoutes.set(path4.id, { dir, index: routes.length });
         routes.push({
           index: nextRouteIndex++,
           key: dir.fullPath,
-          paths: [path3],
+          paths: [path4],
           middleware: [...currentMiddleware],
           layouts: page ? [...currentLayouts] : [],
           meta: dir.files.get(RoutableFileTypes.Meta),
@@ -1178,7 +1177,7 @@ function writeRouterVerb(writer, trie, verb, level = 0, offset = 1) {
         if (useSwitch) {
           writer.writeBlockStart(`switch (${value}) {`);
         }
-        for (const { key, path: path3, route: route2 } of terminal) {
+        for (const { key, path: path4, route: route2 } of terminal) {
           const decodedKey = decodeURIComponent(key);
           if (useSwitch) {
             writer.write(`case '${decodedKey}': `, true);
@@ -1186,7 +1185,7 @@ function writeRouterVerb(writer, trie, verb, level = 0, offset = 1) {
             writer.write(`if (${value} === '${decodedKey}') `, true);
           }
           writer.write(
-            `return ${renderMatch(verb, route2, path3)}; // ${path3.path}
+            `return ${renderMatch(verb, route2, path4)}; // ${path4.path}
 `
           );
         }
@@ -1291,11 +1290,11 @@ function renderParams(params, pathIndex) {
   }
   return result ? result + " }" : "{}";
 }
-function renderMatch(verb, route, path3, pathIndex) {
+function renderMatch(verb, route, path4, pathIndex) {
   const handler = `${verb}${route.index}`;
-  const params = path3.params ? renderParams(path3.params, pathIndex) : "{}";
+  const params = path4.params ? renderParams(path4.params, pathIndex) : "{}";
   const meta = route.meta ? `meta${route.index}` : "{}";
-  const pathPattern = pathToURLPatternString(path3.path);
+  const pathPattern = pathToURLPatternString(path4.path);
   return `{ handler: ${handler}, params: ${params}, meta: ${meta}, path: '${pathPattern}' }`;
 }
 function renderMiddleware(middleware) {
@@ -1316,15 +1315,15 @@ function renderMiddleware(middleware) {
   imports.join();
   return writer.end();
 }
-function stripTsExtension(path3) {
-  const index = path3.lastIndexOf(".");
+function stripTsExtension(path4) {
+  const index = path4.lastIndexOf(".");
   if (index !== -1) {
-    const ext = path3.slice(index + 1);
+    const ext = path4.slice(index + 1);
     if (ext.toLowerCase() === "ts") {
-      return path3.slice(0, index);
+      return path4.slice(0, index);
     }
   }
-  return path3;
+  return path4;
 }
 async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
   var _a, _b;
@@ -1356,8 +1355,8 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
   const routeTypes = /* @__PURE__ */ new Map();
   for (const route of routes.list) {
     let routeType = "";
-    for (const path3 of route.paths) {
-      const pathType = `"${pathToURLPatternString(path3.path)}"`;
+    for (const path4 of route.paths) {
+      const pathType = `"${pathToURLPatternString(path4.path)}"`;
       routeType += routeType ? " | " + pathType : pathType;
       routesWriter.writeLines(`${pathType}: Routes["${route.key}"];`);
     }
@@ -1393,22 +1392,22 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
   const pageWriter = writer.branch("page");
   const layoutWriter = writer.branch("layout");
   for (const [file, types] of routeTypes) {
-    const path3 = `${pathPrefix}/${file.relativePath}`;
+    const path4 = `${pathPrefix}/${file.relativePath}`;
     const routeType = `Run.Routes[${types.join(" | ")}]`;
     switch (file.type) {
       case RoutableFileTypes.Handler:
-        writeModuleDeclaration(handlerWriter, path3, routeType);
+        writeModuleDeclaration(handlerWriter, path4, routeType);
         break;
       case RoutableFileTypes.Middleware:
-        writeModuleDeclaration(middlewareWriter, path3, routeType);
+        writeModuleDeclaration(middlewareWriter, path4, routeType);
         break;
       case RoutableFileTypes.Page:
-        writeModuleDeclaration(pageWriter, path3, routeType);
+        writeModuleDeclaration(pageWriter, path4, routeType);
         break;
       case RoutableFileTypes.Layout:
         writeModuleDeclaration(
           layoutWriter,
-          path3,
+          path4,
           routeType,
           `
   export interface Input {
@@ -1419,7 +1418,7 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
       case RoutableFileTypes.Error:
         writeModuleDeclaration(
           writer,
-          path3,
+          path4,
           "globalThis.MarkoRun.Route",
           `
   export interface Input {
@@ -1428,7 +1427,7 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
         );
         break;
       case RoutableFileTypes.NotFound:
-        writeModuleDeclaration(writer, path3, "Run.Route");
+        writeModuleDeclaration(writer, path4, "Run.Route");
         break;
     }
   }
@@ -1463,13 +1462,13 @@ type Routes = {`);
   writer.writeBlockEnd("}");
   return writer.end();
 }
-function writeModuleDeclaration(writer, path3, routeType, moduleTypes) {
-  writer.writeLines("").write(`declare module "${stripTsExtension(path3)}" {`);
+function writeModuleDeclaration(writer, path4, routeType, moduleTypes) {
+  writer.writeLines("").write(`declare module "${stripTsExtension(path4)}" {`);
   if (moduleTypes) {
     writer.write(moduleTypes);
   }
   if (routeType) {
-    const isMarko = path3.endsWith(".marko");
+    const isMarko = path4.endsWith(".marko");
     writer.write(`
   namespace MarkoRun {
     export { NotHandled, NotMatched, GetPaths, PostPaths, GetablePath, GetableHref, PostablePath, PostableHref, Platform };
@@ -1482,8 +1481,8 @@ function writeModuleDeclaration(writer, path3, routeType, moduleTypes) {
   writer.writeLines(`
 }`);
 }
-function pathToURLPatternString(path3) {
-  return path3.replace(/\/\$(\$?)([^\/]*)/g, (_, catchAll, name) => {
+function pathToURLPatternString(path4) {
+  return path4.replace(/\/\$(\$?)([^\/]*)/g, (_, catchAll, name) => {
     name = decodeURIComponent(name);
     return catchAll ? `/:${name || "rest"}*` : `/:${name}`;
   });
@@ -1492,11 +1491,11 @@ function createRouteTrie(routes) {
   const root = {
     key: ""
   };
-  function insert(path3, route) {
+  function insert(path4, route) {
     let node = root;
-    for (const segment of path3.segments) {
+    for (const segment of path4.segments) {
       if (segment === "$$") {
-        node.catchAll ?? (node.catchAll = { route, path: path3 });
+        node.catchAll ?? (node.catchAll = { route, path: path4 });
         return;
       } else if (segment === "$") {
         node = node.dynamic ?? (node.dynamic = {
@@ -1514,12 +1513,12 @@ function createRouteTrie(routes) {
         node = next;
       }
     }
-    node.path ?? (node.path = path3);
+    node.path ?? (node.path = path4);
     node.route ?? (node.route = route);
   }
   for (const route of routes) {
-    for (const path3 of route.paths) {
-      insert(path3, route);
+    for (const path4 of route.paths) {
+      insert(path4, route);
     }
   }
   return root;
@@ -1609,7 +1608,7 @@ function logRoutesTable(routes, bundle, options) {
     style: { compact: true }
   });
   for (const route of routes.list) {
-    for (const path3 of route.paths) {
+    for (const path4 of route.paths) {
       const verbs = getVerbs(route).sort(
         (a, b) => HttpVerbOrder[a] - HttpVerbOrder[b]
       );
@@ -1628,7 +1627,7 @@ function logRoutesTable(routes, bundle, options) {
           import_kleur.default.bold(HttpVerbColors[verb](verb.toUpperCase()))
         ];
         if (verbs.length === 1 || firstRow) {
-          row.push({ rowSpan: verbs.length, content: prettyPath(path3.path) });
+          row.push({ rowSpan: verbs.length, content: prettyPath(path4.path) });
           firstRow = false;
         }
         row.push(entryType.join(" -> "));
@@ -1692,8 +1691,8 @@ function prettySize([bytes, compBytes]) {
     str += import_kleur.default.bold(import_kleur.default.red(compSize));
   return str;
 }
-function prettyPath(path3) {
-  return path3.replace(/\/\$\$(.*)$/, (_, p) => "/" + import_kleur.default.bold(import_kleur.default.dim(`*${p}`))).replace(/\/\$([^/]+)/g, (_, p) => "/" + import_kleur.default.bold(import_kleur.default.dim(`:${p}`)));
+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
@@ -1712,12 +1711,60 @@ var getExternalAdapterOptions = (viteConfig) => getConfig(viteConfig, AdapterCon
 
 // 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 noop = () => {
+};
+var tmpFile = import_path2.default.join(import_os.default.tmpdir(), "marko-run-storage.json");
+var values = /* @__PURE__ */ new Map();
+var loadedFromDisk;
+var ReadOncePersistedStore = class {
+  constructor(uid) {
+    this.uid = uid;
+  }
+  write(value) {
+    values.set(this.uid, value);
+  }
+  async read() {
+    const { uid } = this;
+    if (values.has(uid)) {
+      const value = values.get(uid);
+      values.delete(uid);
+      return value;
+    }
+    if (loadedFromDisk === true) {
+      throw new Error(`Value for ${uid} could not be loaded.`);
+    }
+    await (loadedFromDisk || (loadedFromDisk = import_fs2.promises.readFile(tmpFile, "utf-8").then(syncDataFromDisk).catch(finishLoadFromDisk)));
+    return this.read();
+  }
+};
+function syncDataFromDisk(data) {
+  finishLoadFromDisk();
+  import_fs2.promises.unlink(tmpFile).catch(noop);
+  for (const [k, v] of JSON.parse(data)) {
+    values.set(k, v);
+  }
+}
+function finishLoadFromDisk() {
+  loadedFromDisk = true;
+}
+process.once("beforeExit", (code) => {
+  if (code === 0 && values.size) {
+    import_fs2.promises.writeFile(tmpFile, JSON.stringify([...values])).catch(noop);
+  }
+});
+
+// src/vite/plugin.ts
 var debug = (0, import_debug.default)("@marko/run");
-var __dirname = import_path2.default.dirname((0, import_url2.fileURLToPath)(__importMetaURL));
+var __dirname = import_path3.default.dirname((0, import_url2.fileURLToPath)(__importMetaURL));
 var PLUGIN_NAME_PREFIX = "marko-run-vite";
 var POSIX_SEP = "/";
 var WINDOWS_SEP = "\\";
-var normalizePath = import_path2.default.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
+var normalizePath = import_path3.default.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
 function markoRun(opts = {}) {
   let { routesDir, adapter, ...markoVitePluginOptions } = opts;
   let compiler;
@@ -1734,7 +1781,6 @@ function markoRun(opts = {}) {
   let devServer;
   let routes;
   let routeData;
-  let routeDataFilename = "routes.json";
   let extractVerbs;
   let resolvedConfig;
   let typesFile;
@@ -1750,15 +1796,15 @@ function markoRun(opts = {}) {
       root,
       "{.tsconfig*,tsconfig*.json}"
     )))) {
-      const filepath = import_path2.default.join(typesDir, "routes.d.ts");
+      const filepath = import_path3.default.join(typesDir, "routes.d.ts");
       const data = await renderRouteTypeInfo(
         routes2,
-        normalizePath(import_path2.default.relative(typesDir, resolvedRoutesDir)),
+        normalizePath(import_path3.default.relative(typesDir, resolvedRoutesDir)),
         adapter
       );
-      if (data !== typesFile || !import_fs2.default.existsSync(filepath)) {
+      if (data !== typesFile || !import_fs3.default.existsSync(filepath)) {
         await ensureDir(typesDir);
-        await import_fs2.default.promises.writeFile(filepath, typesFile = data);
+        await import_fs3.default.promises.writeFile(filepath, typesFile = data);
       }
     }
   }
@@ -1793,24 +1839,24 @@ function markoRun(opts = {}) {
         }
         if (route.page) {
           virtualFiles.set(
-            import_path2.default.posix.join(root, `${route.entryName}.marko`),
+            import_path3.default.posix.join(root, `${route.entryName}.marko`),
             render ? renderRouteTemplate(route) : ""
           );
         }
         virtualFiles.set(
-          import_path2.default.posix.join(root, `${route.entryName}.js`),
+          import_path3.default.posix.join(root, `${route.entryName}.js`),
           render ? renderRouteEntry(route) : ""
         );
       }
       for (const route of Object.values(routes.special)) {
         virtualFiles.set(
-          import_path2.default.posix.join(root, `${route.entryName}.marko`),
+          import_path3.default.posix.join(root, `${route.entryName}.marko`),
           render ? renderRouteTemplate(route) : ""
         );
       }
       if (routes.middleware.length) {
         virtualFiles.set(
-          import_path2.default.posix.join(root, `${markoRunFilePrefix}middleware.js`),
+          import_path3.default.posix.join(root, `${markoRunFilePrefix}middleware.js`),
           render ? renderMiddleware(routes.middleware) : ""
         );
       }
@@ -1842,7 +1888,7 @@ function markoRun(opts = {}) {
       }
       console.error(err);
       virtualFiles.set(
-        import_path2.default.posix.join(root, `${markoRunFilePrefix}error.marko`),
+        import_path3.default.posix.join(root, `${markoRunFilePrefix}error.marko`),
         renderEntryTemplate(`${markoRunFilePrefix}error`, ["<dev-error-page>"])
       );
       virtualFiles.set(
@@ -1886,25 +1932,25 @@ function markoRun(opts = {}) {
         compiler.taglib.register("@marko/run", {
           "<dev-error-page>": {
             template: normalizePath(
-              import_path2.default.resolve(__dirname, "../components/dev-error-page.marko")
+              import_path3.default.resolve(__dirname, "../components/dev-error-page.marko")
             )
           },
           "<*>": {
-            transform: import_path2.default.resolve(
+            transform: import_path3.default.resolve(
               __dirname,
               "../components/src-attributes-transformer.cjs"
             )
           }
         });
         routesDir = opts.routesDir || "src/routes";
-        markoVitePluginOptions.store = store = opts.store || new import_vite2.FileStore(
-          `marko-serve-vite-${import_crypto.default.createHash("SHA1").update(root).digest("hex")}`
+        store = new ReadOncePersistedStore(
+          `vite-marko-run${opts.runtimeId ? `-${opts.runtimeId}` : ""}`
         );
         markoVitePluginOptions.runtimeId = opts.runtimeId;
         markoVitePluginOptions.basePathVar = opts.basePathVar;
-        resolvedRoutesDir = import_path2.default.resolve(root, routesDir);
-        typesDir = import_path2.default.join(root, ".marko-run");
-        devEntryFile = import_path2.default.join(root, "index.html");
+        resolvedRoutesDir = import_path3.default.resolve(root, routesDir);
+        typesDir = import_path3.default.join(root, ".marko-run");
+        devEntryFile = import_path3.default.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;
@@ -1963,7 +2009,8 @@ function markoRun(opts = {}) {
             // Avoid server & client deleting files from each other.
             rollupOptions: {
               output: rollupOutputOptions
-            }
+            },
+            modulePreload: { polyfill: false }
           },
           optimizeDeps: {
             entries: !((_h = config2.optimizeDeps) == null ? void 0 : _h.entries) ? [
@@ -2013,7 +2060,7 @@ function markoRun(opts = {}) {
       configureServer(_server) {
         devServer = _server;
         devServer.watcher.on("all", async (type, filename) => {
-          const routableFileType = matchRoutableFile(import_path2.default.parse(filename).base);
+          const routableFileType = matchRoutableFile(import_path3.default.parse(filename).base);
           if (filename.startsWith(resolvedRoutesDir) && routableFileType) {
             if (type === "add") {
               isStale = true;
@@ -2036,9 +2083,7 @@ function markoRun(opts = {}) {
       async buildStart(_options) {
         if (isBuild && !isSSRBuild) {
           try {
-            routeData = JSON.parse(
-              await store.get(routeDataFilename)
-            );
+            routeData = await store.read();
           } catch {
             this.error(
               `You must run the "ssr" build before the "browser" build.`
@@ -2060,9 +2105,9 @@ function markoRun(opts = {}) {
         let virtualFilePath;
         if (importee.startsWith(virtualFilePrefix)) {
           virtualFilePath = importee.slice(virtualFilePrefix.length + 1);
-          importee = import_path2.default.resolve(root, virtualFilePath);
+          importee = import_path3.default.resolve(root, virtualFilePath);
         } else if (!isBuild && importer && (importer === devEntryFile || normalizePath(importer) === devEntryFilePosix) && importee.startsWith(`/${markoRunFilePrefix}`)) {
-          importee = import_path2.default.resolve(root, "." + importee);
+          importee = import_path3.default.resolve(root, "." + importee);
         }
         importee = normalizePath(importee);
         if (isStale) {
@@ -2071,7 +2116,7 @@ function markoRun(opts = {}) {
         if (virtualFiles.has(importee)) {
           resolved = importee;
         } else if (virtualFilePath) {
-          const filePath = import_path2.default.resolve(__dirname, "..", virtualFilePath);
+          const filePath = import_path3.default.resolve(__dirname, "..", virtualFilePath);
           const resolution = await this.resolve(filePath, importer, {
             skipSelf: true
           });
@@ -2110,7 +2155,7 @@ function markoRun(opts = {}) {
           const builtEntries = Object.values(bundle).reduce(
             (acc, item) => {
               if (item.type === "chunk" && item.isEntry) {
-                acc.push(import_path2.default.join(options.dir, item.fileName));
+                acc.push(import_path3.default.join(options.dir, item.fileName));
               }
               return acc;
             },
@@ -2126,7 +2171,7 @@ function markoRun(opts = {}) {
           for (const [key, code] of virtualFiles) {
             routeData.files.push({ key, code });
           }
-          await store.set(routeDataFilename, JSON.stringify(routeData));
+          store.write(routeData);
           await ((_a = opts == null ? void 0 : opts.emitRoutes) == null ? void 0 : _a.call(opts, routes.list));
         } else if (process.env.MR_EXPLORER !== "true") {
           logRoutesTable(routes, bundle, options);
@@ -2201,17 +2246,17 @@ async function globFileExists(root, pattern) {
   return (await (0, import_glob.glob)(pattern, { root })).length > 0;
 }
 async function ensureDir(dir) {
-  if (!import_fs2.default.existsSync(dir)) {
-    await import_fs2.default.promises.mkdir(dir, { recursive: true });
+  if (!import_fs3.default.existsSync(dir)) {
+    await import_fs3.default.promises.mkdir(dir, { recursive: true });
   }
 }
 async function getPackageData(dir) {
   do {
-    const pkgPath = import_path2.default.join(dir, "package.json");
-    if (import_fs2.default.existsSync(pkgPath)) {
-      return JSON.parse(await import_fs2.default.promises.readFile(pkgPath, "utf-8"));
+    const pkgPath = import_path3.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_path2.default.dirname(dir)));
+  } while (dir !== (dir = import_path3.default.dirname(dir)));
   return null;
 }
 async function resolveAdapter(root, options, log) {
@@ -2243,21 +2288,21 @@ async function resolveAdapter(root, options, log) {
   log && debug("Using default adapter");
   return module2.default();
 }
-var markoEntryFileRegex = /__marko-run__([^.]+)\.(.+)\.marko\.([^.]+)$/;
+var markoEntryFileRegex = /__marko-run__([^.]+)(?:\.(.+))?\.marko\.([^.]+)$/;
 function getEntryFileName(file) {
   const match = file && markoEntryFileRegex.exec(file);
-  return match ? match[2] : void 0;
+  return match ? match[2] || "index" : void 0;
 }
 
 // src/vite/utils/server.ts
 var import_net = __toESM(require("net"), 1);
 var import_child_process = __toESM(require("child_process"), 1);
 var import_dotenv = require("dotenv");
-var import_fs3 = __toESM(require("fs"), 1);
+var import_fs4 = __toESM(require("fs"), 1);
 var import_cluster = __toESM(require("cluster"), 1);
 async function parseEnv(envFile) {
-  if (import_fs3.default.existsSync(envFile)) {
-    const content = await import_fs3.default.promises.readFile(envFile, "utf8");
+  if (import_fs4.default.existsSync(envFile)) {
+    const content = await import_fs4.default.promises.readFile(envFile, "utf8");
     return (0, import_dotenv.parse)(content);
   }
 }
@@ -2283,10 +2328,7 @@ async function spawnServer(cmd, args = [], port = 0, env, cwd = process.cwd(), w
     proc.kill();
   };
   try {
-    await Promise.race([
-      waitForError(proc, port),
-      waitForServer(port, wait)
-    ]);
+    await Promise.race([waitForError(proc, port), waitForServer(port, wait)]);
   } catch (err) {
     close();
     throw err;
@@ -2300,7 +2342,11 @@ async function waitForError(proc, port) {
   return new Promise((_, reject) => {
     proc.once("error", reject);
     proc.once("exit", (code) => {
-      reject(new Error(`Process exited with code ${code} while waiting for server to start on port "${port}".`));
+      reject(
+        new Error(
+          `Process exited with code ${code} while waiting for server to start on port "${port}".`
+        )
+      );
     });
   });
 }