effect 4.0.4 → 4.0.5

package/src/http/Headers.ts

@@ -731,10 +731,11 @@ export const isRedactedName = (
   name: string,
   patterns: ReadonlyArray<string | RegExp>
 ): boolean => {
+  const lowerName = name.toLowerCase()
   for (let i = 0; i < patterns.length; i++) {
     const pattern = patterns[i]
     if (typeof pattern === "string") {
-      if (pattern.toLowerCase() === name.toLowerCase()) {
+      if (pattern.toLowerCase() === lowerName) {
         return true
       }
     } else if (name.search(pattern) !== -1) {
@@ -749,9 +750,9 @@ export const isRedactedName = (
  *
  * **Details**
  *
- * Defaults include `authorization`, `cookie`, `set-cookie`, `x-api-key` and
- * `AWSAccessKeyId`, `Signature`, `sig` and `X-Goog-Signature`. Names match
- * case-insensitively, and providing a new list replaces the defaults.
+ * Defaults include `authorization`, `cookie`, `set-cookie` and `x-api-key`.
+ * A custom list replaces the defaults. Matching uses `isRedactedName`.
+ * Use `UrlParams.CurrentRedactedNames` for query parameters.
  *
  * @stability unstable
  * @category services
@@ -764,10 +765,6 @@ export const CurrentRedactedNames = Context.Reference<
     "authorization",
     "cookie",
     "set-cookie",
-    "x-api-key",
-    "AWSAccessKeyId",
-    "Signature",
-    "sig",
-    "X-Goog-Signature"
+    "x-api-key"
   ]
 })

package/src/http/HttpClient.ts

@@ -47,6 +47,7 @@ import * as HttpMethod from "./HttpMethod.ts"
 import * as TraceContext from "./HttpTraceContext.ts"
 import * as tracing from "./internal/tracing.ts"
 import * as Url from "./Url.ts"
+import * as UrlParams from "./UrlParams.ts"
 
 const TypeId = "~effect/http/HttpClient"
 
@@ -905,7 +906,11 @@ export const make = (
           (span) => {
             span.attribute("http.request.method", request.method)
             const redactedHeaderNames = fiber.getRef(Headers.CurrentRedactedNames)
-            tracing.addUrlAttributes(span, url)
+            tracing.addUrlAttributes(
+              span,
+              url,
+              tracing.redactedNames(request.urlParams, fiber.getRef(UrlParams.CurrentRedactedNames))
+            )
             const headerFilter = fiber.getRef(TracerHeaderFilter)
             tracing.addHeaderAttributes(span, "request", request.headers, headerFilter, redactedHeaderNames)
             request = fiber.getRef(TracerPropagationEnabled)
@@ -2255,6 +2260,18 @@ export const TracerHeaderFilter = Context.Reference<
 /**
  * Context reference that controls whether outgoing client spans are propagated to request headers.
  *
+ * **Details**
+ *
+ * When this is `true`, the client writes the compact B3 `b3` header and the
+ * W3C `traceparent` header. The default is on. The client span is still
+ * created when this is `false`.
+ *
+ * **Gotchas**
+ *
+ * A browser preflight fails when the target does not list `b3` and
+ * `traceparent` in `Access-Control-Allow-Headers`. Set this to `false` for
+ * those requests.
+ *
  * @stability unstable
  * @category services
  * @since 4.0.0

package/src/http/HttpClientError.ts

@@ -15,6 +15,7 @@ import { hasProperty } from "../Predicate.ts"
 import * as Schema from "../Schema.ts"
 import type * as HttpClientRequest from "./HttpClientRequest.ts"
 import type * as ClientResponse from "./HttpClientResponse.ts"
+import * as UrlParams from "./UrlParams.ts"
 
 const TypeId = "~effect/http/HttpClientError"
 
@@ -88,6 +89,9 @@ const formatReason = (tag: string) => tag.endsWith("Error") ? tag.slice(0, -5) :
 const formatMessage = (reason: string, description: string | undefined, info: string) =>
   description ? `${reason}: ${description} (${info})` : `${reason} error (${info})`
 
+const formatMethodAndUrl = (request: HttpClientRequest.HttpClientRequest) =>
+  `${request.method} ${UrlParams.redactUrl(request.url)}`
+
 /**
  * Error describing transport-level failures that occur while sending an HTTP request.
  *
@@ -107,7 +111,7 @@ export class TransportError extends Data.TaggedError("TransportError")<{
    * @since 4.0.0
    */
   get methodAndUrl() {
-    return `${this.request.method} ${this.request.url}`
+    return formatMethodAndUrl(this.request)
   }
 
   /**
@@ -140,7 +144,7 @@ export class EncodeError extends Data.TaggedError("EncodeError")<{
    * @since 4.0.0
    */
   get methodAndUrl() {
-    return `${this.request.method} ${this.request.url}`
+    return formatMethodAndUrl(this.request)
   }
 
   /**
@@ -173,7 +177,7 @@ export class InvalidUrlError extends Data.TaggedError("InvalidUrlError")<{
    * @since 4.0.0
    */
   get methodAndUrl() {
-    return `${this.request.method} ${this.request.url}`
+    return formatMethodAndUrl(this.request)
   }
 
   /**
@@ -207,7 +211,7 @@ export class StatusCodeError extends Data.TaggedError("StatusCodeError")<{
    * @since 4.0.0
    */
   get methodAndUrl() {
-    return `${this.request.method} ${this.request.url}`
+    return formatMethodAndUrl(this.request)
   }
 
   /**
@@ -242,7 +246,7 @@ export class DecodeError extends Data.TaggedError("DecodeError")<{
    * @since 4.0.0
    */
   get methodAndUrl() {
-    return `${this.request.method} ${this.request.url}`
+    return formatMethodAndUrl(this.request)
   }
 
   /**
@@ -277,7 +281,7 @@ export class EmptyBodyError extends Data.TaggedError("EmptyBodyError")<{
    * @since 4.0.0
    */
   get methodAndUrl() {
-    return `${this.request.method} ${this.request.url}`
+    return formatMethodAndUrl(this.request)
   }
 
   /**

package/src/http/HttpClientRequest.ts

@@ -30,6 +30,7 @@ import * as Stream from "../Stream.ts"
 import * as Headers from "./Headers.ts"
 import * as HttpBody from "./HttpBody.ts"
 import { hasBody, type HttpMethod } from "./HttpMethod.ts"
+import * as compression from "./internal/compressionBody.ts"
 import * as bodyInternal from "./internal/httpBody.ts"
 import * as Url from "./Url.ts"
 import * as UrlParams from "./UrlParams.ts"
@@ -104,7 +105,7 @@ const Proto = {
     return {
       _id: "HttpClientRequest",
       method: this.method,
-      url: this.url,
+      url: UrlParams.redactUrl(this.url),
       urlParams: this.urlParams,
       hash: this.hash,
       headers: redact(this.headers),
@@ -755,6 +756,10 @@ export const updateUrl: {
 /**
  * Sets one query parameter, replacing existing values for that parameter name.
  *
+ * **Details**
+ *
+ * A `Redacted` value is sent unwrapped and stays redacted in inspection, errors and spans.
+ *
  * @stability unstable
  * @category combinators
  * @since 4.0.0
@@ -763,20 +768,28 @@ export const setUrlParam: {
   /**
    * Sets one query parameter, replacing existing values for that parameter name.
    *
+   * **Details**
+   *
+   * A `Redacted` value is sent unwrapped and stays redacted in inspection, errors and spans.
+   *
    * @stability unstable
    * @category combinators
    * @since 4.0.0
    */
-  (key: string, value: string): (self: HttpClientRequest) => HttpClientRequest
+  (key: string, value: string | Redacted.Redacted): (self: HttpClientRequest) => HttpClientRequest
   /**
    * Sets one query parameter, replacing existing values for that parameter name.
    *
+   * **Details**
+   *
+   * A `Redacted` value is sent unwrapped and stays redacted in inspection, errors and spans.
+   *
    * @stability unstable
    * @category combinators
    * @since 4.0.0
    */
-  (self: HttpClientRequest, key: string, value: string): HttpClientRequest
-} = dual(3, (self: HttpClientRequest, key: string, value: string): HttpClientRequest =>
+  (self: HttpClientRequest, key: string, value: string | Redacted.Redacted): HttpClientRequest
+} = dual(3, (self: HttpClientRequest, key: string, value: string | Redacted.Redacted): HttpClientRequest =>
   makeWith(
     self.method,
     self.url,
@@ -823,6 +836,10 @@ export const setUrlParams: {
 /**
  * Appends one query parameter value without removing existing values for the same name.
  *
+ * **Details**
+ *
+ * A `Redacted` value is sent unwrapped and stays redacted in inspection, errors and spans.
+ *
  * @stability unstable
  * @category combinators
  * @since 4.0.0
@@ -831,20 +848,28 @@ export const appendUrlParam: {
   /**
    * Appends one query parameter value without removing existing values for the same name.
    *
+   * **Details**
+   *
+   * A `Redacted` value is sent unwrapped and stays redacted in inspection, errors and spans.
+   *
    * @stability unstable
    * @category combinators
    * @since 4.0.0
    */
-  (key: string, value: string): (self: HttpClientRequest) => HttpClientRequest
+  (key: string, value: string | Redacted.Redacted): (self: HttpClientRequest) => HttpClientRequest
   /**
    * Appends one query parameter value without removing existing values for the same name.
    *
+   * **Details**
+   *
+   * A `Redacted` value is sent unwrapped and stays redacted in inspection, errors and spans.
+   *
    * @stability unstable
    * @category combinators
    * @since 4.0.0
    */
-  (self: HttpClientRequest, key: string, value: string): HttpClientRequest
-} = dual(3, (self: HttpClientRequest, key: string, value: string): HttpClientRequest =>
+  (self: HttpClientRequest, key: string, value: string | Redacted.Redacted): HttpClientRequest
+} = dual(3, (self: HttpClientRequest, key: string, value: string | Redacted.Redacted): HttpClientRequest =>
   makeWith(
     self.method,
     self.url,
@@ -974,6 +999,147 @@ export const setBody: {
   )
 })
 
+/**
+ * Algorithms supported by Web `CompressionStream` for request body compression.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export type CompressionAlgorithm = "gzip" | "deflate"
+
+/**
+ * Options for request body compression.
+ *
+ * @stability unstable
+ * @category options
+ * @since 4.0.0
+ */
+export interface CompressionOptions {
+  /**
+   * Minimum known body length in bytes to compress. Defaults to `1024`.
+   * Bodies with unknown length are always compressed.
+   */
+  readonly minSize?: number | undefined
+}
+
+/**
+ * Compresses a request body using Web `CompressionStream` and sets `Content-Encoding`.
+ *
+ * **Details**
+ *
+ * Byte-array bodies (including text, JSON, and URL-encoded bodies) are compressed
+ * into a new `Uint8Array` body, preserving the content type and updating
+ * `Content-Length`. The compressed body does not retain the original lazy text.
+ * Stream bodies are compressed lazily and have their content length removed.
+ * They still require a client runtime that supports streaming request bodies
+ * (Fetch requires `duplex: "half"`, which Safari and Firefox do not support).
+ *
+ * Returns the original request unchanged for empty, FormData, and raw bodies,
+ * bodies with a known length below `options.minSize`, or requests with any
+ * existing `Content-Encoding` header, including `identity`. Unknown-length
+ * streams are always compressed. The default minimum is 1024 bytes because
+ * gzip can make very small bodies larger.
+ *
+ * Requires `CompressionStream` (available in browsers, Node 18+, Bun, and Deno).
+ * There is no typed error channel: byte compression failures are defects;
+ * stream failures surface when the body is sent.
+ *
+ * To compress every request, use
+ * `HttpClient.mapRequestEffect(HttpClientRequest.compressBody("gzip"))`.
+ * `HttpClient.retryTransient` re-runs preprocessing, so this recompresses on
+ * every retry. For large bodies, compress once before calling `client.execute`.
+ *
+ * @stability unstable
+ * @category combinators
+ * @since 4.0.0
+ */
+export const compressBody: {
+  /**
+   * Compresses a request body using Web `CompressionStream` and sets `Content-Encoding`.
+   *
+   * **Details**
+   *
+   * Byte-array bodies (including text, JSON, and URL-encoded bodies) are compressed
+   * into a new `Uint8Array` body, preserving the content type and updating
+   * `Content-Length`. The compressed body does not retain the original lazy text.
+   * Stream bodies are compressed lazily and have their content length removed.
+   * They still require a client runtime that supports streaming request bodies
+   * (Fetch requires `duplex: "half"`, which Safari and Firefox do not support).
+   *
+   * Returns the original request unchanged for empty, FormData, and raw bodies,
+   * bodies with a known length below `options.minSize`, or requests with any
+   * existing `Content-Encoding` header, including `identity`. Unknown-length
+   * streams are always compressed. The default minimum is 1024 bytes because
+   * gzip can make very small bodies larger.
+   *
+   * Requires `CompressionStream` (available in browsers, Node 18+, Bun, and Deno).
+   * There is no typed error channel: byte compression failures are defects;
+   * stream failures surface when the body is sent.
+   *
+   * To compress every request, use
+   * `HttpClient.mapRequestEffect(HttpClientRequest.compressBody("gzip"))`.
+   * `HttpClient.retryTransient` re-runs preprocessing, so this recompresses on
+   * every retry. For large bodies, compress once before calling `client.execute`.
+   *
+   * @stability unstable
+   * @category combinators
+   * @since 4.0.0
+   */
+  (algorithm: CompressionAlgorithm, options?: CompressionOptions | undefined): (self: HttpClientRequest) => Effect.Effect<HttpClientRequest>
+  /**
+   * Compresses a request body using Web `CompressionStream` and sets `Content-Encoding`.
+   *
+   * **Details**
+   *
+   * Byte-array bodies (including text, JSON, and URL-encoded bodies) are compressed
+   * into a new `Uint8Array` body, preserving the content type and updating
+   * `Content-Length`. The compressed body does not retain the original lazy text.
+   * Stream bodies are compressed lazily and have their content length removed.
+   * They still require a client runtime that supports streaming request bodies
+   * (Fetch requires `duplex: "half"`, which Safari and Firefox do not support).
+   *
+   * Returns the original request unchanged for empty, FormData, and raw bodies,
+   * bodies with a known length below `options.minSize`, or requests with any
+   * existing `Content-Encoding` header, including `identity`. Unknown-length
+   * streams are always compressed. The default minimum is 1024 bytes because
+   * gzip can make very small bodies larger.
+   *
+   * Requires `CompressionStream` (available in browsers, Node 18+, Bun, and Deno).
+   * There is no typed error channel: byte compression failures are defects;
+   * stream failures surface when the body is sent.
+   *
+   * To compress every request, use
+   * `HttpClient.mapRequestEffect(HttpClientRequest.compressBody("gzip"))`.
+   * `HttpClient.retryTransient` re-runs preprocessing, so this recompresses on
+   * every retry. For large bodies, compress once before calling `client.execute`.
+   *
+   * @stability unstable
+   * @category combinators
+   * @since 4.0.0
+   */
+  (
+    self: HttpClientRequest,
+    algorithm: CompressionAlgorithm,
+    options?: CompressionOptions | undefined
+  ): Effect.Effect<HttpClientRequest>
+} = dual(
+  (args) => isHttpClientRequest(args[0]),
+  (
+    self: HttpClientRequest,
+    algorithm: CompressionAlgorithm,
+    options?: CompressionOptions | undefined
+  ): Effect.Effect<HttpClientRequest> => {
+    if (self.headers["content-encoding"] !== undefined) {
+      return Effect.succeed(self)
+    }
+    return Effect.map(
+      compression.compressBody(self.body, algorithm, options),
+      (body) => body === self.body ? self : setHeader(setBody(self, body), "content-encoding", algorithm)
+    )
+  }
+)
+
 /**
  * Sets a `Uint8Array` request body with an optional content type.
  *

package/src/http/HttpMiddleware.ts

@@ -11,6 +11,7 @@
  * @stability unstable
  * @since 4.0.0
  */
+import * as ByteSize from "../ByteSize.ts"
 import * as Cause from "../Cause.ts"
 import { Clock } from "../Clock.ts"
 import * as Context from "../Context.ts"
@@ -26,6 +27,7 @@ import type { Predicate } from "../Predicate.ts"
 import type { ReadonlyRecord } from "../Record.ts"
 import { nativeTracer, ParentSpan, Tracer } from "../Tracer.ts"
 import * as Headers from "./Headers.ts"
+import { hasBody } from "./HttpMethod.ts"
 import type { CompressionAlgorithm } from "./HttpPlatform.ts"
 import { HttpPlatform } from "./HttpPlatform.ts"
 import { causeResponseStripped, ClientAbort, HttpServerError, ResponseError } from "./HttpServerError.ts"
@@ -35,9 +37,11 @@ import * as Response from "./HttpServerResponse.ts"
 import type { HttpServerResponse } from "./HttpServerResponse.ts"
 import * as TraceContext from "./HttpTraceContext.ts"
 import * as compressionInternal from "./internal/compression.ts"
+import * as decompressionInternal from "./internal/decompression.ts"
 import * as bodyInternal from "./internal/httpBody.ts"
 import { appendPreResponseHandlerUnsafe } from "./internal/preResponseHandler.ts"
 import * as tracing from "./internal/tracing.ts"
+import * as UrlParams from "./UrlParams.ts"
 
 /**
  * Middleware that transforms an HTTP server app effect into another HTTP server app effect.
@@ -286,11 +290,7 @@ export const tracer: <E, R>(
         span.attribute("http.request.method", request.method)
         const url = Request.toURL(request)
         if (Option.isSome(url)) {
-          if (!request.url.startsWith("/") && (url.value.username !== "" || url.value.password !== "")) {
-            url.value.username = "REDACTED"
-            url.value.password = "REDACTED"
-          }
-          tracing.addUrlAttributes(span, url.value)
+          tracing.addUrlAttributes(span, url.value, fiber.getRef(UrlParams.CurrentRedactedNames))
         }
         if (request.headers["user-agent"] !== undefined) {
           span.attribute("user_agent.original", request.headers["user-agent"])
@@ -626,6 +626,86 @@ export const compression = (
     })
 }
 
+/**
+ * Middleware that decompresses request bodies sent with a `Content-Encoding`
+ * of `gzip` or `deflate`.
+ *
+ * **Details**
+ *
+ * The request service is replaced with a view whose body accessors (`stream`,
+ * `text`, `json`, `arrayBuffer`, `urlParamsBody`, `multipart`) yield the
+ * decompressed body, and whose headers no longer include `Content-Encoding`
+ * or `Content-Length`. Decompression is lazy and only happens when the body
+ * is read. Stacked codings such as `deflate, gzip` are undone in reverse
+ * order, and `identity` members are ignored.
+ *
+ * Requests whose `Content-Encoding` includes any other coding are rejected
+ * with `415 Unsupported Media Type` and `Accept-Encoding: gzip, deflate`,
+ * without running the app. Malformed compressed data fails the body read
+ * with a `RequestParseError`, or a `MultipartError` with reason `Parse` when
+ * reading multipart data.
+ *
+ * The decompressed size is limited to `maxDecompressedSize`, falling back to
+ * the `MaxBodySize` reference and then to 10 MiB. Exceeding it fails the body
+ * read with a `RequestParseError`, or a `MultipartError` with reason
+ * `BodyTooLarge` when reading multipart data. The limit applies to every body
+ * accessor, including `stream`.
+ *
+ * Decompression uses the global `DecompressionStream`. `deflate` means the
+ * zlib format (RFC 1950); raw deflate data is rejected.
+ *
+ * **Gotchas**
+ *
+ * `request.source` is still the original, compressed request.
+ * `HttpServerRequest.toWeb` returns that compressed request only when the
+ * source is a Web `Request`. On other platforms, such as Node, it builds a new
+ * `Request` from the decompressed body and the stripped headers.
+ *
+ * @stability unstable
+ * @category compression
+ * @since 4.0.0
+ */
+export const decompression = (
+  options?: {
+    /**
+     * Maximum number of decompressed body bytes. Defaults to the
+     * `MaxBodySize` reference, or 10 MiB when that is unset.
+     */
+    readonly maxDecompressedSize?: ByteSize.Input | undefined
+  } | undefined
+): <E, R>(
+  httpApp: Effect.Effect<HttpServerResponse, E, R>
+) => Effect.Effect<HttpServerResponse, E, R | HttpServerRequest> => {
+  const maxDecompressedSize = options?.maxDecompressedSize === undefined
+    ? undefined
+    : ByteSize.fromInputUnsafe(options.maxDecompressedSize)
+  return <E, R>(
+    httpApp: Effect.Effect<HttpServerResponse, E, R>
+  ): Effect.Effect<HttpServerResponse, E, R | HttpServerRequest> =>
+    Effect.withFiber((fiber) => {
+      const request = Context.getUnsafe(fiber.context, HttpServerRequest)
+      const contentEncoding = request.headers["content-encoding"]
+      if (contentEncoding === undefined || !hasBody(request.method)) {
+        return httpApp
+      }
+      const codings = decompressionInternal.parseContentEncoding(contentEncoding)
+      if (codings === undefined) {
+        return Effect.succeed(Response.empty({
+          status: 415,
+          headers: { "accept-encoding": "gzip, deflate" }
+        }))
+      }
+      if (codings.length === 0) {
+        return httpApp
+      }
+      return Effect.provideService(
+        httpApp,
+        HttpServerRequest,
+        new decompressionInternal.DecompressedRequest(request, codings, maxDecompressedSize)
+      )
+    })
+}
+
 const withVary = (response: HttpServerResponse): HttpServerResponse => {
   const vary = compressionInternal.varyWith(response.headers, "Accept-Encoding")
   return Response.setHeader(response, "vary", vary)

package/src/http/HttpRouter.ts

@@ -24,6 +24,7 @@ import * as Scope from "../Scope.ts"
 import * as Tracer from "../Tracer.ts"
 import type * as Types from "../Types.ts"
 import * as FindMyWay from "./FindMyWay.ts"
+import { getClosingParenthensePosition } from "./FindMyWay/internal/router.ts"
 import * as HttpEffect from "./HttpEffect.ts"
 import * as HttpIncomingMessage from "./HttpIncomingMessage.ts"
 import type * as HttpMethod from "./HttpMethod.ts"
@@ -123,7 +124,12 @@ export const HttpRouter: Context.Service<HttpRouter, HttpRouter> = Context.Servi
  * @since 4.0.0
  */
 export const make = Effect.gen(function*() {
-  const router = FindMyWay.make<Route<any, never>>(yield* RouterConfig)
+  const config = yield* RouterConfig
+  const ignoreDuplicateSlashes = config.ignoreDuplicateSlashes ?? true
+  const router = FindMyWay.make<{
+    readonly route: Route<any, never>
+    readonly prefixSegments: number | undefined
+  }>(config)
   const middleware = new Set<middleware.Fn>()
 
   const addAll = <const Routes extends ReadonlyArray<Route<any, any>>>(
@@ -147,19 +153,25 @@ export const make = Effect.gen(function*() {
           ...routes[i],
           handler: applyMiddleware(routes[i].handler as Effect.Effect<HttpServerResponse.HttpServerResponse>)
         })
+        const handler = {
+          route: route as Route<any, never>,
+          prefixSegments: Option.isSome(route.prefix)
+            ? countSegments(route.prefix.value, ignoreDuplicateSlashes)
+            : undefined
+        }
         if (route.method === "*") {
           if (route.path.endsWith("/*")) {
-            router.all(route.path, route as any)
-            router.all(route.path.slice(0, -2) as any, route as any)
+            router.all(route.path, handler)
+            router.all(route.path.slice(0, -2) as any, handler)
           } else {
-            router.all(route.path, route as any)
+            router.all(route.path, handler)
           }
         } else {
           if (route.path.endsWith("/*")) {
-            router.on(route.method, route.path, route as any)
-            router.on(route.method, route.path.slice(0, -2) as any, route as any)
+            router.on(route.method, route.path, handler)
+            router.on(route.method, route.path.slice(0, -2) as any, handler)
           } else {
-            router.on(route.method, route.path, route as any)
+            router.on(route.method, route.path, handler)
           }
         }
       }
@@ -211,12 +223,12 @@ export const make = Effect.gen(function*() {
             })
           )
         }
-        const route = result.handler
-        if (Option.isSome(route.prefix)) {
+        const { route, prefixSegments } = result.handler
+        if (prefixSegments !== undefined) {
           context = Context.add(
             context,
             HttpServerRequest.HttpServerRequest,
-            sliceRequestUrl(request, route.prefix.value)
+            sliceRequestUrl(request, prefixSegments, ignoreDuplicateSlashes)
           )
         }
         context = Context.add(context, HttpServerRequest.ParsedSearchParams, result.searchParams)
@@ -251,9 +263,44 @@ export const make = Effect.gen(function*() {
   })
 })
 
-function sliceRequestUrl(request: HttpServerRequest.HttpServerRequest, prefix: string) {
-  const prefexLen = prefix.length
-  return request.modify({ url: request.url.length <= prefexLen ? "/" : request.url.slice(prefexLen) })
+function sliceRequestUrl(
+  request: HttpServerRequest.HttpServerRequest,
+  prefixSegments: number,
+  ignoreDuplicateSlashes: boolean
+) {
+  const url = request.url
+  let index = 0
+  for (let segments = prefixSegments; segments > 0; segments--) {
+    if (ignoreDuplicateSlashes) {
+      while (url[index] === "/") index++
+    } else if (url[index] === "/") {
+      index++
+    }
+    while (index < url.length && !"/?;#".includes(url[index])) index++
+  }
+  return request.modify({ url: index < url.length ? url.slice(index) : "/" })
+}
+
+function countSegments(prefix: string, ignoreDuplicateSlashes: boolean) {
+  let count = 0
+  let inParamName = false
+  for (let i = 0; i < prefix.length; i++) {
+    const char = prefix[i]
+    if (char === "/") {
+      if (!ignoreDuplicateSlashes || prefix[i - 1] !== "/") count++
+      inParamName = false
+    } else if (char === ":") {
+      if (prefix[i + 1] === ":") i++
+      else inParamName = true
+    } else if (char === "-" || char === ".") {
+      inParamName = false
+    } else if (char === "(" && inParamName) {
+      // Slashes inside parameter regexes are not segment boundaries.
+      i = getClosingParenthensePosition(prefix, i)
+      inParamName = false
+    }
+  }
+  return count
 }
 
 /**