@marko/run 0.2.6 → 0.2.8

package/dist/cli/index.mjs

@@ -87,14 +87,15 @@ import path2 from "path";
 import crypto from "crypto";
 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";
 
 // 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 = {
@@ -109,7 +110,7 @@ var RoutableFileTypes = {
 
 // src/vite/routes/vdir.ts
 var _dirs, _pathlessDirs;
-var _VDir = class {
+var _VDir = class _VDir {
   constructor(parent, segment, source) {
     __privateAdd(this, _dirs, void 0);
     __privateAdd(this, _pathlessDirs, void 0);
@@ -246,9 +247,9 @@ var _VDir = class {
     return dirs;
   }
 };
-var VDir = _VDir;
 _dirs = new WeakMap();
 _pathlessDirs = new WeakMap();
+var VDir = _VDir;
 
 // src/vite/routes/parse.ts
 function parseFlatRoute(pattern) {
@@ -769,23 +770,35 @@ function renderRouteTemplate(route) {
   if (!route.page) {
     throw new Error(`Route ${route.key} has no page to render`);
   }
+  return renderEntryTemplate(
+    route.entryName,
+    [...route.layouts, route.page].map((file) => `./${file.importPath}`)
+  );
+}
+function renderEntryTemplate(name, files) {
+  if (!name) {
+    throw new Error(`Invalid argument - 'name' cannot be empty`);
+  }
+  if (!files.length) {
+    throw new Error(`Invalid argument - 'files' cannot be empty`);
+  }
   const writer = createStringWriter();
-  writer.writeLines(`// ${virtualFilePrefix}/${route.entryName}.marko`);
+  writer.writeLines(`// ${virtualFilePrefix}/${name}.marko`);
   writer.branch("imports");
   writer.writeLines("");
-  writeRouteTemplateTag(writer, [...route.layouts, route.page]);
+  writeEntryTemplateTag(writer, files);
   return writer.end();
 }
-function writeRouteTemplateTag(writer, [file, ...rest], index = 1) {
+function writeEntryTemplateTag(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}';`);
+    writer.branch("imports").writeLines(`import ${tag} from '${file}';`);
     if (isLast) {
-      writer.writeLines(`<${tag} ...input />`);
+      writer.writeLines(`<${tag} ...input/>`);
     } else {
       writer.writeBlockStart(`<${tag} ...input>`);
-      writeRouteTemplateTag(writer, rest, index + 1);
+      writeEntryTemplateTag(writer, rest, index + 1);
       writer.writeBlockEnd(`</>`);
     }
   }
@@ -817,7 +830,9 @@ function renderRouteEntry(route) {
   }
   if (runtimeImports.length) {
     imports.writeLines(
-      `import { ${runtimeImports.join(", ")} } from '${virtualRuntimePrefix}';`
+      `import { ${runtimeImports.join(
+        ", "
+      )} } from '${virtualFilePrefix}/runtime/internal';`
     );
   }
   if (middleware.length) {
@@ -931,6 +946,45 @@ function writeRouteEntryHandler(writer, route, verb) {
   continuations.join();
   writer.writeBlockEnd("}");
 }
+function renderErrorRouter(error, options = {
+  trailingSlashes: "RedirectWithout"
+}) {
+  const writer = createStringWriter();
+  writer.write(`
+// @marko/run/router
+import { createContext } from '${virtualFilePrefix}/runtime/internal';
+import errorPage from '${virtualFilePrefix}/${markoRunFilePrefix}error.marko${serverEntryQuery}';
+
+const error = new Error(\`${error.message}\`);
+error.name = '${error.name}';`);
+  if (error.stack) {
+    writer.write(`
+error.stack = \`${error.stack}\`;`);
+  }
+  writer.write(`
+
+globalThis.__marko_run__ = { match, fetch, invoke };
+
+export function match() {
+  return { handler: errorPage, params: {}, meta: {}, path: '/*' }; // /$$
+}
+
+export async function invoke(route, request, platform, url) {
+  const [context, buildInput] = createContext(route, request, platform, url);
+  if (context.request.headers.get('Accept')?.includes('text/html')) {
+    return new Response(errorPage.stream(buildInput({ error })), {
+      status: 500,
+      headers: { "content-type": "text/html;charset=UTF-8" },
+    });
+  }
+  return new Response(error, {
+    status: 500,
+  });
+}
+`);
+  renderFetch(writer, options);
+  return writer.end();
+}
 function renderRouter(routes, options = {
   trailingSlashes: "RedirectWithout"
 }) {
@@ -938,7 +992,7 @@ function renderRouter(routes, options = {
   writer.writeLines(`// @marko/run/router`);
   const imports = writer.branch("imports");
   imports.writeLines(
-    `import { NotHandled, NotMatched, createContext } from 'virtual:marko-run/internal';`
+    `import { NotHandled, NotMatched, createContext } from '${virtualFilePrefix}/runtime/internal';`
   );
   for (const route of routes.list) {
     const verbs = getVerbs(route);
@@ -974,24 +1028,24 @@ globalThis.__marko_run__ = { match, fetch, invoke };
     }
   }
   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;
-				}
-			}
-`);
+  writer.writeLines("").writeBlockStart(
+    "export async function invoke(route, request, platform, url) {"
+  ).writeLines(
+    "const [context, buildInput] = createContext(route, request, platform, url);"
+  );
+  const hasErrorPage = Boolean(routes.special[RoutableFileTypes.Error]);
+  if (hasErrorPage) {
+    writer.writeBlockStart("try {");
+  }
+  writer.writeBlockStart("if (route) {").writeBlockStart("try {").writeLines(
+    "const response = await route.handler(context, buildInput);",
+    "if (response) return response;"
+  ).indent--;
+  writer.writeBlockStart("} catch (error) {").writeLines(
+    "if (error === NotHandled) return;",
+    "if (error !== NotMatched) throw error;"
+  ).writeBlockEnd("}").writeBlockEnd("}");
   if (routes.special[RoutableFileTypes.NotFound]) {
-    writer.indent = 2;
     imports.writeLines(
       `
 const page404ResponseInit = {
@@ -999,33 +1053,31 @@ const page404ResponseInit = {
   headers: { "content-type": "text/html;charset=UTF-8" },
 };`
     );
-    writer.write(
-      `    } else {
-    }
+    writer.write(`    
     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]) {
+  if (hasErrorPage) {
     imports.writeLines(`
 const page500ResponseInit = {
   status: 500,
   headers: { "content-type": "text/html;charset=UTF-8" },
 };`);
-    writer.writeBlockStart(
+    writer.writeBlockStart(`} catch (error) {`).writeBlockStart(
       `if (context.request.headers.get('Accept')?.includes('text/html')) {`
     ).writeLines(
       `return new Response(page500.stream(buildInput({ error })), page500ResponseInit);`
-    ).writeBlockEnd("}");
+    ).writeBlockEnd("}").writeLines("throw error;").writeBlockEnd("}");
   }
-  writer.writeLines(`throw error;`).writeBlockEnd("}").writeBlockEnd("}").write(`
+  writer.writeBlockEnd("}");
+  renderFetch(writer, options);
+  return writer.end();
+}
+function renderFetch(writer, options) {
+  writer.write(`
 export async function fetch(request, platform) {
   try {
     const url = new URL(request.url);
@@ -1063,15 +1115,22 @@ export async function fetch(request, platform) {
     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, {
+    if (import.meta.env.DEV) {
+      let body;
+      if (error.cause) {
+        body = error.cause.stack || error.cause.message || error.cause;
+      } else {
+        body = error.stack || error.message || "Internal Server Error";
+      }
+      return new Response(body, {
+        status: 500
+      });
+    }
+    return new Response(null, {
       status: 500
     });
   }
 }`);
-  return writer.end();
 }
 function writeRouterVerb(writer, trie, verb, level = 0, offset = 1) {
   const { route, dynamic, catchAll } = trie;
@@ -1193,7 +1252,12 @@ function writeRouterVerb(writer, trie, verb, level = 0, offset = 1) {
   }
   if (catchAll) {
     writer.writeLines(
-      `return ${renderMatch(verb, catchAll.route, catchAll.path, String(offset))}; // ${catchAll.path.path}`
+      `return ${renderMatch(
+        verb,
+        catchAll.route,
+        catchAll.path,
+        String(offset)
+      )}; // ${catchAll.path.path}`
     );
   } else if (level === 0) {
     writer.writeLines("return null;");
@@ -1235,7 +1299,9 @@ function renderMiddleware(middleware) {
     `// ${virtualFilePrefix}/${markoRunFilePrefix}middleware.js`
   );
   const imports = writer.branch("imports");
-  imports.writeLines(`import { normalize } from 'virtual:marko-run/internal';`);
+  imports.writeLines(
+    `import { normalize } from '${virtualFilePrefix}/runtime/internal';`
+  );
   writer.writeLines("");
   for (const { id, importPath } of middleware) {
     const importName = `middleware${id}`;
@@ -1553,7 +1619,9 @@ function logRoutesTable(routes, bundle, options) {
           entryType.push(kleur.yellow("page"));
           size = prettySize(computeRouteSize(getRouteChunkName(route), bundle));
         }
-        const row = [kleur.bold(HttpVerbColors[verb](verb.toUpperCase()))];
+        const row = [
+          kleur.bold(HttpVerbColors[verb](verb.toUpperCase()))
+        ];
         if (verbs.length === 1 || firstRow) {
           row.push({ rowSpan: verbs.length, content: prettyPath(path4.path) });
           firstRow = false;
@@ -1591,10 +1659,7 @@ function byteSize(source) {
 }
 function computeChunkSize(chunk, bundle, seen = /* @__PURE__ */ new Set()) {
   if (chunk.type === "asset") {
-    return [
-      byteSize(chunk.source),
-      gzipSize(chunk.source)
-    ];
+    return [byteSize(chunk.source), gzipSize(chunk.source)];
   }
   const size = [byteSize(chunk.code), gzipSize(chunk.code)];
   for (const id of chunk.imports) {
@@ -1627,7 +1692,6 @@ function prettyPath(path4) {
 }
 
 // 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 = "/";
@@ -1660,14 +1724,14 @@ function markoRun(opts = {}) {
     routesBuild: 0,
     routesRender: 0
   };
-  async function writeTypesFile() {
-    if (tsConfigExists ?? (tsConfigExists = await globFileExists(
+  async function writeTypesFile(routes2) {
+    if (routes2 && (tsConfigExists ?? (tsConfigExists = await globFileExists(
       root,
       "{.tsconfig*,tsconfig*.json}"
-    ))) {
+    )))) {
       const filepath = path2.join(typesDir, "routes.d.ts");
       const data = await renderRouteTypeInfo(
-        routes,
+        routes2,
         normalizePath(path2.relative(typesDir, resolvedRoutesDir)),
         adapter
       );
@@ -1677,65 +1741,93 @@ function markoRun(opts = {}) {
       }
     }
   }
-  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'`
+  const buildVirtualFiles = single(async (render) => {
+    var _a;
+    const routerOptions = {
+      trailingSlashes: opts.trailingSlashes || "RedirectWithout"
+    };
+    try {
+      if (isStale) {
+        virtualFiles.clear();
+        isRendered = false;
+        const buildStartTime = performance.now();
+        routes = await buildRoutes(
+          createFSWalker(resolvedRoutesDir),
+          routesDir
+        );
+        times.routesBuild = performance.now() - buildStartTime;
+        if (!routes.list.length) {
+          throw new Error("No routes generated");
+        }
+      }
+      const renderStartTime = performance.now();
+      for (const route of routes.list) {
+        if (render && route.handler) {
+          route.handler.verbs = await extractVerbs(route.handler.filePath);
+          if (!route.handler.verbs.length) {
+            throw new Error(
+              `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) : ""
+        );
       }
-      if (route.page) {
+      for (const route of Object.values(routes.special)) {
         virtualFiles.set(
           path2.posix.join(root, `${route.entryName}.marko`),
           render ? renderRouteTemplate(route) : ""
         );
       }
+      if (routes.middleware.length) {
+        virtualFiles.set(
+          path2.posix.join(root, `${markoRunFilePrefix}middleware.js`),
+          render ? renderMiddleware(routes.middleware) : ""
+        );
+      }
       virtualFiles.set(
-        path2.posix.join(root, `${route.entryName}.js`),
-        render ? renderRouteEntry(route) : ""
+        "@marko/run/router",
+        render ? renderRouter(routes, routerOptions) : ""
       );
-    }
-    for (const route of Object.values(routes.special)) {
+      times.routesRender = performance.now() - renderStartTime;
+      if (render) {
+        await writeTypesFile(routes);
+        if (!isBuild) {
+          await ((_a = opts == null ? void 0 : opts.emitRoutes) == null ? void 0 : _a.call(opts, routes.list));
+        }
+        isRendered = true;
+      }
+    } catch (err) {
+      if (isBuild) {
+        throw err;
+      }
+      console.error(err);
       virtualFiles.set(
-        path2.posix.join(root, `${route.entryName}.marko`),
-        render ? renderRouteTemplate(route) : ""
+        path2.posix.join(root, `${markoRunFilePrefix}error.marko`),
+        renderEntryTemplate(`${markoRunFilePrefix}error`, ["<dev-error-page>"])
       );
+      virtualFiles.set(
+        "@marko/run/router",
+        renderErrorRouter(err, routerOptions)
+      );
+      isRendered = true;
     }
-    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;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         const externalPluginOptions = getExternalPluginOptions(config2);
         if (externalPluginOptions) {
           opts = mergeConfig(opts, externalPluginOptions);
@@ -1761,6 +1853,11 @@ function markoRun(opts = {}) {
         }
         compiler ?? (compiler = await import(opts.compiler || "@marko/compiler"));
         compiler.taglib.register("@marko/run", {
+          "<dev-error-page>": {
+            template: normalizePath(
+              path2.resolve(__dirname, "../components/dev-error-page.marko")
+            )
+          },
           "<*>": {
             transform: path2.resolve(
               __dirname,
@@ -1825,11 +1922,26 @@ function markoRun(opts = {}) {
             noExternal: /@marko\/run/
           },
           build: {
+            target: isBuild && !((_g = config2.build) == null ? void 0 : _g.target) ? resolveToEsbuildTarget(
+              browserslist(void 0, {
+                path: root
+              }),
+              { printUnknownTargets: false }
+            ) : void 0,
             emptyOutDir: isSSRBuild,
+            // Avoid server & client deleting files from each other.
             rollupOptions: {
               output: rollupOutputOptions
             }
           },
+          optimizeDeps: {
+            entries: !((_h = config2.optimizeDeps) == null ? void 0 : _h.entries) ? [
+              "src/pages/**/*+{page,layout}.marko",
+              "!**/__snapshots__/**",
+              `!**/__tests__/**`,
+              `!**/coverage/**`
+            ] : void 0
+          },
           resolve: isBuild ? {
             browserField: isSSRBuild ? false : void 0,
             conditions: [
@@ -1914,40 +2026,35 @@ function markoRun(opts = {}) {
       },
       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)
-          );
+        let virtualFilePath;
+        if (importee.startsWith(virtualFilePrefix)) {
+          virtualFilePath = importee.slice(virtualFilePrefix.length + 1);
+          importee = path2.resolve(root, virtualFilePath);
         } else if (!isBuild && importer && (importer === devEntryFile || normalizePath(importer) === devEntryFilePosix) && importee.startsWith(`/${markoRunFilePrefix}`)) {
           importee = path2.resolve(root, "." + importee);
         }
         importee = normalizePath(importee);
         if (isStale) {
-          await buildVirtualFiles();
+          await buildVirtualFiles(false);
         }
         if (virtualFiles.has(importee)) {
           resolved = importee;
+        } else if (virtualFilePath) {
+          const filePath = path2.resolve(__dirname, "..", virtualFilePath);
+          const resolution = await this.resolve(filePath, importer, {
+            skipSelf: true
+          });
+          return resolution;
         }
         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));
-            }
+          if (isStale || !isRendered) {
+            await buildVirtualFiles(true);
           }
           return virtualFiles.get(id);
         }
@@ -1990,12 +2097,12 @@ function markoRun(opts = {}) {
           }
           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) {
+        } else {
           logRoutesTable(routes, bundle, options);
         }
       },
       async closeBundle() {
-        if (isBuild && !isSSRBuild && (adapter == null ? void 0 : adapter.buildEnd)) {
+        if (isBuild && !isSSRBuild && (adapter == null ? void 0 : adapter.buildEnd) && routes) {
           await adapter.buildEnd(
             resolvedConfig,
             routes.list,
@@ -2128,7 +2235,7 @@ var __dirname2 = path3.dirname(fileURLToPath2(import.meta.url));
 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 = []) {
+async function preview(sourceEntry, entry, cwd, configFile, port, outDir, envFile, args = []) {
   const resolvedConfig = await resolveConfig(
     { root: cwd, configFile, logLevel: "silent", build: { outDir } },
     "serve"
@@ -2152,7 +2259,8 @@ async function preview(entry, cwd, configFile, port, outDir, envFile, args = [])
     dir,
     args,
     port: availablePort,
-    envFile
+    envFile,
+    sourceEntry
   };
   return await adapter.startPreview(entryFile, options);
 }
@@ -2171,6 +2279,7 @@ async function dev(entry, cwd, configFile, port, envFile, args = []) {
   if (!adapter) {
     throw new Error(
       "No adapter specified for 'dev' command without custom target"
+      // Would the user know what a target is if presented with this error?
     );
   } else if (!adapter.startDev) {
     throw new Error(
@@ -2239,6 +2348,7 @@ async function build(entry, cwd, configFile, outDir, envFile) {
       rollupOptions: {
         output: {
           entryFileNames: "index.mjs"
+          // Would rather build with `.js` extension but that will fail in zero-config projects where node runs in cjs mode
         }
       }
     }
@@ -2302,6 +2412,7 @@ prog.command("preview [entry]").describe("Start a production-like server for alr
   const config2 = await getViteConfig(cwd, opts.config);
   await build(entry, cwd, config2, opts.output, opts.env);
   await preview(
+    entry,
     opts.file,
     cwd,
     config2,

package/dist/components/dev-error-page.marko

@@ -0,0 +1,14 @@
+export interface Input {
+  error: Error
+}
+
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <title>${input.error.message}</title>
+  </head>
+  <body>
+    <pre>${input.error.stack || (input.error.name + ': ' + input.error.message)}</pre>
+  </body>
+</html>

package/dist/runtime/index.d.ts

@@ -1,7 +1,9 @@
+import { InlineConfig } from "vite";
 import { NotHandled, NotMatched } from "./namespace";
 import type { GetPaths, PostPaths, GetablePath, GetableHref, PostablePath, PostableHref, Platform, HandlerTypeFn, RuntimeModule, AnyRoute, AnyContext, AnyHandler } from "./types";
 declare global {
     var __marko_run__: RuntimeModule;
+    var __marko_run_vite_config__: InlineConfig | undefined;
     namespace MarkoRun {
         export const route: HandlerTypeFn;
         export { GetPaths, PostPaths, GetablePath, GetableHref, PostablePath, PostableHref, Platform, NotHandled, NotMatched, AnyRoute as Route, AnyContext as Context, AnyHandler as Handler, };

package/dist/vite/codegen/index.d.ts

@@ -1,6 +1,8 @@
 import type { Adapter, Route, BuiltRoutes, RoutableFile, RouterOptions } from "../types";
 export declare function renderRouteTemplate(route: Route): string;
+export declare function renderEntryTemplate(name: string, files: string[]): string;
 export declare function renderRouteEntry(route: Route): string;
+export declare function renderErrorRouter(error: Error, options?: RouterOptions): string;
 export declare function renderRouter(routes: BuiltRoutes, options?: RouterOptions): string;
 export declare function renderMiddleware(middleware: RoutableFile[]): string;
 export declare function renderRouteTypeInfo(routes: BuiltRoutes, pathPrefix?: string, adapter?: Adapter | null): Promise<string>;

package/dist/vite/constants.d.ts

@@ -1,8 +1,6 @@
 type ValuesOf<T> = T[keyof T];
 export declare const markoRunFilePrefix = "__marko-run__";
 export declare const virtualFilePrefix = "virtual:marko-run";
-export declare const virtualRoutesPrefix: string;
-export declare const virtualRuntimePrefix: string;
 export declare const httpVerbs: readonly ["get", "post", "put", "delete"];
 export declare const serverEntryQuery = "?marko-server-entry";
 export declare const browserEntryQuery = "?marko-browser-entry";