@marko/run 0.0.1-beta6 → 0.0.1-beta8

package/dist/adapter/index.js

@@ -62,8 +62,8 @@ function getOrigin(req, protocol, host, trustProxy) {
   }
   return `${protocol}://${host}`;
 }
-function createMiddleware(router, options = {}) {
-  const { trustProxy = process.env.TRUST_PROXY === "1" } = options;
+function createMiddleware(fetch2, options = {}) {
+  const { trustProxy = process.env.TRUST_PROXY === "1", devServer } = options;
   let { origin = process.env.ORIGIN } = options;
   let protocol;
   let host;
@@ -75,45 +75,28 @@ function createMiddleware(router, options = {}) {
     origin ?? (origin = getOrigin(req, protocol, host, trustProxy));
     const url = new URL(req.url, origin);
     const ip = req.ip || trustProxy && getForwardedHeader(req, "for") || req.socket.remoteAddress || "";
-    const requestContext = {
+    const headers = req.headers;
+    const body = req.method === "GET" || req.method === "HEAD" ? void 0 : req.socket ? req : new ReadableStream({
+      start(controller) {
+        req.on("data", (chunk) => controller.enqueue(chunk));
+        req.on("end", () => controller.close());
+        req.on("error", (err) => controller.error(err));
+      }
+    });
+    const request = new Request(url, {
       method: req.method,
-      url,
-      platform: {
-        ip,
-        request: req,
-        response: res,
-        setCookie(cookie) {
-          res.appendHeader("set-cookie", cookie);
-        }
+      headers,
+      body,
+      duplex: "half"
+    });
+    const response = await fetch2(request, {
+      ip,
+      request: req,
+      response: res,
+      setCookie(cookie) {
+        res.appendHeader("set-cookie", cookie);
       }
-    };
-    Object.defineProperty(requestContext, "request", {
-      get() {
-        const headers = req.headers;
-        const body = req.method === "GET" || req.method === "HEAD" ? void 0 : req.socket ? req : new ReadableStream({
-          start(controller) {
-            req.on("data", (chunk) => controller.enqueue(chunk));
-            req.on("end", () => controller.close());
-            req.on("error", (err) => controller.error(err));
-          }
-        });
-        const request = new Request(url, {
-          method: req.method,
-          headers,
-          body,
-          duplex: "half"
-        });
-        Object.defineProperty(this, "request", {
-          value: request,
-          enumerable: true,
-          configurable: true
-        });
-        return request;
-      },
-      enumerable: true,
-      configurable: true
     });
-    const response = await router(requestContext);
     if (!response) {
       if (next) {
         next();
@@ -164,7 +147,17 @@ function createMiddleware(router, options = {}) {
       res.off("error", cancel);
       reader.cancel(error).catch(() => {
       });
-      error && res.destroy(error);
+      if (error) {
+        if (process.env.NODE_ENV !== "production" && devServer) {
+          res.end();
+          devServer.ws.send({
+            type: "error",
+            err: { message: error.message, stack: error.stack || "" }
+          });
+        } else {
+          res.destroy(error);
+        }
+      }
     }
     async function write() {
       try {
@@ -191,6 +184,7 @@ function createMiddleware(router, options = {}) {
 }
 
 // src/adapter/dev-server.ts
+var fixedErrors = /* @__PURE__ */ new WeakSet();
 function createViteDevMiddleware(devServer, load, factory) {
   let value;
   let middleware;
@@ -203,10 +197,16 @@ function createViteDevMiddleware(devServer, load, factory) {
       }
       await middleware(req, res, next);
     } catch (err) {
+      res.statusCode = 500;
       if (err instanceof Error) {
-        devServer.ssrFixStacktrace(err);
+        if (!fixedErrors.has(err)) {
+          fixedErrors.add(err);
+          devServer.ssrFixStacktrace(err);
+        }
+        res.end(err.stack);
+      } else {
+        res.end();
       }
-      return next == null ? void 0 : next();
     }
   };
 }
@@ -214,12 +214,16 @@ async function createDevServer(configFile) {
   const devServer = await createServer({
     configFile,
     appType: "custom",
-    server: { middlewareMode: true }
+    server: { middlewareMode: true },
+    resolve: {
+      dedupe: ["marko"],
+      conditions: ["worker"]
+    }
   });
   const middleware = createViteDevMiddleware(
     devServer,
-    async () => (await devServer.ssrLoadModule("@marko/run/router")).router,
-    createMiddleware
+    async () => await devServer.ssrLoadModule("@marko/run/router"),
+    (module) => createMiddleware(module.fetch, { devServer })
   );
   return devServer.middlewares.use(middleware);
 }
@@ -314,8 +318,8 @@ function adapter() {
         });
       });
     },
-    async startPreview(dir, entry, port, envFile) {
-      const server = await spawnServer(`node ${entry}`, port, envFile, dir);
+    async startPreview(_dir, entry, port, envFile) {
+      const server = await spawnServer(`node ${entry}`, port, envFile);
       console.log(`Preview server started: http://localhost:${server.port}`);
     }
   };

package/dist/adapter/middleware.cjs

@@ -20,7 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/adapter/middleware.ts
 var middleware_exports = {};
 __export(middleware_exports, {
-  default: () => createMiddleware,
+  createMiddleware: () => createMiddleware,
   getOrigin: () => getOrigin
 });
 module.exports = __toCommonJS(middleware_exports);
@@ -82,8 +82,8 @@ function getOrigin(req, protocol, host, trustProxy) {
   }
   return `${protocol}://${host}`;
 }
-function createMiddleware(router, options = {}) {
-  const { trustProxy = process.env.TRUST_PROXY === "1" } = options;
+function createMiddleware(fetch2, options = {}) {
+  const { trustProxy = process.env.TRUST_PROXY === "1", devServer } = options;
   let { origin = process.env.ORIGIN } = options;
   let protocol;
   let host;
@@ -95,45 +95,28 @@ function createMiddleware(router, options = {}) {
     origin ?? (origin = getOrigin(req, protocol, host, trustProxy));
     const url = new URL(req.url, origin);
     const ip = req.ip || trustProxy && getForwardedHeader(req, "for") || req.socket.remoteAddress || "";
-    const requestContext = {
+    const headers = req.headers;
+    const body = req.method === "GET" || req.method === "HEAD" ? void 0 : req.socket ? req : new ReadableStream({
+      start(controller) {
+        req.on("data", (chunk) => controller.enqueue(chunk));
+        req.on("end", () => controller.close());
+        req.on("error", (err) => controller.error(err));
+      }
+    });
+    const request = new Request(url, {
       method: req.method,
-      url,
-      platform: {
-        ip,
-        request: req,
-        response: res,
-        setCookie(cookie) {
-          res.appendHeader("set-cookie", cookie);
-        }
+      headers,
+      body,
+      duplex: "half"
+    });
+    const response = await fetch2(request, {
+      ip,
+      request: req,
+      response: res,
+      setCookie(cookie) {
+        res.appendHeader("set-cookie", cookie);
       }
-    };
-    Object.defineProperty(requestContext, "request", {
-      get() {
-        const headers = req.headers;
-        const body = req.method === "GET" || req.method === "HEAD" ? void 0 : req.socket ? req : new ReadableStream({
-          start(controller) {
-            req.on("data", (chunk) => controller.enqueue(chunk));
-            req.on("end", () => controller.close());
-            req.on("error", (err) => controller.error(err));
-          }
-        });
-        const request = new Request(url, {
-          method: req.method,
-          headers,
-          body,
-          duplex: "half"
-        });
-        Object.defineProperty(this, "request", {
-          value: request,
-          enumerable: true,
-          configurable: true
-        });
-        return request;
-      },
-      enumerable: true,
-      configurable: true
     });
-    const response = await router(requestContext);
     if (!response) {
       if (next) {
         next();
@@ -184,7 +167,17 @@ function createMiddleware(router, options = {}) {
       res.off("error", cancel);
       reader.cancel(error).catch(() => {
       });
-      error && res.destroy(error);
+      if (error) {
+        if (process.env.NODE_ENV !== "production" && devServer) {
+          res.end();
+          devServer.ws.send({
+            type: "error",
+            err: { message: error.message, stack: error.stack || "" }
+          });
+        } else {
+          res.destroy(error);
+        }
+      }
     }
     async function write() {
       try {
@@ -211,5 +204,6 @@ function createMiddleware(router, options = {}) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  createMiddleware,
   getOrigin
 });

package/dist/adapter/middleware.d.ts

@@ -1,5 +1,6 @@
-import type { Router } from "../runtime";
+import type { Fetch } from "../runtime";
 import type { IncomingMessage, ServerResponse } from "http";
+import type { ViteDevServer } from "vite";
 declare module "net" {
     interface Socket {
         encrypted?: boolean;
@@ -46,10 +47,11 @@ export interface NodeAdapterOptions {
      * is set to `1`, otherwise false.
      */
     trustProxy?: boolean;
+    devServer?: ViteDevServer;
 }
 export declare function getOrigin(req: IncomingMessage, protocol?: string, host?: string, trustProxy?: boolean): string;
 /**
  * Creates a request handler to be passed to http.createServer() or used as a
  * middleware in Connect-style frameworks like Express.
  */
-export default function createMiddleware(router: Router<NodePlatformInfo>, options?: NodeAdapterOptions): NodeMiddleware;
+export declare function createMiddleware(fetch: Fetch<NodePlatformInfo>, options?: NodeAdapterOptions): NodeMiddleware;

package/dist/adapter/middleware.js

@@ -55,8 +55,8 @@ function getOrigin(req, protocol, host, trustProxy) {
   }
   return `${protocol}://${host}`;
 }
-function createMiddleware(router, options = {}) {
-  const { trustProxy = process.env.TRUST_PROXY === "1" } = options;
+function createMiddleware(fetch2, options = {}) {
+  const { trustProxy = process.env.TRUST_PROXY === "1", devServer } = options;
   let { origin = process.env.ORIGIN } = options;
   let protocol;
   let host;
@@ -68,45 +68,28 @@ function createMiddleware(router, options = {}) {
     origin ?? (origin = getOrigin(req, protocol, host, trustProxy));
     const url = new URL(req.url, origin);
     const ip = req.ip || trustProxy && getForwardedHeader(req, "for") || req.socket.remoteAddress || "";
-    const requestContext = {
+    const headers = req.headers;
+    const body = req.method === "GET" || req.method === "HEAD" ? void 0 : req.socket ? req : new ReadableStream({
+      start(controller) {
+        req.on("data", (chunk) => controller.enqueue(chunk));
+        req.on("end", () => controller.close());
+        req.on("error", (err) => controller.error(err));
+      }
+    });
+    const request = new Request(url, {
       method: req.method,
-      url,
-      platform: {
-        ip,
-        request: req,
-        response: res,
-        setCookie(cookie) {
-          res.appendHeader("set-cookie", cookie);
-        }
+      headers,
+      body,
+      duplex: "half"
+    });
+    const response = await fetch2(request, {
+      ip,
+      request: req,
+      response: res,
+      setCookie(cookie) {
+        res.appendHeader("set-cookie", cookie);
       }
-    };
-    Object.defineProperty(requestContext, "request", {
-      get() {
-        const headers = req.headers;
-        const body = req.method === "GET" || req.method === "HEAD" ? void 0 : req.socket ? req : new ReadableStream({
-          start(controller) {
-            req.on("data", (chunk) => controller.enqueue(chunk));
-            req.on("end", () => controller.close());
-            req.on("error", (err) => controller.error(err));
-          }
-        });
-        const request = new Request(url, {
-          method: req.method,
-          headers,
-          body,
-          duplex: "half"
-        });
-        Object.defineProperty(this, "request", {
-          value: request,
-          enumerable: true,
-          configurable: true
-        });
-        return request;
-      },
-      enumerable: true,
-      configurable: true
     });
-    const response = await router(requestContext);
     if (!response) {
       if (next) {
         next();
@@ -157,7 +140,17 @@ function createMiddleware(router, options = {}) {
       res.off("error", cancel);
       reader.cancel(error).catch(() => {
       });
-      error && res.destroy(error);
+      if (error) {
+        if (process.env.NODE_ENV !== "production" && devServer) {
+          res.end();
+          devServer.ws.send({
+            type: "error",
+            err: { message: error.message, stack: error.stack || "" }
+          });
+        } else {
+          res.destroy(error);
+        }
+      }
     }
     async function write() {
       try {
@@ -183,6 +176,6 @@ function createMiddleware(router, options = {}) {
   };
 }
 export {
-  createMiddleware as default,
+  createMiddleware,
   getOrigin
 };

package/dist/cli/index.mjs

@@ -98,12 +98,12 @@ var defaultPort = +process.env.PORT || 3e3;
 var defaultConfigFileBases = ["serve.config", "vite.config"];
 var defaultConfigFileExts = [".js", ".cjs", ".mjs", ".ts", ".mts"];
 var prog = sade("marko-run").version("0.0.1").option("-c, --config", `Provide path to a Vite config file (by default looks for a file starting with ${defaultConfigFileBases.join(" or ")} with one of these extensions: ${defaultConfigFileExts.join(", ")})`).option("-e, --env", "Provide path to a dotenv file");
-prog.command("serve [entry]", "", { default: true }).describe("Start a production-like server for already-built app files").option("-o, --output", "Directory to serve files from, and write asset files to if `--build` (default: )").option("-p, --port", "Port the server should listen on (defaults: `$PORT` env variable or 3000)").option("-f, --file", "Output file to start").action(async (entry, opts) => {
+prog.command("serve [entry]").describe("Start a production-like server for already-built app files").option("-o, --output", "Directory to serve files from, and write asset files to if `--build` (default: )").option("-p, --port", "Port the server should listen on (defaults: `$PORT` env variable or 3000)").option("-f, --file", "Output file to start").action(async (entry, opts) => {
   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 development server in watch mode").option("-p, --port", "Port the dev server should listen on (defaults: 'preview.port' in config, or `$PORT` env variable, or 3000)").example("dev --config vite.config.js").action(async (entry, opts) => {
+prog.command("dev [entry]", "", { default: true }).describe("Start development server in watch mode").option("-p, --port", "Port the dev server should listen on (defaults: 'preview.port' in config, or `$PORT` env variable, or 3000)").example("dev --config vite.config.js").action(async (entry, opts) => {
   const cmd = opts._.length ? `${entry} ${opts._.join(" ")}` : entry ? `node ${entry}` : void 0;
   const config2 = await getViteConfig(cwd, opts.config);
   await dev(cmd, config2, opts.port, opts.env);

package/dist/runtime/index.d.ts

@@ -1,11 +1,15 @@
 import type { HandlerLike, ParamsObject, Route, RouteContext } from "./types";
 declare global {
     namespace Marko {
-        interface Global {
-            context: RouteContext;
+        interface Global extends MarkoRun.CurrentContext {
+        }
+        interface Out {
+            global: Global;
         }
     }
     namespace MarkoRun {
+        const NotHandled: symbol;
+        const NotMatched: symbol;
         interface CurrentRoute extends Route {
         }
         interface CurrentContext extends RouteContext<CurrentRoute> {
@@ -14,4 +18,4 @@ declare global {
         function route<Params extends ParamsObject = {}, Meta = unknown>(handler: Handler<Params, Meta>): typeof handler;
     }
 }
-export type { HandlerLike, InputObject, InvokeRoute, MatchRoute, NextFunction, PathTemplate, RequestContext, Route, RouteContext, RouteContextExtensions, RouteHandler, RouteWithHandler, Router, ValidateHref, ValidatePath, } from "./types";
+export type { Fetch, HandlerLike, InputObject, Invoke, Match, NextFunction, PathTemplate, Route, RouteContext, RouteContextExtensions, RouteHandler, RouteWithHandler, RuntimeModule, ValidateHref, ValidatePath, } from "./types";

package/dist/runtime/internal.cjs

@@ -20,8 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/runtime/internal.ts
 var internal_exports = {};
 __export(internal_exports, {
-  RequestNotHandled: () => RequestNotHandled,
-  RequestNotMatched: () => RequestNotMatched,
+  NotHandled: () => NotHandled,
+  NotMatched: () => NotMatched,
   call: () => call,
   compose: () => compose,
   createInput: () => createInput,
@@ -31,17 +31,20 @@ __export(internal_exports, {
   notMatched: () => notMatched
 });
 module.exports = __toCommonJS(internal_exports);
-globalThis.MarkoRun ?? (globalThis.MarkoRun = {});
-globalThis.MarkoRun.route = (handler) => handler;
-var RequestNotHandled = Symbol();
-var RequestNotMatched = Symbol();
+var NotHandled = Symbol();
+var NotMatched = Symbol();
+globalThis.MarkoRun ?? (globalThis.MarkoRun = {
+  NotHandled,
+  NotMatched,
+  route(handler) {
+    return handler;
+  }
+});
 function createInput(context) {
   let existing;
   return (data) => {
     existing ?? (existing = {
-      $global: {
-        context
-      }
+      $global: context
     });
     return data ? Object.assign(existing, data) : existing;
   };
@@ -78,7 +81,7 @@ async function call(handler, next, context) {
       response = await handler(context, next);
     } catch (error) {
       if (error == null) {
-        throw RequestNotHandled;
+        throw NotHandled;
       } else if (error instanceof Response) {
         return error;
       }
@@ -86,7 +89,7 @@ async function call(handler, next, context) {
     }
   }
   if (response === null) {
-    throw RequestNotMatched;
+    throw NotMatched;
   }
   return response || next();
 }
@@ -136,8 +139,8 @@ function notMatched() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RequestNotHandled,
-  RequestNotMatched,
+  NotHandled,
+  NotMatched,
   call,
   compose,
   createInput,

package/dist/runtime/internal.d.ts

@@ -1,6 +1,6 @@
 import type { InputObject, NextFunction, Route, RouteContext, RouteHandler } from "./types";
-export declare const RequestNotHandled: unique symbol;
-export declare const RequestNotMatched: unique symbol;
+export declare const NotHandled: unique symbol;
+export declare const NotMatched: 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;

package/dist/runtime/internal.js

@@ -1,15 +1,18 @@
 // src/runtime/internal.ts
-globalThis.MarkoRun ?? (globalThis.MarkoRun = {});
-globalThis.MarkoRun.route = (handler) => handler;
-var RequestNotHandled = Symbol();
-var RequestNotMatched = Symbol();
+var NotHandled = Symbol();
+var NotMatched = Symbol();
+globalThis.MarkoRun ?? (globalThis.MarkoRun = {
+  NotHandled,
+  NotMatched,
+  route(handler) {
+    return handler;
+  }
+});
 function createInput(context) {
   let existing;
   return (data) => {
     existing ?? (existing = {
-      $global: {
-        context
-      }
+      $global: context
     });
     return data ? Object.assign(existing, data) : existing;
   };
@@ -46,7 +49,7 @@ async function call(handler, next, context) {
       response = await handler(context, next);
     } catch (error) {
       if (error == null) {
-        throw RequestNotHandled;
+        throw NotHandled;
       } else if (error instanceof Response) {
         return error;
       }
@@ -54,7 +57,7 @@ async function call(handler, next, context) {
     }
   }
   if (response === null) {
-    throw RequestNotMatched;
+    throw NotMatched;
   }
   return response || next();
 }
@@ -103,8 +106,8 @@ function notMatched() {
   return null;
 }
 export {
-  RequestNotHandled,
-  RequestNotMatched,
+  NotHandled,
+  NotMatched,
   call,
   compose,
   createInput,

package/dist/runtime/router.cjs

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

package/dist/runtime/router.d.ts

@@ -1,4 +1,3 @@
-import type { MatchRoute, RequestContext, Route } from "./types";
-export declare const router: <T>(context: RequestContext<T>) => Promise<Response | void>;
-export declare const matchRoute: MatchRoute;
-export declare const invokeRoute: <T>(route: Route | null, context: RequestContext<T>) => Promise<Response | void>;
+export declare const fetch: <Platform = unknown>(request: Request, platform: Platform) => Promise<void | Response>;
+export declare const match: (method: string, pathname: string) => import("./types").RouteWithHandler<{}, unknown, string> | null;
+export declare const invoke: <Platform = unknown>(route: import("./types").RouteWithHandler<{}, unknown, string> | null, request: Request, platform: Platform) => Promise<void | Response>;

package/dist/runtime/router.js

@@ -4,11 +4,11 @@ function notImplemented() {
     "This should have been replaced by the @marko/run plugin at build/dev time"
   );
 }
-var router = notImplemented;
-var matchRoute = notImplemented;
-var invokeRoute = notImplemented;
+var fetch = notImplemented;
+var match = notImplemented;
+var invoke = notImplemented;
 export {
-  invokeRoute,
-  matchRoute,
-  router
+  fetch,
+  invoke,
+  match
 };

package/dist/runtime/types.d.ts

@@ -7,20 +7,17 @@ export interface RouteContextExtensions {
 }
 export declare type ParamsObject = Record<string, string>;
 export declare type InputObject = Record<PropertyKey, any>;
-export interface RequestContext<T = unknown> {
+export declare type RouteContext<Platform = unknown, TRoute extends Route = Route> = TRoute extends any ? Combine<RouteContextExtensions & Readonly<{
     url: URL;
-    method: string;
     request: Request;
-    platform: T;
-}
-export declare type RouteContext<TRoute extends Route = Route> = TRoute extends any ? Combine<RouteContextExtensions & Readonly<RequestContext & {
     route: TRoute["path"];
     params: TRoute["params"];
     meta: TRoute["meta"];
+    platform: Platform;
 }>> : 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 declare type RouteHandler<TRoute extends Route = Route> = (context: RouteContext<unknown, TRoute>, next: NextFunction) => Awaitable<Response | null | void>;
 export interface Route<Params extends ParamsObject = {}, Meta = unknown, Path extends string = string> {
     path: Path;
     params: Params;
@@ -29,9 +26,14 @@ export interface Route<Params extends ParamsObject = {}, Meta = unknown, Path ex
 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 = unknown> = (context: RequestContext<T>) => Promise<Response | void>;
-export declare type InvokeRoute<T = unknown> = (route: Route | null, context: RequestContext<T>) => Promise<Response | void>;
+export declare type Fetch<Platform = unknown> = (request: Request, platform: Platform) => Promise<Response | void>;
+export declare type Match = (method: string, pathname: string) => RouteWithHandler | null;
+export declare type Invoke = <Platform = unknown>(route: RouteWithHandler | null, request: Request, platform: Platform) => Promise<Response | void>;
+export interface RuntimeModule {
+    fetch: <Platform = unknown>(request: Request, platform: Platform) => Promise<Response | void>;
+    match: (method: string, pathname: string) => RouteWithHandler | null;
+    invoke: <Platform = unknown>(route: RouteWithHandler | null, request: Request, platform: Platform) => Promise<Response | void>;
+}
 declare type Member<T, U> = T extends T ? (U extends T ? T : never) : never;
 declare type Segments<T extends string, Acc extends string[] = []> = T extends "" ? Acc : T extends `${infer Left}/${infer Rest}` ? Segments<Rest, [...Acc, Left]> : [...Acc, T];
 declare type GTE<A extends any[], B extends any[]> = A["length"] extends B["length"] ? 1 : A extends [infer _Ha, ...infer Ta] ? B extends [infer _Hb, ...infer Tb] ? GTE<Ta, Tb> : 1 : 0;

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

@@ -3,4 +3,4 @@ export declare function renderRouteTemplate(route: Route): string;
 export declare function renderRouteEntry(route: Route): 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;
+export declare function renderRouteTypeInfo(routes: BuiltRoutes, pathPrefix?: string, adapterTypes?: string): string;