@marko/run 0.2.17 → 0.3.0

package/dist/vite/index.js

@@ -24,15 +24,14 @@ var __privateSet = (obj, member, value, setter) => {
 };
 
 // src/vite/plugin.ts
-import path2 from "path";
-import crypto from "crypto";
-import fs2 from "fs";
+import path3 from "path";
+import fs3 from "fs";
 import { glob } from "glob";
 import { fileURLToPath } from "url";
 import browserslist from "browserslist";
 import { resolveToEsbuildTarget } from "esbuild-plugin-browserslist";
 import { mergeConfig } from "vite";
-import markoVitePlugin, { FileStore } from "@marko/vite";
+import markoVitePlugin from "@marko/vite";
 
 // src/vite/constants.ts
 var markoRunFilePrefix = "__marko-run__";
@@ -113,10 +112,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;
     }
@@ -162,10 +161,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();
@@ -177,7 +176,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);
@@ -219,9 +218,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()
             })),
             "",
             "_",
@@ -251,9 +250,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) {
@@ -273,9 +272,9 @@ function parseFlatRoute(pattern) {
     }
     if (!current) {
       segmentEnd(
-        basePaths.map((path3) => ({
-          ...path3,
-          segments: path3.segments.slice()
+        basePaths.map((path4) => ({
+          ...path4,
+          segments: path4.segments.slice()
         })),
         "",
         "_",
@@ -299,9 +298,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,
@@ -309,22 +308,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);
       }
     }
   }
@@ -380,7 +379,7 @@ async function buildRoutes(sources) {
         dirStack.length = prevDirStackLength;
       };
     },
-    onFile({ name, path: path3 }) {
+    onFile({ name, path: path4 }) {
       const match = name.match(routeableFileRegex);
       if (!match) {
         return;
@@ -388,7 +387,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;
       }
@@ -403,7 +402,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
@@ -455,23 +454,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),
@@ -1134,7 +1133,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);
@@ -1142,7 +1141,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}
 `
           );
         }
@@ -1247,11 +1246,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) {
@@ -1272,15 +1271,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;
@@ -1312,8 +1311,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}"];`);
     }
@@ -1349,22 +1348,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 {
@@ -1375,7 +1374,7 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
       case RoutableFileTypes.Error:
         writeModuleDeclaration(
           writer,
-          path3,
+          path4,
           "globalThis.MarkoRun.Route",
           `
   export interface Input {
@@ -1384,7 +1383,7 @@ async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
         );
         break;
       case RoutableFileTypes.NotFound:
-        writeModuleDeclaration(writer, path3, "Run.Route");
+        writeModuleDeclaration(writer, path4, "Run.Route");
         break;
     }
   }
@@ -1419,13 +1418,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 };
@@ -1438,8 +1437,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}`;
   });
@@ -1448,11 +1447,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 = {
@@ -1470,12 +1469,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;
@@ -1565,7 +1564,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]
       );
@@ -1584,7 +1583,7 @@ function logRoutesTable(routes, bundle, options) {
           kleur.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(" -> "));
@@ -1648,8 +1647,8 @@ function prettySize([bytes, compBytes]) {
     str += kleur.bold(kleur.red(compSize));
   return str;
 }
-function prettyPath(path3) {
-  return path3.replace(/\/\$\$(.*)$/, (_, p) => "/" + kleur.bold(kleur.dim(`*${p}`))).replace(/\/\$([^/]+)/g, (_, p) => "/" + kleur.bold(kleur.dim(`:${p}`)));
+function prettyPath(path4) {
+  return path4.replace(/\/\$\$(.*)$/, (_, p) => "/" + kleur.bold(kleur.dim(`*${p}`))).replace(/\/\$([^/]+)/g, (_, p) => "/" + kleur.bold(kleur.dim(`:${p}`)));
 }
 
 // src/vite/utils/config.ts
@@ -1668,12 +1667,60 @@ var getExternalAdapterOptions = (viteConfig) => getConfig(viteConfig, AdapterCon
 
 // src/vite/plugin.ts
 import createDebug from "debug";
+
+// src/vite/utils/read-once-persisted-store.ts
+import os from "os";
+import path2 from "path";
+import { promises as fs2 } from "fs";
+var noop = () => {
+};
+var tmpFile = path2.join(os.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 = fs2.readFile(tmpFile, "utf-8").then(syncDataFromDisk).catch(finishLoadFromDisk)));
+    return this.read();
+  }
+};
+function syncDataFromDisk(data) {
+  finishLoadFromDisk();
+  fs2.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) {
+    fs2.writeFile(tmpFile, JSON.stringify([...values])).catch(noop);
+  }
+});
+
+// src/vite/plugin.ts
 var debug = createDebug("@marko/run");
-var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var __dirname = path3.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;
+var normalizePath = path3.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
 function markoRun(opts = {}) {
   let { routesDir, adapter, ...markoVitePluginOptions } = opts;
   let compiler;
@@ -1690,7 +1737,6 @@ function markoRun(opts = {}) {
   let devServer;
   let routes;
   let routeData;
-  let routeDataFilename = "routes.json";
   let extractVerbs;
   let resolvedConfig;
   let typesFile;
@@ -1706,15 +1752,15 @@ function markoRun(opts = {}) {
       root,
       "{.tsconfig*,tsconfig*.json}"
     )))) {
-      const filepath = path2.join(typesDir, "routes.d.ts");
+      const filepath = path3.join(typesDir, "routes.d.ts");
       const data = await renderRouteTypeInfo(
         routes2,
-        normalizePath(path2.relative(typesDir, resolvedRoutesDir)),
+        normalizePath(path3.relative(typesDir, resolvedRoutesDir)),
         adapter
       );
-      if (data !== typesFile || !fs2.existsSync(filepath)) {
+      if (data !== typesFile || !fs3.existsSync(filepath)) {
         await ensureDir(typesDir);
-        await fs2.promises.writeFile(filepath, typesFile = data);
+        await fs3.promises.writeFile(filepath, typesFile = data);
       }
     }
   }
@@ -1749,24 +1795,24 @@ function markoRun(opts = {}) {
         }
         if (route.page) {
           virtualFiles.set(
-            path2.posix.join(root, `${route.entryName}.marko`),
+            path3.posix.join(root, `${route.entryName}.marko`),
             render ? renderRouteTemplate(route) : ""
           );
         }
         virtualFiles.set(
-          path2.posix.join(root, `${route.entryName}.js`),
+          path3.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`),
+          path3.posix.join(root, `${route.entryName}.marko`),
           render ? renderRouteTemplate(route) : ""
         );
       }
       if (routes.middleware.length) {
         virtualFiles.set(
-          path2.posix.join(root, `${markoRunFilePrefix}middleware.js`),
+          path3.posix.join(root, `${markoRunFilePrefix}middleware.js`),
           render ? renderMiddleware(routes.middleware) : ""
         );
       }
@@ -1798,7 +1844,7 @@ function markoRun(opts = {}) {
       }
       console.error(err);
       virtualFiles.set(
-        path2.posix.join(root, `${markoRunFilePrefix}error.marko`),
+        path3.posix.join(root, `${markoRunFilePrefix}error.marko`),
         renderEntryTemplate(`${markoRunFilePrefix}error`, ["<dev-error-page>"])
       );
       virtualFiles.set(
@@ -1842,25 +1888,25 @@ function markoRun(opts = {}) {
         compiler.taglib.register("@marko/run", {
           "<dev-error-page>": {
             template: normalizePath(
-              path2.resolve(__dirname, "../components/dev-error-page.marko")
+              path3.resolve(__dirname, "../components/dev-error-page.marko")
             )
           },
           "<*>": {
-            transform: path2.resolve(
+            transform: path3.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")}`
+        store = new ReadOncePersistedStore(
+          `vite-marko-run${opts.runtimeId ? `-${opts.runtimeId}` : ""}`
         );
         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");
+        resolvedRoutesDir = path3.resolve(root, routesDir);
+        typesDir = path3.join(root, ".marko-run");
+        devEntryFile = path3.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;
@@ -1919,7 +1965,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) ? [
@@ -1969,7 +2016,7 @@ function markoRun(opts = {}) {
       configureServer(_server) {
         devServer = _server;
         devServer.watcher.on("all", async (type, filename) => {
-          const routableFileType = matchRoutableFile(path2.parse(filename).base);
+          const routableFileType = matchRoutableFile(path3.parse(filename).base);
           if (filename.startsWith(resolvedRoutesDir) && routableFileType) {
             if (type === "add") {
               isStale = true;
@@ -1992,9 +2039,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.`
@@ -2016,9 +2061,9 @@ function markoRun(opts = {}) {
         let virtualFilePath;
         if (importee.startsWith(virtualFilePrefix)) {
           virtualFilePath = importee.slice(virtualFilePrefix.length + 1);
-          importee = path2.resolve(root, virtualFilePath);
+          importee = path3.resolve(root, virtualFilePath);
         } else if (!isBuild && importer && (importer === devEntryFile || normalizePath(importer) === devEntryFilePosix) && importee.startsWith(`/${markoRunFilePrefix}`)) {
-          importee = path2.resolve(root, "." + importee);
+          importee = path3.resolve(root, "." + importee);
         }
         importee = normalizePath(importee);
         if (isStale) {
@@ -2027,7 +2072,7 @@ function markoRun(opts = {}) {
         if (virtualFiles.has(importee)) {
           resolved = importee;
         } else if (virtualFilePath) {
-          const filePath = path2.resolve(__dirname, "..", virtualFilePath);
+          const filePath = path3.resolve(__dirname, "..", virtualFilePath);
           const resolution = await this.resolve(filePath, importer, {
             skipSelf: true
           });
@@ -2066,7 +2111,7 @@ function markoRun(opts = {}) {
           const builtEntries = Object.values(bundle).reduce(
             (acc, item) => {
               if (item.type === "chunk" && item.isEntry) {
-                acc.push(path2.join(options.dir, item.fileName));
+                acc.push(path3.join(options.dir, item.fileName));
               }
               return acc;
             },
@@ -2082,7 +2127,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);
@@ -2157,17 +2202,17 @@ async function globFileExists(root, pattern) {
   return (await glob(pattern, { root })).length > 0;
 }
 async function ensureDir(dir) {
-  if (!fs2.existsSync(dir)) {
-    await fs2.promises.mkdir(dir, { recursive: true });
+  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"));
+    const pkgPath = path3.join(dir, "package.json");
+    if (fs3.existsSync(pkgPath)) {
+      return JSON.parse(await fs3.promises.readFile(pkgPath, "utf-8"));
     }
-  } while (dir !== (dir = path2.dirname(dir)));
+  } while (dir !== (dir = path3.dirname(dir)));
   return null;
 }
 async function resolveAdapter(root, options, log) {
@@ -2209,11 +2254,11 @@ function getEntryFileName(file) {
 import net from "net";
 import cp from "child_process";
 import { parse, config } from "dotenv";
-import fs3 from "fs";
+import fs4 from "fs";
 import cluster from "cluster";
 async function parseEnv(envFile) {
-  if (fs3.existsSync(envFile)) {
-    const content = await fs3.promises.readFile(envFile, "utf8");
+  if (fs4.existsSync(envFile)) {
+    const content = await fs4.promises.readFile(envFile, "utf8");
     return parse(content);
   }
 }

package/dist/vite/types.d.ts

@@ -36,12 +36,12 @@ export interface Adapter {
 export interface RouterOptions {
     trailingSlashes: "Ignore" | "RedirectWithout" | "RedirectWith" | "RewriteWithout" | "RewriteWith";
 }
-export interface MarkoServeOptions extends Partial<RouterOptions> {
+export interface MarkoRunOptions extends Partial<RouterOptions> {
     routesDir?: string;
     emitRoutes?(routes: Route[]): void | Promise<void>;
     adapter?: Adapter | null;
 }
-export type Options = MarkoServeOptions & MarkoViteOptions;
+export type Options = MarkoRunOptions & MarkoViteOptions;
 export interface Route {
     key: string;
     index: number;

package/dist/vite/utils/read-once-persisted-store.d.ts

@@ -0,0 +1,6 @@
+export declare class ReadOncePersistedStore<T> {
+    private uid;
+    constructor(uid: string);
+    write(value: T): void;
+    read(): Promise<T>;
+}