@marko/run 0.0.1-beta3 → 0.0.1-beta4

package/README.md

@@ -1,31 +1,33 @@
-<h1 align="center">
+<div align="center">
   <!-- Logo -->
-  <img src="https://user-images.githubusercontent.com/4985201/115444712-ca550500-a1c9-11eb-9897-238ece59129c.png" height="118"/>
-  <br/>
-  @marko/run
-	<br/>
+  <h1>
+    <img alt="" src="https://user-images.githubusercontent.com/4985201/115444712-ca550500-a1c9-11eb-9897-238ece59129c.png" height="118"/>
+    <br/>
+    @marko/run
+  </h1>
 
   <!-- Language -->
-  <a href="http://typescriptlang.org">
+  <a href="https://www.typescriptlang.org">
     <img src="https://img.shields.io/badge/%3C%2F%3E-typescript-blue.svg" alt="TypeScript"/>
   </a>
-</h1>
+</div>
 
-Vite plugin for Marko with these features
-- Encapsulates [@marko/vite](https://github.com/marko-js/vite)
+`@marko/serve` is a Vite plugin for [Marko](https://markojs.com), with these features:
+
+- Encapsulates [`@marko/vite`](https://github.com/marko-js/vite)
 - File-based routing with layouts and middleware
 - Efficient routing using a compiled static trie
-- Designed with web standards to run anywhere
+- [Designed with web standards](https://developer.mozilla.org/en-US/docs/Web/API/URLPattern/URLPattern) to run anywhere
 
-## Intallation
+## Installation
 
-```
+```sh
 npm install @marko/run
 ```
 
 ## Vite Plugin
 
-This package provides both a Vite plugin and a runtime import. The Vite plugin is responsible for discovering your route files, generating the routing code and registering the @marko/vite plugin which builds your .marko files.
+This package’s Vite plugin discovers your route files, generates the routing code, and registers the `@marko/vite` plugin to compile your `.marko` files.
 
 ```ts
 // vite.config.ts
@@ -35,27 +37,32 @@ import marko from "@marko/run/vite"; // Import the Vite plugin
 export default defineConfig({
   plugins: [marko()], // Register the Vite plugin
   build: {
-    sourcemap: true, // Generate sourcemaps for all builds.
-    emptyOutDir: false, // Avoid server & client deleting files from each other.
+    sourcemap: true, // Generate sourcemaps for all builds
+    emptyOutDir: false, // Avoid server & client deleting files from each other. TODO: do we have to make the user set this themselves?
   }
 })
 ```
 
 ## Runtime
 
-Generally you'll want to use one of the adapters to provide a more convenient experience but this package provides the following runtime interface:
+Generally, using one of the adapters is more convenient <!-- TODO: is an “adapter” the same thing as using the Vite plugin above? -->, but this package also provides a runtime API:
 
 ```ts
 import { router, getMatchedRoute } from '@marko/run`;
 ```
 
 ### `router`
+
 ```ts
 (request: Request) => Promise<Response>;
 ```
-This asynchronouse function takes a [WHATWG request](https://fetch.spec.whatwg.org/#request-class) object and returns a [response](https://fetch.spec.whatwg.org/#response-class) object generated by executing the corresponding matched route files. If no match is found, a response with a 404 status code is returned. If an unhandled error occurs, a response with a 500 status code will be returned.
+
+This asynchronous function takes a [WHATWG `Request` object](https://fetch.spec.whatwg.org/#request-class) and returns a [`Response` object](https://fetch.spec.whatwg.org/#response-class) generated by executing any matched route files.
+
+If no match is found, returns a response with a `404` status code. If an unhandled error occurs, returns a response with a `500` status code.
 
 ### `getMatchedRoute`
+
 ```ts
 (method: string, url: URL) => {
   params: Record<string, string>;
@@ -63,20 +70,25 @@ This asynchronouse function takes a [WHATWG request](https://fetch.spec.whatwg.o
   invoke(request: Request): Promise<Response>;
 } | null;
 ```
-This synchronous function takes a HTTP verb method, and URL and returns an object representing the best match or null if no match is found.
-- `params` - a key-value collection of any path parameters for the route
-- `meta` - meta data for the route
-- `invoke` - an asynchronouse function that takes a WHATWG request and returns the response generated by executing the matched route files. Note: unlike the top-level `router` function errors will not be caught.
+
+This synchronous function takes an HTTP method + URL, then returns an object representing the best match — or `null` if no match is found.
+
+- `params` - a `{ key: value }` collection of any path parameters for the route
+- `meta` - metadata for the route
+- `invoke` - an asynchronous function that takes a `Request` and returns the `Response` generated from matched route files.
+  > **Note**: unlike the top-level `router` function, errors will not be caught.
 
 ## File-based Routing
 
-## Nested Routing
+### Nested Routing
 
-*TODO: provide a quick overview*
+*🎗 TODO: provide a quick overview*
 
 ### Routes Directory
 
-By default, the plugin will look for files in the configured _routes directory_. By default it will look in `./src/routes` (relative to the Vite config file) which can be configured:
+The plugin looks for route files in the configured **routes directory**. By default, that’s `./src/routes`, relative to the Vite config file.
+
+To change what directory routes are found in:
 
 ```ts
 // vite.config.ts
@@ -86,55 +98,56 @@ import marko from "@marko/run/vite";
 export default defineConfig({
   plugins: [marko({
     routesDir: 'src/pages' // Use `./src/pages` (relative to this file) as the routes directory
-  })],
-  //...
+  })]
 })
 ```
 
 ### Routeable Files
 
-In order to allow for co-location of files that should not be served (e.g. tests, stories, assets), the router only recognizes a specific set of file names. The following files will be discovered in any directory within your application's _routes directory_.
+To allow for colocation of files that shouldn’t be served (like tests, assets, etc.), the router only recognizes certain filenames.
+
+The following filenames will be discovered in any directory inside your application’s [routes directory](#routes-directory).
 
 #### `+page.marko`
-These files establish a route at the current directory path which will be served for GET requests with the HTML content of the page. Only one page may exists for any served path.
+
+These files establish a route at the current directory path which will be served for `GET` requests with the HTML content of the page. Only one page may exists for any served path.
 
 #### `+layout.marko`
-These files provide a layout component which will wrap all nested layouts and pages.
 
-<details>
-  <summary>More Info</summary>
-  
-  Layouts are just like any other Marko component with no extra constraints. Each layout receives the request, path params, URL and route meta data as input as well as a renderBody which will be the subsequent layout or page to project. 
-
-  ```marko
-  <div>
-    <h1>My Products</h1>
-    <main>
-      ${input.renderBody} // project the page or layout here
-    </main>
-  </div>
-  ```
-</details>
+These files provide a **layout component**, which will wrap all nested layouts and pages.
+
+Layouts are like any other Marko component with no extra constraints. Each layout receives the request, path params, URL, and route metadata as input, as well as a `renderBody` which will be the next layout or page to project. 
+
+```marko
+<main>
+  <h1>My Products</h1>
+
+  ${input.renderBody} // render the page or layout here
+</main>
+```
 
 #### `+handler.*`
-These files establish a route at the current directory path which can handle requests for GET, POST, PUT and DELETE HTTP verbs. Typically these will be .js or .ts files depending on your project. Just like pages, only one handler may exist for any served path. A handler should export functions
+
+These files establish a route at the current directory path which can handle requests for `GET`, `POST`, `PUT`, and `DELETE` HTTP methods. <!-- TODO: what about HEAD? -->
+
+Typically, these will be `.js` or `.ts` files depending on your project. Like pages, only one handler may exist for any served path. A handler should export functions
 
 <details>
   <summary>More Info</summary>
   
-  - Valid exports are: `get`, `post`, `put`, `del`.
-  - Each method takes a `context` and `next` argument and should return a WHATWG response either synchronously or asynchronously.
-  - The `context` argument contains the WHATWG request object, path parameters, URL and route meta data.
-  - The `next` argument will call the page for get requests where applicable or return a 204 response.
+  - Valid exports are functions named `get`, `post`, `put`, or `del`.
+  - Each export receives a `context` and `next` argument, and should return a WHATWG `Response` either synchronously or asynchronously.
+    - The `context` argument contains the WHATWG request object, path parameters, URL, and route metadata.
+    - The `next` argument will call the page for get requests where applicable or return a `204` response.
 
-  ```ts
+  ```js
   export function post(context, next) {
     const { request, params, url, meta } = context;
-    return new Response('updated', { status: 200 });
+    return new Response('Successfully updated', { status: 200 });
   }
 
   export function put(context, next) {
-    return new Response('created', { status: 201 }); // handle the request
+    return new Response('Successfully created', { status: 201 }); // handle the request
   }
 
   export function get(context, next) {
@@ -142,29 +155,33 @@ These files establish a route at the current directory path which can handle req
   }
 
   export function del(context, next) {
-    return new Response('removed', { status: 204 });
+    return new Response('Successfully removed', { status: 204 });
   }
   ```
 </details>
 
 
-#### `+middlware.*`
-These files are analagous to layouts for handlers. Middlware get called before handlers and let you perform arbitrary work before and after. Unlike handlers, middleware run for all HTTP verbs.
+#### `+middleware.*`
+
+These files are like layouts, but for handlers. Middleware get called before handlers and let you perform arbitrary work before and after.
+
+> **Note**: Unlike handlers, middleware run for all HTTP methods.
 
 <details>
   <summary>More Info</summary>
   
-  - Expects default export that takes a `context` and `next` argument and should return a WHATWG response either synchronously or asynchronously.
-  - The `context` argument contains the WHATWG request object, path parameters, URL and route meta data.
-  - The `next` argument will call the next middleware, handler or page as applicable for the route.
+  Expects a `default` export that receives a `context` and `next` argument, and should return a WHATWG response either synchronously or asynchronously.
+	
+  - The `context` argument contains the WHATWG `Request` object, path parameters, URL, and route metadata.
+  - The `next` argument will call the next middleware, handler, or page for the route.
 
   ```ts
   export default async function(context, next) {
-    const requestName = `${ctx.request.method} ${ctx.url.href}`;
+    const requestName = `${ctx.request.method} ${ctx.url.href}`; // TODO: could this be just `ctx.url` with a `toString` that then grabs `.href`?
     let success = true;
     console.log(`${requestName} request started`)
     try {
-      return await next(); // wait for subsequent middleware/handler/page
+      return await next(); // Wait for subsequent middleware/handler/page
     } catch (err) {
       success = false;
       throw err;
@@ -176,30 +193,42 @@ These files are analagous to layouts for handlers. Middlware get called before h
 </details>
 
 #### `+meta.*`
-These files represent some meta data to attach to the route. This meta data will be automatically imported by the router and provided on the the route context when invoking a route. 
+
+These files represent metadata to attach to the route. This metadata will be automatically provided on the the route `context` when invoking a route. 
 
 ### Special Files
 
-In addition to the files above which can be defined in any directory under the _routes directory_, there are some special files which can only be defined within the _routes directory_:
+In addition to the files above which can be defined in any directory under the _routes directory_, there are some special files which can only be defined at the top-level of the _routes directory_. <!-- TODO: do we want to keep this restriction? Having nested 404s would be handy for disambiguating things like “there’s no user with that name” or “that promotion wasn’t found, it may have expired” -->
+
+These special pages are subject to a root layout file (`pages/+layout.marko` in the default configuration).
 
 #### `+404.marko`
-This is a special page wich will be rendered for any request whose `Accept` header includes `text/html` if no other handler or page handled the request. This page will be subject to the root layout file (ie. +layout.marko file in the _routes directory_). Responses with this page will have a `404` status code.
+
+This special page responds to any request where:
+
+- The `Accept` request header includes `text/html`
+- *And* no other handler or page rendered the request
+
+Responses with this page will have a `404` status code.
 
 #### `+500.marko`
-This is a special page wich will be rendered for any request whose `Accept` header includes `text/html` if an uncaught error occurs while handling the request. This page will be subject to the root layout file (ie. +layout.marko file in the _routes directory_). Responses with this page will have a `500` status code.
 
+This special page responds to any request where:
+
+- The `Accept` request header includes `text/html`
+- *And* an uncaught error occurs while serving the request
+
+Responses with this page will have a `500` status code.
 
 ### Execution Order
 
-For a matched route the routable files execute in the following order
+For a matched route, the routable files execute in the following order:
+
 1. Middlewares from root-most to leaf-most
 2. Handler
 3. Layouts from root-most to leaf-most
 4. Page
 
-<details>
-  <summary>Diagram</summary>
-
 ```mermaid
 sequenceDiagram
     participant Middleware1
@@ -218,13 +247,12 @@ sequenceDiagram
     Handler-->>Middleware2: Response
     Middleware2-->>Middleware1: Response
 ```
-</details>
 
 ### Path Structure
 
-Within the _routes directory_ the directory structure will determine the path the route will be served. There are four types of directory names:
+Within the _routes directory_, the directory structure will determine the path the route will be served. There are four types of directory names: static, pathless, dynamic, and catch-all.
 
-- **Static directories** - The most common type of directory. Each static directory will contribute its name as a segment in the route's served path like a traditional file server. This is the default and unless the directory matches the requirements for one of the below types, it will be a static directory.
+1. **Static directories** - The most common type. Each static directory contributes its name as a segment in the route's served path, like a traditional fileserver. Unless a directory name matches the requirements for one of the below types, it defaults to a static directory.
 
   Examples:
   ```
@@ -233,7 +261,7 @@ Within the _routes directory_ the directory structure will determine the path th
   /projects
   ```
 
-- **Pathless directories** - These directories do not contribute their name to the route's served path. Directory names that start with an underscore ('_') as well as directories named 'index' will be a pathless directory.
+2. **Pathless directories** - These directories do **not** contribute their name to the route's served path. Directory names that start with an underscore (`_`) or directories named `index` will be a pathless directory.
 
   Examples:
   ```
@@ -242,7 +270,7 @@ Within the _routes directory_ the directory structure will determine the path th
   /index
   ```
 
-- **Dynamic directories** - These directories introduce a dynamic parameter to the route's served path and will match any value at that segment. Any directory name that starts with a single dollar sign ('\$') will be a dynamic directory and the remaining directory name will be the parameter at runtime. In the case the directory name is '$', the parameter will not exist at runtime but will be matched.
+3. **Dynamic directories** - These directories introduce a dynamic parameter to the route's served path and will match any value at that segment. Any directory name that starts with a single dollar sign (`$`) will be a dynamic directory, and the remaining directory name will be the parameter at runtime. If the directory name is exactly `$/`, the parameter will not exist at runtime but will be matched.
 
   Examples:
   ```
@@ -251,9 +279,9 @@ Within the _routes directory_ the directory structure will determine the path th
   /$
   ```
 
-- **Catcha-all directories** - These directories are similar to dynamic directories and introduce a dynamic parameter but instead of matching a single sement of the path, they match to the end of the path. Any directory that starts with two dollar signs ('\$\$') will be a catch-all directory and the remaining directory name will be the parameter at runtime. In the case of a directory name '$$', the parameter name at runtime will be '*'. Catch-all directories can be used to make not found/404 routes at any level including the root.
+4. **Catch-all directories** - These directories are similar to dynamic directories and introduce a dynamic parameter, but instead of matching a single path segment, they match to the end of the path. Any directory that starts with two dollar signs (`$$`) will be a catch-all directory, and the remaining directory name will be the parameter at runtime. In the case of a directory named `$$/`, the parameter name at runtime will be `*`. Catch-all directories can be used to make `404` Not Found routes at any level, including the root.
 
-  Because catch-all directories always match and consume all the remaining path, you cannot have nested routes within and no further directories will be traversed.
+  Because catch-all directories match any path segment and consume the rest of the path, you cannot nest route files in them and no further directories will be traversed.
 
   Examples:
   ```

package/dist/adapter/dev-server.d.ts

@@ -1,4 +1,4 @@
 import { ViteDevServer } from "vite";
-import { type NodeMiddleware } from "@marko/run/adapter/middleware";
+import { type NodeMiddleware } from "./middleware";
 export declare function createViteDevMiddleware<T>(devServer: ViteDevServer, load: (prev: T | undefined) => Promise<T>, factory: (value: T) => NodeMiddleware): NodeMiddleware;
 export declare function createDevServer(configFile?: string): Promise<import("vite").Connect.Server>;

package/dist/adapter/index.cjs

@@ -36,7 +36,173 @@ var import_url = require("url");
 
 // src/adapter/dev-server.ts
 var import_vite = require("vite");
-var import_middleware = __toESM(require("@marko/run/adapter/middleware"), 1);
+
+// src/adapter/middleware.ts
+var webStream = __toESM(require("stream/web"), 1);
+var import_crypto = __toESM(require("@hattip/polyfills/crypto"), 1);
+(0, import_crypto.default)();
+for (const key of Object.keys(webStream)) {
+  if (!(key in global)) {
+    global[key] = webStream[key];
+  }
+}
+function getForwardedHeader(req, name) {
+  const value = req.headers["x-forwarded-" + name];
+  if (value) {
+    if (typeof value === "string") {
+      const index = value.indexOf(",");
+      return index < 0 ? value : value.slice(0, index);
+    }
+    return value[0];
+  }
+}
+function getOrigin(req, protocol, host, trustProxy) {
+  var _a;
+  protocol ?? (protocol = req.protocol || trustProxy && getForwardedHeader(req, "proto") || ((_a = req.socket) == null ? void 0 : _a.encrypted) && "https" || "http");
+  host ?? (host = trustProxy && getForwardedHeader(req, "host") || req.headers.host);
+  if (!host) {
+    if (process.env.NODE_ENV !== "production") {
+      host = "localhost";
+      console.warn(
+        `Could not automatically determine the origin host, using 'localhost'. Use the 'origin' option or the 'ORIGIN' environment variable to set the origin explicitly.`
+      );
+    } else {
+      throw new Error(
+        `Could not automatically determine the origin host. Use the 'origin' option or the 'ORIGIN' environment variable to set the origin explicitly.`
+      );
+    }
+  }
+  return `${protocol}://${host}`;
+}
+function createMiddleware(router, options = {}) {
+  const { trustProxy = process.env.TRUST_PROXY === "1" } = options;
+  let { origin = process.env.ORIGIN } = options;
+  let protocol;
+  let host;
+  if (origin) {
+    ({ protocol, host } = new URL(origin));
+    protocol = protocol.slice(0, -1);
+  }
+  return async (req, res, next) => {
+    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 = {
+      method: req.method,
+      url,
+      platform: {
+        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();
+      } else {
+        res.statusCode = 404;
+        res.setHeader("content-length", "0");
+        res.end();
+        return;
+      }
+      return;
+    }
+    res.statusCode = response.status;
+    for (const [key, value] of response.headers) {
+      if (key === "set-cookie") {
+        let sepIndex = value.indexOf(",") + 1;
+        if (!sepIndex) {
+          res.setHeader(key, value);
+        } else {
+          let index = 0;
+          do {
+            res.appendHeader(key, value.slice(index, sepIndex - 1));
+            index = sepIndex;
+            sepIndex = value.indexOf(",", sepIndex) + 1;
+          } while (sepIndex);
+          res.appendHeader(key, value.slice(index));
+        }
+      } else {
+        res.setHeader(key, value);
+      }
+    }
+    if (!response.body) {
+      if (!response.headers.has("content-length")) {
+        res.setHeader("content-length", "0");
+      }
+      res.end();
+      return;
+    }
+    const reader = response.body.getReader();
+    if (res.destroyed) {
+      reader.cancel();
+      return;
+    }
+    res.on("close", cancel);
+    res.on("error", cancel);
+    write();
+    function cancel(error) {
+      res.off("close", cancel);
+      res.off("error", cancel);
+      reader.cancel(error).catch(() => {
+      });
+      error && res.destroy(error);
+    }
+    async function write() {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            res.end();
+            return;
+          } else if (!res.write(value)) {
+            res.once("drain", write);
+            return;
+          } else if (res.flush) {
+            res.flush();
+          }
+        }
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Error while writing to node response", {
+          cause: err
+        });
+        cancel(error);
+      }
+    }
+  };
+}
+
+// src/adapter/dev-server.ts
 function createViteDevMiddleware(devServer, load, factory) {
   let value;
   let middleware;
@@ -65,7 +231,7 @@ async function createDevServer(configFile) {
   const middleware = createViteDevMiddleware(
     devServer,
     async () => (await devServer.ssrLoadModule("@marko/run/router")).router,
-    import_middleware.default
+    createMiddleware
   );
   return devServer.middlewares.use(middleware);
 }

package/dist/adapter/index.d.ts

@@ -1,4 +1,5 @@
 import type { Adapter } from "../vite";
 export { createDevServer, createViteDevMiddleware } from "./dev-server";
 export type { Adapter };
+export type { NodePlatformInfo } from './middleware';
 export default function adapter(): Adapter;

package/dist/adapter/index.js

@@ -4,7 +4,173 @@ import { fileURLToPath } from "url";
 
 // src/adapter/dev-server.ts
 import { createServer } from "vite";
-import createMiddleware from "@marko/run/adapter/middleware";
+
+// src/adapter/middleware.ts
+import * as webStream from "stream/web";
+import installCrypto from "@hattip/polyfills/crypto";
+installCrypto();
+for (const key of Object.keys(webStream)) {
+  if (!(key in global)) {
+    global[key] = webStream[key];
+  }
+}
+function getForwardedHeader(req, name) {
+  const value = req.headers["x-forwarded-" + name];
+  if (value) {
+    if (typeof value === "string") {
+      const index = value.indexOf(",");
+      return index < 0 ? value : value.slice(0, index);
+    }
+    return value[0];
+  }
+}
+function getOrigin(req, protocol, host, trustProxy) {
+  var _a;
+  protocol ?? (protocol = req.protocol || trustProxy && getForwardedHeader(req, "proto") || ((_a = req.socket) == null ? void 0 : _a.encrypted) && "https" || "http");
+  host ?? (host = trustProxy && getForwardedHeader(req, "host") || req.headers.host);
+  if (!host) {
+    if (process.env.NODE_ENV !== "production") {
+      host = "localhost";
+      console.warn(
+        `Could not automatically determine the origin host, using 'localhost'. Use the 'origin' option or the 'ORIGIN' environment variable to set the origin explicitly.`
+      );
+    } else {
+      throw new Error(
+        `Could not automatically determine the origin host. Use the 'origin' option or the 'ORIGIN' environment variable to set the origin explicitly.`
+      );
+    }
+  }
+  return `${protocol}://${host}`;
+}
+function createMiddleware(router, options = {}) {
+  const { trustProxy = process.env.TRUST_PROXY === "1" } = options;
+  let { origin = process.env.ORIGIN } = options;
+  let protocol;
+  let host;
+  if (origin) {
+    ({ protocol, host } = new URL(origin));
+    protocol = protocol.slice(0, -1);
+  }
+  return async (req, res, next) => {
+    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 = {
+      method: req.method,
+      url,
+      platform: {
+        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();
+      } else {
+        res.statusCode = 404;
+        res.setHeader("content-length", "0");
+        res.end();
+        return;
+      }
+      return;
+    }
+    res.statusCode = response.status;
+    for (const [key, value] of response.headers) {
+      if (key === "set-cookie") {
+        let sepIndex = value.indexOf(",") + 1;
+        if (!sepIndex) {
+          res.setHeader(key, value);
+        } else {
+          let index = 0;
+          do {
+            res.appendHeader(key, value.slice(index, sepIndex - 1));
+            index = sepIndex;
+            sepIndex = value.indexOf(",", sepIndex) + 1;
+          } while (sepIndex);
+          res.appendHeader(key, value.slice(index));
+        }
+      } else {
+        res.setHeader(key, value);
+      }
+    }
+    if (!response.body) {
+      if (!response.headers.has("content-length")) {
+        res.setHeader("content-length", "0");
+      }
+      res.end();
+      return;
+    }
+    const reader = response.body.getReader();
+    if (res.destroyed) {
+      reader.cancel();
+      return;
+    }
+    res.on("close", cancel);
+    res.on("error", cancel);
+    write();
+    function cancel(error) {
+      res.off("close", cancel);
+      res.off("error", cancel);
+      reader.cancel(error).catch(() => {
+      });
+      error && res.destroy(error);
+    }
+    async function write() {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            res.end();
+            return;
+          } else if (!res.write(value)) {
+            res.once("drain", write);
+            return;
+          } else if (res.flush) {
+            res.flush();
+          }
+        }
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Error while writing to node response", {
+          cause: err
+        });
+        cancel(error);
+      }
+    }
+  };
+}
+
+// src/adapter/dev-server.ts
 function createViteDevMiddleware(devServer, load, factory) {
   let value;
   let middleware;

package/dist/adapter/middleware.cjs

@@ -79,20 +79,19 @@ 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 platform = {
-      ip,
-      request: req,
-      response: res,
-      setCookie(cookie) {
-        res.appendHeader("set-cookie", cookie);
-      }
-    };
-    const context = {
+    const requestContext = {
       method: req.method,
       url,
-      platform
+      platform: {
+        ip,
+        request: req,
+        response: res,
+        setCookie(cookie) {
+          res.appendHeader("set-cookie", cookie);
+        }
+      }
     };
-    Object.defineProperty(context, "request", {
+    Object.defineProperty(requestContext, "request", {
       get() {
         const headers = req.headers;
         const body = req.method === "GET" || req.method === "HEAD" ? void 0 : req.socket ? req : new ReadableStream({
@@ -118,7 +117,7 @@ function createMiddleware(router, options = {}) {
       enumerable: true,
       configurable: true
     });
-    const response = await router(context);
+    const response = await router(requestContext);
     if (!response) {
       if (next) {
         next();

package/dist/adapter/middleware.d.ts

@@ -1,4 +1,4 @@
-import type { Router } from "@marko/run";
+import type { Router } from "../runtime";
 import type { IncomingMessage, ServerResponse } from "http";
 declare module "net" {
     interface Socket {
@@ -14,10 +14,6 @@ declare module "http" {
         appendHeader(key: string, value: string | string[]): this;
     }
 }
-declare module "@marko/run" {
-    interface Platform extends NodePlatformInfo {
-    }
-}
 export interface NodePlatformInfo {
     ip: string;
     request: IncomingMessage;

package/dist/adapter/middleware.js

@@ -48,20 +48,19 @@ 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 platform = {
-      ip,
-      request: req,
-      response: res,
-      setCookie(cookie) {
-        res.appendHeader("set-cookie", cookie);
-      }
-    };
-    const context = {
+    const requestContext = {
       method: req.method,
       url,
-      platform
+      platform: {
+        ip,
+        request: req,
+        response: res,
+        setCookie(cookie) {
+          res.appendHeader("set-cookie", cookie);
+        }
+      }
     };
-    Object.defineProperty(context, "request", {
+    Object.defineProperty(requestContext, "request", {
       get() {
         const headers = req.headers;
         const body = req.method === "GET" || req.method === "HEAD" ? void 0 : req.socket ? req : new ReadableStream({
@@ -87,7 +86,7 @@ function createMiddleware(router, options = {}) {
       enumerable: true,
       configurable: true
     });
-    const response = await router(context);
+    const response = await router(requestContext);
     if (!response) {
       if (next) {
         next();

package/dist/cli/index.mjs

@@ -8,14 +8,18 @@ import { build as viteBuild, resolveConfig } from "vite";
 import sade from "sade";
 
 // src/vite/utils/config.ts
-var KEY = "__MARKO_SERVE_OPTIONS__";
-function getMarkoRunOptions(viteConfig) {
-  return viteConfig[KEY];
+var PluginConfigKey = "__MARKO_RUN_PLUGIN_CONFIG__";
+var AdapterConfigKey = "__MARKO_RUN_ADAPTER_CONFIG__";
+function getConfig(obj, key) {
+  return obj[key];
 }
-function setMarkoRunOptions(viteConfig, options) {
-  viteConfig[KEY] = options;
-  return viteConfig;
+function setConfig(obj, key, value) {
+  obj[key] = value;
+  return obj;
 }
+var getExternalPluginOptions = (viteConfig) => getConfig(viteConfig, PluginConfigKey);
+var setExternalPluginOptions = (viteConfig, value) => setConfig(viteConfig, PluginConfigKey, value);
+var setExternalAdapterOptions = (viteConfig, value) => setConfig(viteConfig, AdapterConfigKey, value);
 
 // src/cli/index.ts
 import { MemoryStore } from "@marko/vite";
@@ -91,18 +95,20 @@ 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").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) => {
+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) => {
   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) => {
+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) => {
   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);
 });
-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) => {
+prog.command("build [entry]").describe("Build the application (without serving it)").option("-o, --output", "Directory to write built files (default: )").option("--skip-client", "Skip the client-side build").example("build --config vite.config.js").action(async (entry, opts) => {
   const config2 = await getViteConfig(cwd, opts.config);
   await build(entry, config2, opts.ouput, opts["skip-client"], opts.env);
 });
@@ -117,9 +123,9 @@ async function preview(entry, configFile, port, outDir, envFile) {
   }
   const adapter = await resolveAdapter(resolvedConfig);
   if (!adapter) {
-    throw new Error("No adapter specified for serve command");
+    throw new Error("No adapter specified for 'serve' command");
   } else if (!adapter.startPreview) {
-    throw new Error(`Adapter ${adapter.name} does not support serve command`);
+    throw new Error(`Adapter ${adapter.name} does not support 'serve' command`);
   }
   const dir = path.resolve(cwd, resolvedConfig.build.outDir);
   const entryFile = entry ? path.join(dir, entry) : await findFileWithExt(dir, "index", [".mjs", ".js"]);
@@ -145,10 +151,10 @@ async function dev(cmd, configFile, port, envFile) {
     const adapter = await resolveAdapter(resolvedConfig);
     if (!adapter) {
       throw new Error(
-        "No adapter specified for dev command without custom target"
+        "No adapter specified for 'dev' command without custom target"
       );
     } else if (!adapter.startDev) {
-      throw new Error(`Adapter ${adapter.name} does not support serve command`);
+      throw new Error(`Adapter '${adapter.name}' does not support 'serve' command`);
     } else {
       await adapter.startDev(configFile, port, envFile);
     }
@@ -156,38 +162,39 @@ async function dev(cmd, configFile, port, envFile) {
 }
 async function build(entry, configFile, outDir, skipClient = false, envFile) {
   var _a;
+  const resolvedConfig = await resolveConfig(
+    { root: cwd, configFile },
+    "build"
+  );
+  const adapter = await resolveAdapter(resolvedConfig);
+  if (!adapter) {
+    throw new Error("No adapter specified for build command without entry");
+  }
   if (!entry) {
-    const resolvedConfig = await resolveConfig(
-      { root: cwd, configFile },
-      "build"
-    );
-    const adapter = await resolveAdapter(resolvedConfig);
-    if (!adapter) {
-      throw new Error("No adapter specified for build command without entry");
-    }
     entry = await ((_a = adapter.getEntryFile) == null ? void 0 : _a.call(adapter));
     if (!entry) {
       throw new Error(
-        `Adapter ${adapter.name} does not support build command without entry`
+        `Adapter '${adapter.name}' does not support building without an entry`
       );
     }
   }
   if (envFile) {
     envFile = path.resolve(cwd, envFile);
   }
-  const buildConfig = setMarkoRunOptions(
-    {
-      root: cwd,
-      configFile,
-      build: {
-        ssr: false,
-        outDir
-      }
-    },
-    {
-      store: new MemoryStore()
+  let buildConfig = {
+    root: cwd,
+    configFile,
+    build: {
+      ssr: false,
+      outDir
     }
-  );
+  };
+  buildConfig = setExternalPluginOptions(buildConfig, {
+    store: new MemoryStore()
+  });
+  buildConfig = setExternalAdapterOptions(buildConfig, {
+    envFile
+  });
   await viteBuild({
     ...buildConfig,
     build: {
@@ -211,7 +218,7 @@ async function build(entry, configFile, outDir, skipClient = false, envFile) {
     });
   }
 }
-function findFileWithExt(dir, base, extensions = [".js", ".cjs", ".mjs", ".ts", ".mts"]) {
+function findFileWithExt(dir, base, extensions = defaultConfigFileExts) {
   for (const ext of extensions) {
     const filePath = path.join(dir, base + ext);
     if (fs2.existsSync(filePath)) {
@@ -220,10 +227,11 @@ function findFileWithExt(dir, base, extensions = [".js", ".cjs", ".mjs", ".ts",
   }
   return void 0;
 }
-async function getViteConfig(dir, configFile, bases = ["serve.config", "vite.config"]) {
+async function getViteConfig(dir, configFile, bases = defaultConfigFileBases) {
   if (configFile) {
-    if (!fs2.existsSync(path.join(dir, configFile))) {
-      throw new Error(`Unable to load config file '${configFile}' from ${dir}`);
+    const configFilePath = path.join(dir, configFile);
+    if (!fs2.existsSync(configFilePath)) {
+      throw new Error(`No config file found at '${configFilePath}'`);
     }
     return configFile;
   }
@@ -236,9 +244,9 @@ async function getViteConfig(dir, configFile, bases = ["serve.config", "vite.con
   return path.join(__dirname, "default.config.mjs");
 }
 async function resolveAdapter(config2) {
-  const options = getMarkoRunOptions(config2);
+  const options = getExternalPluginOptions(config2);
   if (!options) {
-    throw new Error("Unable to resolve Marko Serve options");
+    throw new Error("Unable to resolve @marko/serve options");
   }
   return options.adapter;
 }

package/dist/runtime/router.cjs

@@ -26,7 +26,9 @@ __export(router_exports, {
 });
 module.exports = __toCommonJS(router_exports);
 function notImplemented() {
-  throw new Error("This should have been replaced by the @marko/run plugin at build/dev time");
+  throw new Error(
+    "This should have been replaced by the @marko/run plugin at build/dev time"
+  );
 }
 var router = notImplemented;
 var matchRoute = notImplemented;

package/dist/runtime/router.d.ts

@@ -1,4 +1,4 @@
-import type { InvokeRoute, MatchRoute, Router } from './types';
-export declare const router: Router<import("./types").Platform>;
+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: InvokeRoute<import("./types").Platform>;
+export declare const invokeRoute: <T>(route: Route | null, context: RequestContext<T>) => Promise<Response | void>;

package/dist/runtime/router.js

@@ -1,6 +1,8 @@
 // src/runtime/router.ts
 function notImplemented() {
-  throw new Error("This should have been replaced by the @marko/run plugin at build/dev time");
+  throw new Error(
+    "This should have been replaced by the @marko/run plugin at build/dev time"
+  );
 }
 var router = notImplemented;
 var matchRoute = notImplemented;

package/dist/runtime/types.d.ts

@@ -5,11 +5,9 @@ declare type Combine<T> = T extends object ? {
 } : 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> {
+export interface RequestContext<T = unknown> {
     url: URL;
     method: string;
     request: Request;
@@ -32,6 +30,6 @@ export interface RouteWithHandler<Params extends ParamsObject = {}, Meta = unkno
     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 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 {};

package/dist/vite/index.cjs

@@ -1219,14 +1219,18 @@ function prettyPath(path3) {
 }
 
 // src/vite/utils/config.ts
-var KEY = "__MARKO_SERVE_OPTIONS__";
-function getMarkoRunOptions(viteConfig) {
-  return viteConfig[KEY];
+var PluginConfigKey = "__MARKO_RUN_PLUGIN_CONFIG__";
+var AdapterConfigKey = "__MARKO_RUN_ADAPTER_CONFIG__";
+function getConfig(obj, key) {
+  return obj[key];
 }
-function setMarkoRunOptions(viteConfig, options) {
-  viteConfig[KEY] = options;
-  return viteConfig;
+function setConfig(obj, key, value) {
+  obj[key] = value;
+  return obj;
 }
+var getExternalPluginOptions = (viteConfig) => getConfig(viteConfig, PluginConfigKey);
+var setExternalPluginOptions = (viteConfig, value) => setConfig(viteConfig, PluginConfigKey, value);
+var getExternalAdapterOptions = (viteConfig) => getConfig(viteConfig, AdapterConfigKey);
 
 // src/vite/plugin.ts
 var import_url = require("url");
@@ -1267,10 +1271,8 @@ function markoServe(opts = {}) {
       "{.tsconfig*,tsconfig*.json}"
     ))) {
       const filepath = import_path2.default.join(typesDir, "routes.d.ts");
-      const data = renderRouteTypeInfo(
-        routes,
-        import_path2.default.relative(typesDir, routesDir)
-      );
+      const adapterTypeInfo = (adapter == null ? void 0 : adapter.writeTypeInfo) && await (adapter == null ? void 0 : adapter.writeTypeInfo());
+      const data = renderRouteTypeInfo(routes, import_path2.default.relative(typesDir, routesDir)) + adapterTypeInfo;
       if (data !== typesFile || !import_fs2.default.existsSync(filepath)) {
         await ensureDir(typesDir);
         await import_fs2.default.promises.writeFile(filepath, typesFile = data);
@@ -1335,13 +1337,19 @@ function markoServe(opts = {}) {
       enforce: "pre",
       async config(config2, env) {
         var _a, _b, _c;
-        const externalPluginOptions = getMarkoRunOptions(config2);
+        const externalPluginOptions = getExternalPluginOptions(config2);
         if (externalPluginOptions) {
           opts = (0, import_vite.mergeConfig)(opts, externalPluginOptions);
         }
-        const adapterOptions = await ((_a = adapter == null ? void 0 : adapter.pluginOptions) == null ? void 0 : _a.call(adapter, opts));
-        if (adapterOptions) {
-          opts = (0, import_vite.mergeConfig)(opts, adapterOptions);
+        if (adapter) {
+          const externalAdapterConfig = getExternalAdapterOptions(config2);
+          if (externalAdapterConfig && adapter.configure) {
+            adapter.configure(externalAdapterConfig);
+          }
+          const adapterOptions = await ((_a = adapter.pluginOptions) == null ? void 0 : _a.call(adapter, opts));
+          if (adapterOptions) {
+            opts = (0, import_vite.mergeConfig)(opts, adapterOptions);
+          }
         }
         root = (0, import_vite.normalizePath)(config2.root || process.cwd());
         store = opts.store || new import_vite2.FileStore(
@@ -1365,7 +1373,7 @@ function markoServe(opts = {}) {
         if (adapterConfig) {
           pluginConfig = (0, import_vite.mergeConfig)(pluginConfig, adapterConfig);
         }
-        return setMarkoRunOptions(pluginConfig, opts);
+        return setExternalPluginOptions(pluginConfig, opts);
       },
       configResolved(config2) {
         resolvedConfig = config2;

package/dist/vite/index.d.ts

@@ -1,4 +1,4 @@
 export { default } from "./plugin";
 export { getAvailablePort, isPortInUse, loadEnv, parseEnv, spawnServer, } from "./utils/server";
 export type { SpawnedServer } from "./utils/server";
-export type { Adapter, Options, BuiltRoutes, HttpVerb, ParamInfo, Route, RoutableFile, RoutableFileType, } from "./types";
+export type { Adapter, AdapterConfig, Options, BuiltRoutes, HttpVerb, ParamInfo, Route, RoutableFile, RoutableFileType, } from "./types";

package/dist/vite/index.js

@@ -1182,14 +1182,18 @@ function prettyPath(path3) {
 }
 
 // src/vite/utils/config.ts
-var KEY = "__MARKO_SERVE_OPTIONS__";
-function getMarkoRunOptions(viteConfig) {
-  return viteConfig[KEY];
+var PluginConfigKey = "__MARKO_RUN_PLUGIN_CONFIG__";
+var AdapterConfigKey = "__MARKO_RUN_ADAPTER_CONFIG__";
+function getConfig(obj, key) {
+  return obj[key];
 }
-function setMarkoRunOptions(viteConfig, options) {
-  viteConfig[KEY] = options;
-  return viteConfig;
+function setConfig(obj, key, value) {
+  obj[key] = value;
+  return obj;
 }
+var getExternalPluginOptions = (viteConfig) => getConfig(viteConfig, PluginConfigKey);
+var setExternalPluginOptions = (viteConfig, value) => setConfig(viteConfig, PluginConfigKey, value);
+var getExternalAdapterOptions = (viteConfig) => getConfig(viteConfig, AdapterConfigKey);
 
 // src/vite/plugin.ts
 import { fileURLToPath } from "url";
@@ -1229,10 +1233,8 @@ function markoServe(opts = {}) {
       "{.tsconfig*,tsconfig*.json}"
     ))) {
       const filepath = path2.join(typesDir, "routes.d.ts");
-      const data = renderRouteTypeInfo(
-        routes,
-        path2.relative(typesDir, routesDir)
-      );
+      const adapterTypeInfo = (adapter == null ? void 0 : adapter.writeTypeInfo) && await (adapter == null ? void 0 : adapter.writeTypeInfo());
+      const data = renderRouteTypeInfo(routes, path2.relative(typesDir, routesDir)) + adapterTypeInfo;
       if (data !== typesFile || !fs2.existsSync(filepath)) {
         await ensureDir(typesDir);
         await fs2.promises.writeFile(filepath, typesFile = data);
@@ -1297,13 +1299,19 @@ function markoServe(opts = {}) {
       enforce: "pre",
       async config(config2, env) {
         var _a, _b, _c;
-        const externalPluginOptions = getMarkoRunOptions(config2);
+        const externalPluginOptions = getExternalPluginOptions(config2);
         if (externalPluginOptions) {
           opts = mergeConfig(opts, externalPluginOptions);
         }
-        const adapterOptions = await ((_a = adapter == null ? void 0 : adapter.pluginOptions) == null ? void 0 : _a.call(adapter, opts));
-        if (adapterOptions) {
-          opts = mergeConfig(opts, adapterOptions);
+        if (adapter) {
+          const externalAdapterConfig = getExternalAdapterOptions(config2);
+          if (externalAdapterConfig && adapter.configure) {
+            adapter.configure(externalAdapterConfig);
+          }
+          const adapterOptions = await ((_a = adapter.pluginOptions) == null ? void 0 : _a.call(adapter, opts));
+          if (adapterOptions) {
+            opts = mergeConfig(opts, adapterOptions);
+          }
         }
         root = normalizePath(config2.root || process.cwd());
         store = opts.store || new FileStore(
@@ -1327,7 +1335,7 @@ function markoServe(opts = {}) {
         if (adapterConfig) {
           pluginConfig = mergeConfig(pluginConfig, adapterConfig);
         }
-        return setMarkoRunOptions(pluginConfig, opts);
+        return setExternalPluginOptions(pluginConfig, opts);
       },
       configResolved(config2) {
         resolvedConfig = config2;

package/dist/vite/types.d.ts

@@ -3,14 +3,19 @@ import type { Options as MarkoViteOptions } from "@marko/vite";
 import type { ResolvedConfig, UserConfig } from "vite";
 export type { RoutableFileType, HttpVerb };
 export declare type StartServer = (port?: number) => Promise<void>;
+export interface AdapterConfig {
+    [name: PropertyKey]: any;
+}
 export interface Adapter {
     readonly name: string;
+    configure?(config: AdapterConfig): void;
     pluginOptions?(options: Options): Promise<Options> | Options | undefined;
     viteConfig?(config: UserConfig): Promise<UserConfig> | UserConfig | undefined;
     getEntryFile?(): Promise<string> | string;
     startDev?(configFile: string, port: number, envFile?: string): Promise<void> | void;
     startPreview?(dir: string, entry?: string, port?: number, envFile?: string): Promise<void> | void;
     buildEnd?(config: ResolvedConfig, routes: Route[], builtEntries: string[], sourceEntries: string[]): Promise<void> | void;
+    writeTypeInfo?(): Promise<string> | string;
 }
 export interface RouterOptions {
     trailingSlashes: 'Ignore' | 'RedirectWithout' | 'RedirectWith' | 'RewriteWithout' | 'RewriteWith';

package/dist/vite/utils/config.d.ts

@@ -1,3 +1,5 @@
-import type { Options } from '../types';
-export declare function getMarkoRunOptions<T extends Record<string, any>>(viteConfig: T): Readonly<Options> | undefined;
-export declare function setMarkoRunOptions<T extends Record<string, any>>(viteConfig: T, options: Options): T;
+import type { Options, AdapterConfig } from '../types';
+export declare const getExternalPluginOptions: <T>(viteConfig: T) => Readonly<Options> | undefined;
+export declare const setExternalPluginOptions: <T>(viteConfig: T, value: Options) => T;
+export declare const getExternalAdapterOptions: <T>(viteConfig: T) => Readonly<AdapterConfig> | undefined;
+export declare const setExternalAdapterOptions: <T>(viteConfig: T, value: AdapterConfig) => T;

package/dist/vite/utils/route.d.ts

@@ -1,3 +1,3 @@
 import type { HttpVerb, Route } from "../types";
-export declare function getVerbs(route: Route): ("get" | "post" | "put" | "delete")[];
+export declare function getVerbs(route: Route): ("get" | "delete" | "post" | "put")[];
 export declare function hasVerb(route: Route, verb: HttpVerb): boolean | import("../types").RoutableFile | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marko/run",
-  "version": "0.0.1-beta3",
+  "version": "0.0.1-beta4",
   "description": "File-based routing for Marko based on Vite",
   "keywords": [],
   "author": "Ryan Turnquist <rturnq@gmail.com>",
@@ -47,19 +47,19 @@
   "typesVersions": {
     "*": {
       "*": [
-        "./src/runtime/index.ts"
+        "./dist/runtime/index.d.ts"
       ],
       "router": [
-        "./src/runtime/router.ts"
+        "./dist/runtime/router.d.ts"
       ],
       "vite": [
-        "./src/vite/index.ts"
+        "./dist/vite/index.d.ts"
       ],
       "adapter/middleware": [
-        "./src/adapter/middleware.ts"
+        "./dist/adapter/middleware.d.ts"
       ],
       "adapter": [
-        "./src/adapter/index.ts"
+        "./dist/adapter/index.d.ts"
       ]
     }
   },
@@ -81,7 +81,7 @@
     "acorn": "^8.8.0",
     "cross-env": "^7.0.3",
     "esbuild": "^0.15.7",
-    "marko": "^5.21.9",
+    "marko": "^5.22.4",
     "mocha": "^10.0.0",
     "mocha-snap": "^4.3.0",
     "prettier": "^2.7.1",

package/dist/runtime/utils.d.ts

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