@marko/run 0.0.1-beta2 → 0.0.1-beta3

package/dist/cli/index.mjs

@@ -2,17 +2,17 @@
 
 // src/cli/index.ts
 import path from "path";
-import fs from "fs";
+import fs2 from "fs";
 import { fileURLToPath } from "url";
 import { build as viteBuild, resolveConfig } from "vite";
 import sade from "sade";
 
 // src/vite/utils/config.ts
 var KEY = "__MARKO_SERVE_OPTIONS__";
-function getMarkoServeOptions(viteConfig) {
+function getMarkoRunOptions(viteConfig) {
   return viteConfig[KEY];
 }
-function setMarkoServeOptions(viteConfig, options) {
+function setMarkoRunOptions(viteConfig, options) {
   viteConfig[KEY] = options;
   return viteConfig;
 }
@@ -23,16 +23,27 @@ import { MemoryStore } from "@marko/vite";
 // src/vite/utils/server.ts
 import net from "net";
 import cp from "child_process";
-async function spawnServer(cmd, port = 0, cwd2 = process.cwd(), wait = 3e4) {
+import { parse, config } from "dotenv";
+import fs from "fs";
+async function parseEnv(envFile) {
+  if (fs.existsSync(envFile)) {
+    const content = await fs.promises.readFile(envFile, "utf8");
+    return parse(content);
+  }
+}
+async function spawnServer(cmd, port = 0, env, cwd2 = process.cwd(), wait = 3e4) {
   if (port <= 0) {
     port = await getAvailablePort();
   }
+  if (typeof env === "string") {
+    env = await parseEnv(env);
+  }
   const proc = cp.spawn(cmd, {
     cwd: cwd2,
     shell: true,
     stdio: "inherit",
     windowsHide: true,
-    env: { NODE_ENV: "development", ...process.env, PORT: `${port}` }
+    env: { ...env, NODE_ENV: "development", ...process.env, PORT: `${port}` }
   });
   const close = () => {
     proc.unref();
@@ -80,23 +91,23 @@ function sleep(ms) {
 var __dirname = fileURLToPath(new URL(".", import.meta.url));
 var cwd = process.cwd();
 var defaultPort = +process.env.PORT || 3e3;
-var prog = sade("marko-run").version("0.0.1").option("-c, --config", "Provide path to a Vite config");
+var prog = sade("marko-run").version("0.0.1").option("-c, --config", "Provide path to a Vite config").option("-e, --env", "Provide path to a dotenv file");
 prog.command("preview [entry]", "", { default: true }).describe("Start production-like server against built assets").option("-o, --output", "Directory to serve files").option("-p, --port", "Port to use for dev server").option("-f, --file", "Output file to start").action(async (entry, opts) => {
-  const config = await getViteConfig(cwd, opts.config);
-  await build(entry, config, opts.output);
-  await preview(opts.entry, config, opts.port, opts.output);
+  const config2 = await getViteConfig(cwd, opts.config);
+  await build(entry, config2, opts.output, false, opts.env);
+  await preview(opts.entry, config2, opts.port, opts.output, opts.env);
 });
 prog.command("dev [entry]").describe("Start dev server").option("-p, --port", "Port to use for dev server").example("dev --config vite.config.js").action(async (entry, opts) => {
   const cmd = opts._.length ? `${entry} ${opts._.join(" ")}` : entry ? `node ${entry}` : void 0;
-  const config = await getViteConfig(cwd, opts.config);
-  await dev(cmd, config, opts.port);
+  const config2 = await getViteConfig(cwd, opts.config);
+  await dev(cmd, config2, opts.port, opts.env);
 });
 prog.command("build [entry]").describe("Build the application").option("-o, --output", "Directory to ouput built files").option("--skip-client", "Skip the client build").example("build --config vite.config.js").action(async (entry, opts) => {
-  const config = await getViteConfig(cwd, opts.config);
-  await build(entry, config, opts.ouput, opts["skip-client"]);
+  const config2 = await getViteConfig(cwd, opts.config);
+  await build(entry, config2, opts.ouput, opts["skip-client"], opts.env);
 });
 prog.parse(process.argv);
-async function preview(entry, configFile, port, outDir) {
+async function preview(entry, configFile, port, outDir, envFile) {
   const resolvedConfig = await resolveConfig(
     { root: cwd, configFile, build: { outDir } },
     "serve"
@@ -112,9 +123,12 @@ async function preview(entry, configFile, port, outDir) {
   }
   const dir = path.resolve(cwd, resolvedConfig.build.outDir);
   const entryFile = entry ? path.join(dir, entry) : await findFileWithExt(dir, "index", [".mjs", ".js"]);
-  await adapter.startPreview(dir, entryFile, port);
+  if (envFile) {
+    envFile = path.resolve(cwd, envFile);
+  }
+  await adapter.startPreview(dir, entryFile, port, envFile);
 }
-async function dev(cmd, configFile, port) {
+async function dev(cmd, configFile, port, envFile) {
   const resolvedConfig = await resolveConfig(
     { root: cwd, configFile },
     "build"
@@ -122,8 +136,11 @@ async function dev(cmd, configFile, port) {
   if (port === void 0) {
     port = resolvedConfig.preview.port ?? defaultPort;
   }
+  if (envFile) {
+    envFile = path.resolve(cwd, envFile);
+  }
   if (cmd) {
-    await spawnServer(cmd, port);
+    await spawnServer(cmd, port, envFile);
   } else {
     const adapter = await resolveAdapter(resolvedConfig);
     if (!adapter) {
@@ -133,11 +150,11 @@ async function dev(cmd, configFile, port) {
     } else if (!adapter.startDev) {
       throw new Error(`Adapter ${adapter.name} does not support serve command`);
     } else {
-      await adapter.startDev(configFile, port);
+      await adapter.startDev(configFile, port, envFile);
     }
   }
 }
-async function build(entry, configFile, outDir, skipClient = false) {
+async function build(entry, configFile, outDir, skipClient = false, envFile) {
   var _a;
   if (!entry) {
     const resolvedConfig = await resolveConfig(
@@ -155,7 +172,10 @@ async function build(entry, configFile, outDir, skipClient = false) {
       );
     }
   }
-  const buildConfig = setMarkoServeOptions(
+  if (envFile) {
+    envFile = path.resolve(cwd, envFile);
+  }
+  const buildConfig = setMarkoRunOptions(
     {
       root: cwd,
       configFile,
@@ -171,6 +191,7 @@ async function build(entry, configFile, outDir, skipClient = false) {
   await viteBuild({
     ...buildConfig,
     build: {
+      target: "esnext",
       ...buildConfig.build,
       ssr: entry,
       rollupOptions: {
@@ -193,7 +214,7 @@ async function build(entry, configFile, outDir, skipClient = false) {
 function findFileWithExt(dir, base, extensions = [".js", ".cjs", ".mjs", ".ts", ".mts"]) {
   for (const ext of extensions) {
     const filePath = path.join(dir, base + ext);
-    if (fs.existsSync(filePath)) {
+    if (fs2.existsSync(filePath)) {
       return filePath;
     }
   }
@@ -201,7 +222,7 @@ function findFileWithExt(dir, base, extensions = [".js", ".cjs", ".mjs", ".ts",
 }
 async function getViteConfig(dir, configFile, bases = ["serve.config", "vite.config"]) {
   if (configFile) {
-    if (!fs.existsSync(path.join(dir, configFile))) {
+    if (!fs2.existsSync(path.join(dir, configFile))) {
       throw new Error(`Unable to load config file '${configFile}' from ${dir}`);
     }
     return configFile;
@@ -214,8 +235,8 @@ async function getViteConfig(dir, configFile, bases = ["serve.config", "vite.con
   }
   return path.join(__dirname, "default.config.mjs");
 }
-async function resolveAdapter(config) {
-  const options = getMarkoServeOptions(config);
+async function resolveAdapter(config2) {
+  const options = getMarkoRunOptions(config2);
   if (!options) {
     throw new Error("Unable to resolve Marko Serve options");
   }

package/dist/runtime/index.cjs

@@ -3,10 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -19,16 +15,4 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 
 // src/runtime/index.ts
 var runtime_exports = {};
-__export(runtime_exports, {
-  getMatchedRoute: () => import_router.getMatchedRoute,
-  handler: () => import_router.handler,
-  router: () => import_router.router
-});
 module.exports = __toCommonJS(runtime_exports);
-var import_router = require("@marko/run/router");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getMatchedRoute,
-  handler,
-  router
-});

package/dist/runtime/index.d.ts

@@ -1,2 +1,10 @@
-export { router, getMatchedRoute, handler } from '@marko/run/router';
-export type { MatchedRoute, Handler, RouteContext, RouteHandler, RouteMatcher, Router } from './types';
+import type { HandlerLike, ParamsObject, Route } from "./types";
+declare global {
+    namespace Marko {
+        interface CurrentRoute extends Route {
+        }
+        type Handler<Params extends ParamsObject = {}, Meta = unknown> = HandlerLike<Route<Params, Meta, string>>;
+        function route<Params extends ParamsObject = {}, Meta = unknown>(handler: Handler<Params, Meta>): typeof handler;
+    }
+}
+export type { HandlerLike, InputObject, InvokeRoute, MatchRoute, NextFunction, RequestContext, Route, RouteContext, RouteContextExtensions, RouteHandler, RouteWithHandler, Router, } from "./types";

package/dist/runtime/index.js

@@ -1,7 +0,0 @@
-// src/runtime/index.ts
-import { router, getMatchedRoute, handler } from "@marko/run/router";
-export {
-  getMatchedRoute,
-  handler,
-  router
-};

package/dist/runtime/internal.cjs

@@ -0,0 +1,148 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  RequestNotHandled: () => RequestNotHandled,
+  RequestNotMatched: () => RequestNotMatched,
+  call: () => call,
+  compose: () => compose,
+  createInput: () => createInput,
+  noContent: () => noContent,
+  normalize: () => normalize,
+  notHandled: () => notHandled,
+  notMatched: () => notMatched
+});
+module.exports = __toCommonJS(internal_exports);
+globalThis.Marko ?? (globalThis.Marko = {});
+globalThis.Marko.route = (handler) => handler;
+var RequestNotHandled = Symbol();
+var RequestNotMatched = Symbol();
+function createInput(context) {
+  let existing;
+  return (data) => {
+    existing ?? (existing = {
+      $global: {
+        context
+      }
+    });
+    return data ? Object.assign(existing, data) : existing;
+  };
+}
+async function call(handler, next, context) {
+  let response;
+  if (process.env.NODE_ENV !== "production") {
+    let nextCallCount = 0;
+    let didThrow = false;
+    try {
+      response = await handler(context, () => {
+        nextCallCount++;
+        return next();
+      });
+    } catch (error) {
+      didThrow = true;
+      if (error instanceof Response) {
+        return error;
+      }
+      throw error;
+    } finally {
+      if (!response && !didThrow && nextCallCount > 0) {
+        console.warn(
+          `Handler '${handler.name}' called its next function but no response was returned. This will cause the next function to be called again which is wasteful. Either return or throw the result of calling \`next\`, return or throw a new Response object or finally \`throw null\` to skip handling the request`
+        );
+      } else if (nextCallCount > 1) {
+        console.warn(
+          `Handler '${handler.name}' called its next function more than once. Make sure this is intentional because it is inefficient.`
+        );
+      }
+    }
+  } else {
+    try {
+      response = await handler(context, next);
+    } catch (error) {
+      if (error == null) {
+        throw RequestNotHandled;
+      } else if (error instanceof Response) {
+        return error;
+      }
+      throw error;
+    }
+  }
+  if (response === null) {
+    throw RequestNotMatched;
+  }
+  return response || next();
+}
+function compose(handlers) {
+  const len = handlers.length;
+  if (!len) {
+    return (_context, next) => next();
+  } else if (len === 1) {
+    return handlers[0];
+  }
+  return (context, next) => {
+    let i = 0;
+    return function nextHandler() {
+      return i < len ? call(handlers[i++], nextHandler, context) : next();
+    }();
+  };
+}
+function normalize(obj) {
+  if (typeof obj === "function") {
+    return obj;
+  } else if (Array.isArray(obj)) {
+    return compose(obj);
+  } else if (obj instanceof Promise) {
+    const promise = obj.then((value) => {
+      fn = Array.isArray(value) ? compose(value) : value;
+    });
+    let fn = async (context, next) => {
+      await promise;
+      return fn(context, next);
+    };
+    return (context, next) => fn(context, next);
+  }
+  throw new Error(
+    `Invalid handler - expected function, array or Promise but received ${obj}`
+  );
+}
+function noContent() {
+  return new Response(null, {
+    status: 204
+  });
+}
+function notHandled() {
+  throw null;
+}
+function notMatched() {
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RequestNotHandled,
+  RequestNotMatched,
+  call,
+  compose,
+  createInput,
+  noContent,
+  normalize,
+  notHandled,
+  notMatched
+});

package/dist/runtime/internal.d.ts

@@ -0,0 +1,10 @@
+import type { InputObject, NextFunction, Route, RouteContext, RouteHandler } from "./types";
+export declare const RequestNotHandled: unique symbol;
+export declare const RequestNotMatched: unique symbol;
+export declare function createInput(context: RouteContext): (data: InputObject) => InputObject;
+export declare function call(handler: RouteHandler<Route>, next: NextFunction, context: RouteContext): Promise<Response>;
+export declare function compose(handlers: RouteHandler[]): RouteHandler;
+export declare function normalize(obj: RouteHandler | RouteHandler[] | Promise<RouteHandler | RouteHandler[]>): RouteHandler;
+export declare function noContent(): Response;
+export declare function notHandled(): void;
+export declare function notMatched(): null;

package/dist/runtime/internal.js

@@ -0,0 +1,115 @@
+// src/runtime/internal.ts
+globalThis.Marko ?? (globalThis.Marko = {});
+globalThis.Marko.route = (handler) => handler;
+var RequestNotHandled = Symbol();
+var RequestNotMatched = Symbol();
+function createInput(context) {
+  let existing;
+  return (data) => {
+    existing ?? (existing = {
+      $global: {
+        context
+      }
+    });
+    return data ? Object.assign(existing, data) : existing;
+  };
+}
+async function call(handler, next, context) {
+  let response;
+  if (process.env.NODE_ENV !== "production") {
+    let nextCallCount = 0;
+    let didThrow = false;
+    try {
+      response = await handler(context, () => {
+        nextCallCount++;
+        return next();
+      });
+    } catch (error) {
+      didThrow = true;
+      if (error instanceof Response) {
+        return error;
+      }
+      throw error;
+    } finally {
+      if (!response && !didThrow && nextCallCount > 0) {
+        console.warn(
+          `Handler '${handler.name}' called its next function but no response was returned. This will cause the next function to be called again which is wasteful. Either return or throw the result of calling \`next\`, return or throw a new Response object or finally \`throw null\` to skip handling the request`
+        );
+      } else if (nextCallCount > 1) {
+        console.warn(
+          `Handler '${handler.name}' called its next function more than once. Make sure this is intentional because it is inefficient.`
+        );
+      }
+    }
+  } else {
+    try {
+      response = await handler(context, next);
+    } catch (error) {
+      if (error == null) {
+        throw RequestNotHandled;
+      } else if (error instanceof Response) {
+        return error;
+      }
+      throw error;
+    }
+  }
+  if (response === null) {
+    throw RequestNotMatched;
+  }
+  return response || next();
+}
+function compose(handlers) {
+  const len = handlers.length;
+  if (!len) {
+    return (_context, next) => next();
+  } else if (len === 1) {
+    return handlers[0];
+  }
+  return (context, next) => {
+    let i = 0;
+    return function nextHandler() {
+      return i < len ? call(handlers[i++], nextHandler, context) : next();
+    }();
+  };
+}
+function normalize(obj) {
+  if (typeof obj === "function") {
+    return obj;
+  } else if (Array.isArray(obj)) {
+    return compose(obj);
+  } else if (obj instanceof Promise) {
+    const promise = obj.then((value) => {
+      fn = Array.isArray(value) ? compose(value) : value;
+    });
+    let fn = async (context, next) => {
+      await promise;
+      return fn(context, next);
+    };
+    return (context, next) => fn(context, next);
+  }
+  throw new Error(
+    `Invalid handler - expected function, array or Promise but received ${obj}`
+  );
+}
+function noContent() {
+  return new Response(null, {
+    status: 204
+  });
+}
+function notHandled() {
+  throw null;
+}
+function notMatched() {
+  return null;
+}
+export {
+  RequestNotHandled,
+  RequestNotMatched,
+  call,
+  compose,
+  createInput,
+  noContent,
+  normalize,
+  notHandled,
+  notMatched
+};

package/dist/runtime/router.cjs

@@ -20,20 +20,20 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/runtime/router.ts
 var router_exports = {};
 __export(router_exports, {
-  getMatchedRoute: () => getMatchedRoute,
-  handler: () => handler,
+  invokeRoute: () => invokeRoute,
+  matchRoute: () => matchRoute,
   router: () => router
 });
 module.exports = __toCommonJS(router_exports);
 function notImplemented() {
   throw new Error("This should have been replaced by the @marko/run plugin at build/dev time");
 }
-var handler = notImplemented;
 var router = notImplemented;
-var getMatchedRoute = notImplemented;
+var matchRoute = notImplemented;
+var invokeRoute = notImplemented;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getMatchedRoute,
-  handler,
+  invokeRoute,
+  matchRoute,
   router
 });

package/dist/runtime/router.d.ts

@@ -1,4 +1,4 @@
-import type { Handler, RouteMatcher, Router } from './types';
-export declare const handler: Handler;
-export declare const router: Router;
-export declare const getMatchedRoute: RouteMatcher;
+import type { InvokeRoute, MatchRoute, Router } from './types';
+export declare const router: Router<import("./types").Platform>;
+export declare const matchRoute: MatchRoute;
+export declare const invokeRoute: InvokeRoute<import("./types").Platform>;

package/dist/runtime/router.js

@@ -2,11 +2,11 @@
 function notImplemented() {
   throw new Error("This should have been replaced by the @marko/run plugin at build/dev time");
 }
-var handler = notImplemented;
 var router = notImplemented;
-var getMatchedRoute = notImplemented;
+var matchRoute = notImplemented;
+var invokeRoute = notImplemented;
 export {
-  getMatchedRoute,
-  handler,
+  invokeRoute,
+  matchRoute,
   router
 };

package/dist/runtime/types.d.ts

@@ -1,22 +1,37 @@
-import type { AdapterRequestContext } from '@hattip/core';
-export interface RouteContext<Params extends Record<string, string> = {}, Meta = unknown> {
-    request: Request;
+declare type Awaitable<T> = Promise<T> | T;
+declare type OneOrMany<T> = T | T[];
+declare type Combine<T> = T extends object ? {
+    [P in keyof T]: T[P];
+} : T;
+export interface RouteContextExtensions {
+}
+export interface Platform {
+}
+export declare type ParamsObject = Record<string, string>;
+export declare type InputObject = Record<PropertyKey, any>;
+export interface RequestContext<T = Platform> {
     url: URL;
-    params: Params;
-    meta: Meta;
-    error?: unknown;
+    method: string;
+    request: Request;
+    platform: T;
 }
-export declare type RouteHandler<Params extends Record<string, string> = {}, Meta = unknown> = (context: RouteContext<Params, Meta>) => Promise<Response>;
-export interface MatchedRoute<Params extends Record<string, string> = {}, Meta = unknown> {
-    handler: RouteHandler;
+export declare type RouteContext<TRoute extends Route = Route> = TRoute extends any ? Combine<RouteContextExtensions & Readonly<RequestContext & {
+    route: TRoute["path"];
+    params: TRoute["params"];
+    meta: TRoute["meta"];
+}>> : never;
+export declare type NextFunction = () => Awaitable<Response>;
+export declare type HandlerLike<TRoute extends Route = Route> = Awaitable<OneOrMany<RouteHandler<TRoute>>>;
+export declare type RouteHandler<TRoute extends Route = Route> = (context: RouteContext<TRoute>, next: NextFunction) => Awaitable<Response | null | void>;
+export interface Route<Params extends ParamsObject = {}, Meta = unknown, Path extends string = string> {
+    path: Path;
     params: Params;
     meta: Meta;
-    invoke: Router;
 }
-export declare type Router = (request: Request) => Promise<Response>;
-export declare type RouteMatcher = (method: string, url: URL) => MatchedRoute | null;
-export declare type Handler = (context: AdapterRequestContext) => Promise<Response>;
-export interface Runtime {
-    router: Router;
-    getMatchedRoute: RouteMatcher;
+export interface RouteWithHandler<Params extends ParamsObject = {}, Meta = unknown, Path extends string = string> extends Route<Params, Meta, Path> {
+    handler: RouteHandler<this>;
 }
+export declare type MatchRoute = (method: string, pathname: string) => RouteWithHandler | null;
+export declare type Router<T = Platform> = (context: RequestContext<T>) => Promise<Response | void>;
+export declare type InvokeRoute<T = Platform> = (route: Route | null, context: RequestContext<T>) => Promise<Response | void>;
+export {};

package/dist/runtime/utils.d.ts

@@ -0,0 +1,3 @@
+import type { RouteHandler } from "./types";
+export declare function compose(...handlers: RouteHandler[]): RouteHandler;
+export declare function createHandler(factory: () => Promise<RouteHandler>): RouteHandler;

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

@@ -1,5 +1,6 @@
-import type { Route, BuiltRoutes, CodegenOptions } from "../types";
-export declare const DefaultCodegenOptions: CodegenOptions;
+import type { Route, BuiltRoutes, RoutableFile, RouterOptions } from "../types";
 export declare function renderRouteTemplate(route: Route): string;
 export declare function renderRouteEntry(route: Route): string;
-export declare function renderRouter(routes: BuiltRoutes, options?: CodegenOptions): 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): string;

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

@@ -2,7 +2,7 @@ export interface Writer {
     indent: number;
     branch(name: string): Writer;
     join(closeBranches?: boolean): void;
-    write(data: string): Writer;
+    write(data: string, indent?: boolean): Writer;
     writeLines(...lines: string[]): Writer;
     writeBlockStart(data: string): Writer;
     writeBlockEnd(data: string): Writer;

package/dist/vite/constants.d.ts

@@ -1,7 +1,8 @@
 declare type ValuesOf<T> = T[keyof T];
-export declare const markoServeFilePrefix = "__marko-serve__";
-export declare const virtualFilePrefix = "virtual:marko-serve";
+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";