@johnhenry/letterpress 0.0.3 → 0.2.0

package/API.md

@@ -100,7 +100,7 @@ Content-Type: application/json
 
 Letterpress provides several utility functions to help with request and response handling:
 
-> Note: `@johnhenry/letterpress` does not export a `serve` function or a `tagRequest` function. To run a server, pair it with [leserve](https://www.npmjs.com/package/@johnhenry/leserve) (imported directly, e.g. `import serve from "@johnhenry/leserve"`) or any server of your choice. To build a `Request` from a template literal, use `createRequest` (see below).
+> Note: `@johnhenry/letterpress` does not export a `serve` function. To run a server, pair it with [leserve](https://www.npmjs.com/package/@johnhenry/leserve) (imported directly, e.g. `import serve from "@johnhenry/leserve"`) or any server of your choice. To build a `Request`/`Response` from a template literal, use `createRequest`/`createResponse` (forgiving) or `tagRequest`/`tagResponse` (strict -- see below for the difference).
 
 ### createRequest
 
@@ -130,6 +130,62 @@ Content-Type: application/json
 `;
 ```
 
+### tagRequest
+
+A strict, from-scratch parser of raw HTTP-request text (see the README's
+`createRequest`/`tagRequest` comparison table for the difference). The
+request line is required. Substitutions are spliced in verbatim -- never
+re-scanned for `"\n"`/`":"` -- so a substituted header value can safely
+contain either. A binary substitution (`Blob`/`Uint8Array`/`ArrayBuffer`/
+`ReadableStream`/`FormData`/`URLSearchParams`) becomes the real request
+body, but must be the sole content of the body -- combining it with other
+text throws.
+
+```javascript
+import { tagRequest } from "@johnhenry/letterpress";
+
+const request = await tagRequest`POST /users HTTP/1.1
+Host: example.com
+Content-Type: application/x-www-form-urlencoded
+Content-Length: 49
+
+name=FirstName+LastName&email=bsmth%40example.com`;
+
+// Defaults for anything the template doesn't specify -- headers only.
+// Method, URL, status, and body always come from the parsed template
+// text, never from defaults.
+const request2 = await tagRequest({ headers: { host: "example.com" } })`POST /users HTTP/1.1
+Content-Type: application/x-www-form-urlencoded
+Content-Length: 49
+
+name=FirstName+LastName&email=bsmth%40example.com`;
+
+// Sugar for the one common case -- throws if headers.host/Host is also set
+const request3 = await tagRequest({ host: "example.com" })`POST /users HTTP/1.1
+Content-Type: application/x-www-form-urlencoded
+Content-Length: 49
+
+name=FirstName+LastName&email=bsmth%40example.com`;
+```
+
+### tagResponse
+
+The response-side counterpart to `tagRequest` -- itself a tagged-template
+function (uncurried, like `createResponse`), requiring a status line.
+
+```javascript
+import { tagResponse } from "@johnhenry/letterpress";
+
+const response = await tagResponse`HTTP/1.1 201 Created
+Content-Type: application/json
+Location: http://example.com/users/123
+
+{
+  "message": "New user created",
+  "user": { "id": 123, "firstName": "Example", "lastName": "Person", "email": "bsmth@example.com" }
+}`;
+```
+
 ### HTTPExpression
 
 A tagged-template function for matching HTTP requests against a method/path/header pattern. It returns an object with `test(request)` and `exec(request)` methods — not `.method`/`.path`/`.version` properties.

package/CHANGELOG.md

@@ -6,6 +6,133 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 This project will adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) once it reaches 1.0.0.
 
+## [0.2.0] - 2026-09-30
+
+### Added
+
+- ✨ **`tagRequest`/`tagResponse`** (#8): a strict, from-scratch pair of
+  tagged-template functions for building `Request`/`Response` objects
+  directly from raw HTTP-message text, coexisting with the existing
+  `createRequest`/`createResponse` rather than replacing them -- see the
+  README's new comparison table under `createRequest`, `createResponse`,
+  `tagRequest`, `tagResponse`. The request/status line is required (no
+  implicit default the way `createRoute`'s `init` object provides one);
+  `defaults` only ever contributes headers (plus a `host` sugar key and a
+  few `Request`-only fields raw text can't express) -- method, URL,
+  status, and body always come from the parsed template text. A binary
+  substitution (`Blob`/`Uint8Array`/`ArrayBuffer`/`ReadableStream`/
+  `FormData`/`URLSearchParams`) becomes the real body, but must be the
+  sole content of the body zone -- combining it with other text throws,
+  rather than silently corrupting or discarding either side.
+- New shared internal parser, `utility/parse-http-text.mjs`: scans only
+  the template's literal `strings` pieces for structure (start line,
+  header lines, the blank line that ends them); a substitution's value is
+  spliced in verbatim and never re-scanned for `"\n"`/`":"`. This is the
+  single most important correctness property of the new parser -- see
+  below for how it also fixed two real, pre-existing bugs once
+  `create-route.mjs` was backported onto it.
+
+### Fixed
+
+- 🐛 **`createRoute`/`createResponse`/`createRouter` silently overwrote a
+  repeated header name instead of accumulating it** -- `headers.set()`
+  was called for every header line found while parsing a template, so
+  e.g. two `Set-Cookie:` lines in a template (or an `init.headers` value
+  plus a same-named template header) resulted in only the last one
+  surviving. Now: the first occurrence of a header name overwrites
+  whatever was already set (from `init`/a previous occurrence), and a
+  second-or-later occurrence of the *same name within the template*
+  accumulates via `.append()` instead. **This is a real, user-visible
+  behavior change** for anyone relying on repeated headers being silently
+  collapsed to the last one -- if that was intentional, call
+  `headers.delete(name)` before setting it again via `context.setHeader`.
+  Fixed in the same change as the next item, both via `create-route.mjs`
+  now delegating its structural parsing to `utility/parse-http-text.mjs`
+  (function-valued substitutions are still resolved by `create-route.mjs`
+  itself in a pre-pass, preserving their side-effect/early-return
+  behavior exactly).
+- 🐛 **A substituted value containing `"\n"` or `":"` could be
+  reinterpreted as new HTTP syntax** in `createRoute`/`createResponse`/
+  `createRouter` templates -- a stringified substitution was re-fed
+  through the same line tokenizer used for the template's own literal
+  text, so e.g. `` `X-Note: ${value}` `` could have `value` silently
+  start a new header line or end the header section early if it happened
+  to contain those characters. Regression tests added directly against
+  `createRoute` (not just via `tagRequest`/`tagResponse`) in
+  `test/route.mjs`.
+- Removed dead code in `create-route.mjs`: a `JSON.parse`-based
+  Content-Type auto-sniff that could never actually run, since
+  `Content-Type` was always already set to `text/html` by the
+  unconditional check immediately before it. No behavior change --
+  `Content-Type` already always ended up `text/html` for a JSON-shaped
+  body with no explicit header, both before and after this cleanup.
+
+### Can I rely on the old header-overwrite behavior? No.
+
+If any consumer depended on a repeated header name collapsing to the last
+value written (rather than accumulating), that behavior is gone as of
+this version. This was never documented as intentional -- it was an
+unreviewed side effect of `headers.set()` being called unconditionally --
+and the new behavior (both values survive, matching how real HTTP
+Set-Cookie accumulation works and how `createRequest`'s own header parser
+already behaved) is the one `create-route.mjs` was always meant to have.
+
+## [0.1.0] - 2026-09-28
+
+### Added
+
+- ✨ **`createRewriter`**: `leroute` (the package letterpress was renamed
+  from -- see the README's provenance note) had a `createRewriter` export
+  (`leroute/rewrite`) for request/response rewriting: rewriting an inbound
+  request's target path/headers before it reaches a handler, and rewriting
+  a handler's response headers/status on the way back out. This never got
+  carried over during the leroute -> `@johnhenry/letterpress` rename --
+  it simply wasn't in the initial `@johnhenry/letterpress` source, a gap
+  in that migration rather than an intentional removal. It was discovered
+  while porting a downstream consumer, `prism` (a live HTTP request
+  inspector/proxy), whose proxy mode depends on it for rewriting proxied
+  requests/responses. Ported unchanged in behavior as `rewrite.mjs`
+  (`createRewriter`, plus `rewriteRequest`/`rewriteResponse`/`addRule`/
+  `removeRule`/`getRules`/`middleware`), exposed via a dedicated
+  `@johnhenry/letterpress/rewrite` subpath -- mirroring how
+  `createFSRouter` is isolated on `@johnhenry/letterpress/fs` rather than
+  the main barrel -- with its own `rewrite.d.ts` types wired into
+  `package.json`'s `exports` map and `tsconfig.json`. Tests ported from
+  leroute's `test/rewrite.mjs` into `test/rewrite.mjs`, plus new
+  `./rewrite` subpath-export regression tests in `test/exports.mjs` and
+  `test/types/fixture.ts` coverage, following the same pattern the `./fs`
+  subpath already established.
+
+- ✨ **`router.mount(prefix, subHandler)`**: another `leroute` capability
+  (`create-lerouter.mjs`'s `router.mount`) dropped during the same rename,
+  found via the same `prism` port -- prism's own top-level router uses it
+  to mount its dashboard sub-router under `/inspect`. Delegates every
+  request under `prefix` to `subHandler` with the prefix stripped from the
+  forwarded request's path; `subHandler` may be a plain `(Request) =>
+  Response` function or an object exposing one as `.fetch`, so a `Router`
+  can mount another `Router`. Ported onto the main barrel (`create-router.mjs`,
+  right alongside `router.endpoint`, not an isolated subpath like `rewrite`
+  -- unlike `rewrite`/`fs`, `mount` is core routing behavior every router
+  needs, not an optional extra), dropping only the old implementation's
+  now-obsolete `middleware` and `request.raw` preservation (the current
+  `createRouter` doesn't have either concept). New `Mountable` type in
+  `types.d.ts`; seven new tests in `test/router.mjs` covering delegation,
+  the bare-prefix-with-no-trailing-segment case, 404 fallthrough for
+  non-matching paths, the `.fetch`-object form, query-string/method
+  preservation on the forwarded request, and ctx forwarding (below).
+
+- ✨ **The router's own dispatch now accepts an optional second `ctx`
+  argument** (`router(request, ctx?)`), merged underneath `init` and the
+  matched route's own params so a route's params can't be shadowed by it,
+  and forwarded to `defaultHandler` too. This was also present in `leroute`
+  (`router(request, ctx = {})`) and dropped during the rename; brought back
+  specifically so `mount()` can hand a mounted sub-router its `mountPrefix`
+  (used by `prism` to reconstruct the full request path for display in its
+  captured-request feed, purely cosmetic but a real fidelity gap otherwise)
+  -- caught by testing `mount()` end-to-end against `prism` itself, not by
+  a direct comparison against the old source this time. Existing single-arg
+  `router(request)` callers are unaffected (`ctx` defaults to `{}`).
+
 ## [0.0.3] - 2026-09-26
 
 ### Fixed

package/README.md

@@ -148,6 +148,23 @@ Creates a new router instance.
 - `errorHandler`: Custom error handler function (optional)
 - `cache`: Caching options (optional)
 
+### `router.mount(prefix: string, subHandler: Mountable): Router`
+
+Delegates every request under `prefix` to `subHandler`, with the prefix
+stripped from the forwarded request's path — e.g. `router.mount("/api",
+apiRouter)` sends a request for `/api/users` to `apiRouter` as `/users`.
+`subHandler` may be a plain `(Request) => Response` function or an object
+exposing one as `.fetch` — a `Router` satisfies both, so one router can
+mount another:
+
+```javascript
+const api = createRouter();
+api.endpoint`GET /users``[]`;
+
+const router = createRouter();
+router.mount("/api", api); // GET /api/users -> api's GET /users
+```
+
 ### `createRoute(options?: RouteInit): Route`
 
 Creates a new route handler.
@@ -171,9 +188,27 @@ expr.test(request); // boolean — does this request match?
 expr.exec(request); // matched params (plus method/headers), or null
 ```
 
-### `createRequest`, `createResponse`
+### `createRequest`, `createResponse`, `tagRequest`, `tagResponse`
+
+Four tagged-template functions for building `Request`/`Response` objects
+from raw HTTP-message-shaped template literals -- two pairs with a
+deliberately different purpose, not two ways to do the same thing:
+
+| | `createRequest` / `createResponse` | `tagRequest` / `tagResponse` |
+|---|---|---|
+| Purpose | convenient, forgiving builder | strict raw-HTTP-text parser |
+| Request/status line | optional / defaulted | **required** -- throws without one |
+| Header value containing `": "` | truncated | parses correctly |
+| Repeated header name (e.g. `Set-Cookie`) | both kept | both kept |
+| Interpolated value containing `\n`/`:` | re-tokenized as syntax | spliced in verbatim, never re-scanned |
+| Function-valued interpolation | not supported | not supported (use `createRoute` for that) |
+| Binary substitution (`Blob`/stream/etc.) | becomes the body | becomes the body, but **must be the sole body content** -- throws if combined with other text |
 
-Tagged-template functions for building `Request`/`Response` objects from raw HTTP-message-shaped template literals. See [api.md](./api.md) for details.
+Reach for `tagRequest`/`tagResponse` when a template literal needs to
+behave exactly like the HTTP text it looks like (tests, fixtures,
+hand-authored wire-format examples); reach for `createRequest`/
+`createResponse` for everyday convenience where partial specification is
+fine. See [api.md](./api.md) for the full examples of both.
 
 ### `createFSRouter`
 
@@ -189,7 +224,49 @@ import { createFSRouter } from "@johnhenry/letterpress/fs";
 > and the `theres-waldo` dependency, so it's kept out of the main entry
 > point to keep that entry point bundler-friendly for browser use. Everything
 > else (`createRouter`, `createRoute`, `createRequest`, `createResponse`,
-> `HTTPExpression`) is pure and safe to bundle for the browser.
+> `tagRequest`, `tagResponse`, `HTTPExpression`) is pure and safe to bundle
+> for the browser.
+
+### `createRewriter`
+
+Builds a request/response rewriter for target-URL/path rewriting -- e.g.
+rewriting an inbound path before it reaches a route, or rewriting a
+proxied response's headers/status on the way back out. Useful for proxy
+middleware (rewrite the target URL/path of a proxied request, adjust
+headers, force a status code) as well as plain routing (redirect old
+paths to new ones).
+
+```javascript
+import { createRewriter } from "@johnhenry/letterpress/rewrite";
+
+const rewriter = createRewriter([
+  {
+    match: { path: /^\/api\/v1\/(.*)/ },
+    action: { rewritePath: "/api/v2/$1" },
+  },
+]);
+
+// Wrap a handler: the handler receives the rewritten request, and its
+// response is run back through the rewriter before being returned.
+const handler = rewriter.middleware(async (request) => {
+  const url = new URL(request.url);
+  return new Response(`routed to ${url.pathname}`);
+});
+
+// Or call rewriteRequest/rewriteResponse directly, and manage rules with
+// addRule/removeRule/getRules.
+rewriter.addRule({ match: { path: "/teapot" }, action: { setStatus: 418 } });
+```
+
+> `createRewriter` is imported from the `@johnhenry/letterpress/rewrite`
+> subpath, not the main `@johnhenry/letterpress` barrel, mirroring how
+> `createFSRouter` is isolated on `@johnhenry/letterpress/fs` above.
+>
+> This existed in `leroute` (the package letterpress was renamed from --
+> see the provenance note near the top of this README) but was dropped
+> during that rename. It's ported here, discovered missing while porting a
+> downstream consumer (`prism`, a request inspector/proxy) that relies on
+> it for proxy-mode rewriting -- see CHANGELOG.md.
 
 ### `deconstruct`, `cook`
 
@@ -241,6 +318,13 @@ is designed to pair with a sibling package that does.
   `Route`-shaped function works too; `leserve` is the tested, documented
   pairing, not a hard dependency (it's a `devDependency` here, used only in
   the demo scripts).
+- **[`@johnhenry/prism`](https://github.com/johnhenry/prism)** -- a live
+  HTTP request inspector/proxy that uses `createRouter()` as its top-level
+  router. Porting it surfaced two real gaps left over from letterpress's
+  own rename from `leroute`: `router.mount()` (with the `ctx`-forwarding
+  its `mountPrefix` depends on) and `createRewriter`
+  (`@johnhenry/letterpress/rewrite`) -- both closed as part of that port,
+  see CHANGELOG.md.
 
 ## 🤝 Contributing
 

package/create-route.mjs

@@ -1,5 +1,25 @@
+import { parseHttpText } from "./utility/parse-http-text.mjs";
+
 const DEFAULT_REQUEST = () => new Request("http://.");
 
+// Same rule tag-request.mjs/tag-response.mjs use: the first occurrence of
+// a header name overwrites whatever was already set (e.g. from `init`),
+// a second-or-later occurrence of the *same name* accumulates instead of
+// overwriting it. Fixes the Set-Cookie-overwrite bug this file used to
+// have (headers.set() for every line, unconditionally).
+const mergeHeaderEntries = (headers, headerEntries) => {
+  const seen = new Set();
+  for (const { name, value } of headerEntries) {
+    const key = name.toLowerCase();
+    if (seen.has(key)) {
+      headers.append(name, value);
+    } else {
+      headers.set(name, value);
+      seen.add(key);
+    }
+  }
+};
+
 export const createRoute = (initOrMiddleware) => {
   const getInit =
     typeof initOrMiddleware === "function"
@@ -29,140 +49,57 @@ export const createRoute = (initOrMiddleware) => {
         ...additionalContext,
       };
 
-      const processInput = async () => {
-        let mode = "INITIAL";
-        let buffer = "";
-        let bodyContent = "";
-        let headerName = "";
-        let i = 0;
-        let j = 0;
-
-        const processChunk = (chunk) => {
-          buffer += chunk;
-          const lines = buffer.split("\n");
-
-          while (lines.length > 1) {
-            const line = lines.shift().trim();
-
-            switch (mode) {
-              case "INITIAL":
-                if (line.startsWith("HTTP/")) {
-                  const [httpVersion, statusCode, ...statusTextParts] =
-                    line.split(" ");
-                  status = parseInt(statusCode, 10);
-                  statusText = statusTextParts.join(" ");
-                  mode = "HEADER";
-                } else if (line !== "") {
-                  mode = "BODY";
-                  bodyContent += line + "\n";
-                }
-                break;
-
-              case "HEADER":
-                if (line === "") {
-                  mode = "BODY";
-                } else {
-                  const colonIndex = line.indexOf(":");
-                  if (colonIndex > 0) {
-                    const key = line.slice(0, colonIndex).trim();
-                    const value = line.slice(colonIndex + 1).trim();
-                    headers.set(key, value);
-                  }
-                }
-                break;
-
-              case "BODY":
-                bodyContent += line + "\n";
-                break;
-            }
-          }
-
-          buffer = lines[0] || "";
-        };
-
-        while (i < strings.length) {
-          processChunk(strings[i]);
-
-          if (j < substitutions.length) {
-            const sub = substitutions[j];
-            if (typeof sub === "function") {
-              const result = await sub(request, context);
-              if (
-                result instanceof ReadableStream ||
-                result instanceof Blob ||
-                result instanceof ArrayBuffer ||
-                result instanceof Uint8Array
-              ) {
-                // A substitution function can return a stream/binary value
-                // just like a directly-substituted one; it must get the
-                // same raw-passthrough treatment rather than being coerced
-                // via .toString() (which would produce "[object ...]").
-                if (!headers.has("Content-Type")) {
-                  headers.set(
-                    "Content-Type",
-                    result.type ?? "application/octet-stream" // Blob may have a type
-                  );
-                }
-                return result;
-              } else if (result !== undefined && result !== null) {
-                processChunk(result.toString());
-              }
-            } else if (
-              sub instanceof ReadableStream ||
-              sub instanceof Blob ||
-              sub instanceof ArrayBuffer ||
-              sub instanceof Uint8Array
-            ) {
-              if (!headers.has("Content-Type")) {
-                headers.set(
-                  "Content-Type",
-                  sub.type ?? "application/octet-stream" // Blob may have a type
-                );
-              }
-              return sub;
-            } else if (sub instanceof Headers) {
-              for (const [key, value] of sub) {
-                headers.set(key, value);
-              }
-            } else if (sub !== undefined && sub !== null) {
-              processChunk(sub.toString());
-            }
-            j++;
-          }
+      // Resolve every function-valued substitution up front -- this is
+      // create-route's one feature the shared parser doesn't (and
+      // shouldn't) know about: a substitution can run arbitrary async
+      // work and mutate `context` (headers/status) as a side effect, in
+      // addition to contributing a value to the template. `null`/
+      // `undefined` are preserved (parseHttpText already treats either as
+      // "contributes nothing," matching ordinary JS template semantics).
+      const resolvedSubstitutions = [];
+      for (const sub of substitutions) {
+        resolvedSubstitutions.push(
+          typeof sub === "function" ? await sub(request, context) : sub
+        );
+      }
 
-          i++;
+      const { startLine, headerEntries, body } = parseHttpText(
+        strings,
+        resolvedSubstitutions,
+        {
+          isStartLine: (line) => line.startsWith("HTTP/"),
+          trimBodyLines: true,
         }
+      );
 
-        // Process any remaining buffer content
-        if (buffer) {
-          processChunk("\n");
+      if (startLine !== null) {
+        const [, statusCodeText, ...statusTextParts] = startLine.split(" ");
+        const parsedStatus = parseInt(statusCodeText, 10);
+        if (!Number.isNaN(parsedStatus)) {
+          status = parsedStatus;
+          statusText = statusTextParts.join(" ");
         }
-
-        return bodyContent.trim();
-      };
-
-      let responseBody = await processInput();
-
-      if (!headers.has("Content-Type")) {
-        headers.set("Content-Type", "text/html");
       }
 
-      if (typeof responseBody === "string") {
-        try {
-          JSON.parse(responseBody);
-          if (!headers.has("Content-Type")) {
-            headers.set("Content-Type", "application/json");
-          }
-        } catch {
-          // Not JSON, keep existing Content-Type
-        }
+      mergeHeaderEntries(headers, headerEntries);
 
-        if (!headers.has("Content-Length")) {
+      let responseBody = body;
+      const isBinaryBody = typeof responseBody !== "string";
+
+      if (isBinaryBody) {
+        if (!headers.has("Content-Type")) {
           headers.set(
-            "Content-Length",
-            new Blob([responseBody]).size.toString()
+            "Content-Type",
+            responseBody.type ?? "application/octet-stream" // Blob may have a type
           );
         }
+      } else {
+        if (!headers.has("Content-Type")) {
+          headers.set("Content-Type", "text/html");
+        }
+        if (!headers.has("Content-Length")) {
+          headers.set("Content-Length", new Blob([responseBody]).size.toString());
+        }
       }
 
       if (streaming && typeof responseBody === "string") {
@@ -173,11 +110,11 @@ export const createRoute = (initOrMiddleware) => {
           },
         });
       }
+
       return new Response(
         status === 204 && !responseBody ? null : responseBody, // If status is 204, body must be null
         { headers, status, statusText }
       );
-      // return new Response(responseBody, { headers, status, statusText });
     };
   };
 };

package/create-router.mjs

@@ -11,7 +11,12 @@ export const createRouter = (initial = {}) => {
     ...init
   } = initial;
 
-  const router = async (request) => {
+  // `ctx` is an optional caller-supplied context object (e.g. `.mount()`
+  // uses it to pass `mountPrefix` down to a mounted sub-router) merged
+  // underneath the router's own `init` and the matched route's own params --
+  // so a route's own params can't be shadowed by a mount's ctx, but a
+  // handler can still read whatever the caller passed in.
+  const router = async (request, ctx = {}) => {
     try {
       for (const [matcher, handler] of routes) {
         const match = matcher(request);
@@ -20,10 +25,10 @@ export const createRouter = (initial = {}) => {
           // directly) is required so that a handler that throws inside an
           // async function (i.e. rejects its returned promise) is still
           // caught below and routed to errorHandler.
-          return await handler(request, { ...init, ...match });
+          return await handler(request, { ...ctx, ...init, ...match });
         }
       }
-      return await defaultHandler(request);
+      return await defaultHandler(request, ctx);
     } catch (error) {
       return errorHandler(error, request);
     }
@@ -57,5 +62,47 @@ export const createRouter = (initial = {}) => {
       return router;
     };
   };
+
+  // Delegate every request under `prefix` to `subHandler`, with the prefix
+  // stripped from the forwarded request's path -- e.g. `router.mount("/api",
+  // apiRouter)` sends a request for `/api/users` to `apiRouter` as `/users`.
+  // `subHandler` may be a plain `(Request) => Response` function or an
+  // object exposing one as `.fetch` (matching how `Router` itself works, so
+  // one router can mount another).
+  router.mount = (prefix, subHandler) => {
+    const normalizedPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+
+    const matcher = (request) => {
+      const url = new URL(request.url);
+      if (
+        url.pathname === normalizedPrefix ||
+        url.pathname.startsWith(normalizedPrefix + "/")
+      ) {
+        return { params: {}, method: request.method, headers: {} };
+      }
+      return null;
+    };
+
+    const handler = (request) => {
+      const url = new URL(request.url);
+      const newPath = url.pathname.slice(normalizedPrefix.length) || "/";
+      const newUrl = new URL(newPath + url.search + url.hash, url.origin);
+
+      const hasBody = request.method !== "GET" && request.method !== "HEAD";
+      const newRequest = new Request(newUrl.toString(), {
+        method: request.method,
+        headers: request.headers,
+        body: hasBody ? request.body : undefined,
+        duplex: hasBody ? "half" : undefined,
+      });
+
+      const sub = typeof subHandler === "function" ? subHandler : subHandler.fetch;
+      return sub(newRequest, { mountPrefix: normalizedPrefix });
+    };
+
+    routes.push([matcher, handler]);
+    return router;
+  };
+
   return router;
 };

package/index.mjs

@@ -2,6 +2,8 @@ export { createRequest } from "./create-request.mjs";
 export { createRouter } from "./create-router.mjs";
 export { createRoute } from "./create-route.mjs";
 export { createResponse } from "./create-response.mjs";
+export { tagRequest } from "./tag-request.mjs";
+export { tagResponse } from "./tag-response.mjs";
 export * from "./utility/index.mjs";
 export { deconstruct } from "./utility/deconstruct.mjs";
 export { cook } from "./utility/cook.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johnhenry/letterpress",
-  "version": "0.0.3",
+  "version": "0.2.0",
   "description": "A tagged-template-string HTTP routing library for defining and matching request handlers with plain JavaScript syntax.",
   "main": "index.mjs",
   "types": "types.d.ts",
@@ -13,6 +13,10 @@
       "types": "./fs.d.ts",
       "default": "./fs-router.mjs"
     },
+    "./rewrite": {
+      "types": "./rewrite.d.ts",
+      "default": "./rewrite.mjs"
+    },
     "./package.json": "./package.json",
     "./*": "./*"
   },
@@ -58,4 +62,4 @@
   "dependencies": {
     "theres-waldo": "^0.0.0"
   }
-}
+}