effect 4.0.0-beta.1 → 4.0.0-beta.11

package/src/unstable/http/HttpMethod.ts

@@ -14,6 +14,7 @@ export type HttpMethod =
   | "PATCH"
   | "HEAD"
   | "OPTIONS"
+  | "TRACE"
 
 /**
  * @since 4.0.0
@@ -24,7 +25,7 @@ export declare namespace HttpMethod {
    * @since 4.0.0
    * @category models
    */
-  export type NoBody = "GET" | "HEAD" | "OPTIONS"
+  export type NoBody = "GET" | "HEAD" | "OPTIONS" | "TRACE"
 
   /**
    * @since 4.0.0
@@ -36,12 +37,22 @@ export declare namespace HttpMethod {
 /**
  * @since 4.0.0
  */
-export const hasBody = (method: HttpMethod): boolean => method !== "GET" && method !== "HEAD" && method !== "OPTIONS"
+export const hasBody = (method: HttpMethod): method is HttpMethod.WithBody =>
+  method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE"
 
 /**
  * @since 4.0.0
  */
-export const all: ReadonlySet<HttpMethod> = new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+export const all: ReadonlySet<HttpMethod> = new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "HEAD",
+  "OPTIONS",
+  "TRACE"
+])
 
 /**
  * @since 4.0.0
@@ -53,7 +64,8 @@ export const allShort = [
   ["DELETE", "del"],
   ["PATCH", "patch"],
   ["HEAD", "head"],
-  ["OPTIONS", "options"]
+  ["OPTIONS", "options"],
+  ["TRACE", "trace"]
 ] as const
 
 /**

package/src/unstable/http/HttpMiddleware.ts

@@ -46,21 +46,16 @@ export declare namespace HttpMiddleware {
  */
 export const make = <M extends HttpMiddleware>(middleware: M): M => middleware
 
-/**
- * @since 4.0.0
- * @category Logger
- */
-export const LoggerDisabled = ServiceMap.Reference<boolean>("effect/http/HttpMiddleware/LoggerDisabled", {
-  defaultValue: constFalse
-})
+const loggerDisabledRequests = new WeakSet<HttpServerRequest>()
 
 /**
  * @since 4.0.0
  * @category Logger
  */
-export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | HttpServerRequest> =>
   Effect.withFiber((fiber) => {
-    fiber.setServices(ServiceMap.add(fiber.services, LoggerDisabled, true))
+    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+    loggerDisabledRequests.add(request)
     return self
   })
 
@@ -102,7 +97,7 @@ export const logger: <E, R>(
     const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
     return Effect.withLogSpan(
       Effect.flatMap(Effect.exit(httpApp), (exit) => {
-        if (fiber.getRef(LoggerDisabled)) {
+        if (loggerDisabledRequests.has(request)) {
           return exit
         } else if (exit._tag === "Failure") {
           const [response, cause] = causeResponseStripped(exit.cause)

package/src/unstable/http/HttpServerError.ts

@@ -4,6 +4,7 @@
 import * as Cause from "../../Cause.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
+import * as ErrorReporter from "../../ErrorReporter.ts"
 import type * as Exit from "../../Exit.ts"
 import { hasProperty } from "../../Predicate.ts"
 import type * as Request from "./HttpServerRequest.ts"
@@ -32,35 +33,24 @@ export class HttpServerError extends Data.TaggedError("HttpServerError")<{
     }
   }
 
-  /**
-   * @since 4.0.0
-   */
   readonly [TypeId] = TypeId
 
-  /**
-   * @since 4.0.0
-   */
   override stack = `${this.name}: ${this.message}`
 
-  /**
-   * @since 4.0.0
-   */
   get request(): Request.HttpServerRequest {
     return this.reason.request
   }
 
-  /**
-   * @since 4.0.0
-   */
   get response(): Response.HttpServerResponse | undefined {
     return "response" in this.reason ? this.reason.response : undefined
   }
 
-  /**
-   * @since 4.0.0
-   */
-  [Respondable.TypeId]() {
-    return this.reason[Respondable.TypeId]()
+  [Respondable.symbol]() {
+    return this.reason[Respondable.symbol]()
+  }
+
+  override get [ErrorReporter.ignore](): boolean {
+    return this.reason[ErrorReporter.ignore] ?? false
   }
 
   override get message(): string {
@@ -80,7 +70,7 @@ export class RequestParseError extends Data.TaggedError("RequestParseError")<{
   /**
    * @since 4.0.0
    */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 400 }))
   }
 
@@ -102,13 +92,12 @@ export class RouteNotFound extends Data.TaggedError("RouteNotFound")<{
   readonly description?: string
   readonly cause?: unknown
 }> implements Respondable.Respondable {
-  /**
-   * @since 4.0.0
-   */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 404 }))
   }
 
+  override readonly [ErrorReporter.ignore] = true
+
   get methodAndUrl() {
     return `${this.request.method} ${this.request.url}`
   }
@@ -130,7 +119,7 @@ export class InternalError extends Data.TaggedError("InternalError")<{
   /**
    * @since 4.0.0
    */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 500 }))
   }
 
@@ -159,10 +148,7 @@ export class ResponseError extends Data.TaggedError("ResponseError")<{
   readonly description?: string
   readonly cause?: unknown
 }> implements Respondable.Respondable {
-  /**
-   * @since 4.0.0
-   */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 500 }))
   }
 

package/src/unstable/http/HttpServerRespondable.ts

@@ -12,21 +12,21 @@ import * as Response from "./HttpServerResponse.ts"
  * @since 4.0.0
  * @category Type IDs
  */
-export const TypeId = "~effect/http/HttpServerRespondable"
+export const symbol = "~effect/http/HttpServerRespondable"
 
 /**
  * @since 4.0.0
  * @category models
  */
 export interface Respondable {
-  readonly [TypeId]: () => Effect.Effect<HttpServerResponse, unknown>
+  [symbol](): Effect.Effect<HttpServerResponse, unknown>
 }
 
 /**
  * @since 4.0.0
  * @category guards
  */
-export const isRespondable = (u: unknown): u is Respondable => hasProperty(u, TypeId)
+export const isRespondable = (u: unknown): u is Respondable => hasProperty(u, symbol)
 
 const badRequest = Response.empty({ status: 400 })
 const notFound = Response.empty({ status: 404 })
@@ -39,7 +39,7 @@ export const toResponse = (self: Respondable): Effect.Effect<HttpServerResponse>
   if (Response.isHttpServerResponse(self)) {
     return Effect.succeed(self)
   }
-  return Effect.orDie(self[TypeId]())
+  return Effect.orDie(self[symbol]())
 }
 
 /**
@@ -50,7 +50,7 @@ export const toResponseOrElse = (u: unknown, orElse: HttpServerResponse): Effect
   if (Response.isHttpServerResponse(u)) {
     return Effect.succeed(u)
   } else if (isRespondable(u)) {
-    return Effect.catchCause(u[TypeId](), () => Effect.succeed(orElse))
+    return Effect.catchCause(u[symbol](), () => Effect.succeed(orElse))
     // add support for some commmon types
   } else if (Schema.isSchemaError(u)) {
     return Effect.succeed(badRequest)
@@ -68,7 +68,7 @@ export const toResponseOrElseDefect = (u: unknown, orElse: HttpServerResponse):
   if (Response.isHttpServerResponse(u)) {
     return Effect.succeed(u)
   } else if (isRespondable(u)) {
-    return Effect.catchCause(u[TypeId](), () => Effect.succeed(orElse))
+    return Effect.catchCause(u[symbol](), () => Effect.succeed(orElse))
   }
   return Effect.succeed(orElse)
 }

package/src/unstable/http/HttpServerResponse.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import * as Effect from "../../Effect.ts"
+import * as ErrorReporter from "../../ErrorReporter.ts"
 import type * as FileSystem from "../../FileSystem.ts"
 import { dual } from "../../Function.ts"
 import type * as Inspectable from "../../Inspectable.ts"
@@ -28,7 +29,7 @@ const TypeId = "~effect/http/HttpServerResponse"
  * @since 4.0.0
  * @category models
  */
-export interface HttpServerResponse extends Inspectable.Inspectable, Pipeable {
+export interface HttpServerResponse extends Inspectable.Inspectable, Pipeable, ErrorReporter.Reportable {
   readonly [TypeId]: typeof TypeId
   readonly status: number
   readonly statusText?: string | undefined
@@ -327,7 +328,7 @@ export const formData = (
     statusText: options?.statusText,
     headers: options?.headers && Headers.fromInput(options.headers),
     cookies: options?.cookies,
-    body: Body.makeFormData(body)
+    body: Body.formData(body)
   })
 
 /**
@@ -834,6 +835,7 @@ const Proto: Omit<
 > = {
   ...PipeInspectableProto,
   [TypeId]: TypeId,
+  [ErrorReporter.ignore]: true,
   toJSON(this: HttpServerResponse) {
     return {
       _id: "HttpServerResponse",

package/src/unstable/http/Multipart.ts

@@ -203,13 +203,13 @@ export const PersistedFileSchema: PersistedFileSchema = Schema.declare(
  * @since 4.0.0
  * @category Schemas
  */
-export const FilesSchema: Schema.Array$<PersistedFileSchema> = Schema.Array(PersistedFileSchema)
+export const FilesSchema: Schema.$Array<PersistedFileSchema> = Schema.Array(PersistedFileSchema)
 
 /**
  * @since 4.0.0
  * @category Schemas
  */
-export const SingleFileSchema: Schema.decodeTo<PersistedFileSchema, Schema.Array$<PersistedFileSchema>> = FilesSchema
+export const SingleFileSchema: Schema.decodeTo<PersistedFileSchema, Schema.$Array<PersistedFileSchema>> = FilesSchema
   .check(
     Schema.isLengthBetween(1, 1)
   ).pipe(

package/src/unstable/http/UrlParams.ts

@@ -43,10 +43,14 @@ export const isUrlParams = (u: unknown): u is UrlParams => hasProperty(u, TypeId
  * @category models
  */
 export type Input =
-  | CoercibleRecord
+  | CoercibleRecordInput
   | Iterable<readonly [string, Coercible]>
   | URLSearchParams
 
+type CoercibleRecordInput = CoercibleRecord & {
+  readonly [Symbol.iterator]?: never
+}
+
 /**
  * @since 4.0.0
  * @category models
@@ -57,8 +61,17 @@ export type Coercible = string | number | bigint | boolean | null | undefined
  * @since 4.0.0
  * @category models
  */
-export interface CoercibleRecord {
-  readonly [key: string]: Coercible | ReadonlyArray<Coercible> | CoercibleRecord
+type CoercibleRecordField<A> = A extends Coercible ? A
+  : A extends ReadonlyArray<infer Item> ? ReadonlyArray<Item extends Coercible ? Item : never>
+  : A extends object ? CoercibleRecord<A>
+  : never
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export type CoercibleRecord<A extends object = any> = {
+  readonly [K in keyof A]: CoercibleRecordField<A[K]>
 }
 
 const Proto = {
@@ -110,7 +123,9 @@ export const fromInput = (input: Input): UrlParams => {
 }
 
 const fromInputNested = (input: Input): Array<[string | Array<string>, any]> => {
-  const entries = Symbol.iterator in input ? Arr.fromIterable(input) : Object.entries(input)
+  const entries = typeof (input as any)[Symbol.iterator] === "function"
+    ? Arr.fromIterable(input as Iterable<readonly [string, Coercible]>)
+    : Object.entries(input)
   const out: Array<[string | Array<string>, string]> = []
   for (const [key, value] of entries) {
     if (Array.isArray(value)) {
@@ -539,7 +554,7 @@ export const schemaJsonField = (field: string): schemaJsonField =>
  */
 export interface schemaRecord extends
   Schema.decodeTo<
-    Schema.Record$<Schema.String, Schema.Union<readonly [Schema.String, Schema.NonEmptyArray<Schema.String>]>>,
+    Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.NonEmptyArray<Schema.String>]>>,
     UrlParamsSchema,
     never,
     never

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -2,7 +2,7 @@
  * @since 4.0.0
  */
 import * as Effect from "../../Effect.ts"
-import * as Base64 from "../../encoding/Base64.ts"
+import * as Encoding from "../../Encoding.ts"
 import * as Fiber from "../../Fiber.ts"
 import type { FileSystem } from "../../FileSystem.ts"
 import { identity } from "../../Function.ts"
@@ -328,7 +328,7 @@ export const securityDecode = <Security extends HttpApiSecurity.HttpApiSecurity>
       } as any
       return HttpServerRequest.asEffect().pipe(
         Effect.flatMap((request) =>
-          Base64.decodeString((request.headers.authorization ?? "").slice(basicLen)).asEffect()
+          Encoding.decodeBase64String((request.headers.authorization ?? "").slice(basicLen)).asEffect()
         ),
         Effect.match({
           onFailure: () => empty,
@@ -505,9 +505,9 @@ function handlerToRoute(
   const endpoint = handler.endpoint
   const encodeSuccess = Schema.encodeUnknownEffect(makeSuccessSchema(endpoint))
   const encodeError = Schema.encodeUnknownEffect(makeErrorSchema(endpoint))
-  const decodeParams = UndefinedOr.map(HttpApiEndpoint.getParamsSchema(endpoint), Schema.decodeUnknownEffect)
-  const decodeHeaders = UndefinedOr.map(HttpApiEndpoint.getHeadersSchema(endpoint), Schema.decodeUnknownEffect)
-  const decodeQuery = UndefinedOr.map(HttpApiEndpoint.getQuerySchema(endpoint), Schema.decodeUnknownEffect)
+  const decodeParams = UndefinedOr.map(endpoint.params, Schema.decodeUnknownEffect)
+  const decodeHeaders = UndefinedOr.map(endpoint.headers, Schema.decodeUnknownEffect)
+  const decodeQuery = UndefinedOr.map(endpoint.query, Schema.decodeUnknownEffect)
 
   const shouldParsePayload = endpoint.payload.size > 0 && !handler.isRaw
   const payloadBy = shouldParsePayload ? buildPayloadDecoders(endpoint.payload) : undefined
@@ -549,6 +549,7 @@ function handlerToRoute(
       return Response.isHttpServerResponse(response) ? response : yield* encodeSuccess(response)
     })
   ).pipe(
+    Effect.withErrorReporting,
     Effect.catch((error) => {
       if (Schema.isSchemaError(error)) {
         error = HttpApiSchemaError.fromSchemaError(error)

package/src/unstable/httpapi/HttpApiClient.ts

@@ -217,7 +217,7 @@ const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>
         })
 
         // encoders
-        const encodeParams = UndefinedOr.map(HttpApiEndpoint.getParamsSchema(endpoint), Schema.encodeUnknownEffect)
+        const encodeParams = UndefinedOr.map(endpoint.params, Schema.encodeUnknownEffect)
 
         const payloadSchemas = HttpApiEndpoint.getPayloadSchemas(endpoint)
         const encodePayload = Arr.isArrayNonEmpty(payloadSchemas) ?
@@ -226,8 +226,8 @@ const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>
             : Schema.encodeUnknownEffect(Schema.Union(payloadSchemas)) :
           undefined
 
-        const encodeHeaders = UndefinedOr.map(HttpApiEndpoint.getHeadersSchema(endpoint), Schema.encodeUnknownEffect)
-        const encodeQuery = UndefinedOr.map(HttpApiEndpoint.getQuerySchema(endpoint), Schema.encodeUnknownEffect)
+        const encodeHeaders = UndefinedOr.map(endpoint.headers, Schema.encodeUnknownEffect)
+        const encodeQuery = UndefinedOr.map(endpoint.query, Schema.encodeUnknownEffect)
 
         const middlewareKeys = Array.from(onEndpointOptions.middleware, (tag) => `${tag.key}/Client`)
 

package/src/unstable/httpapi/HttpApiEndpoint.ts

@@ -4,7 +4,6 @@
 import * as Arr from "../../Array.ts"
 import type { Brand } from "../../Brand.ts"
 import type { Effect } from "../../Effect.ts"
-import { format } from "../../Formatter.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
@@ -71,9 +70,9 @@ export interface HttpApiEndpoint<
   readonly name: Name
   readonly path: Path
   readonly method: Method
-  readonly params: Schema.Struct.Fields | undefined
-  readonly query: Schema.Struct.Fields | undefined
-  readonly headers: Schema.Struct.Fields | undefined
+  readonly params: Schema.Top | undefined
+  readonly query: Schema.Top | undefined
+  readonly headers: Schema.Top | undefined
   readonly payload: PayloadMap
   readonly success: ReadonlySet<Schema.Top>
   readonly error: ReadonlySet<Schema.Top>
@@ -156,21 +155,6 @@ export interface HttpApiEndpoint<
   >
 }
 
-/** @internal */
-export function getParamsSchema(endpoint: AnyWithProps): Schema.Top | undefined {
-  return endpoint.params ? Schema.Struct(endpoint.params) : undefined
-}
-
-/** @internal */
-export function getQuerySchema(endpoint: AnyWithProps): Schema.Top | undefined {
-  return endpoint.query ? Schema.Struct(endpoint.query) : undefined
-}
-
-/** @internal */
-export function getHeadersSchema(endpoint: AnyWithProps): Schema.Top | undefined {
-  return endpoint.headers ? Schema.Struct(endpoint.headers) : undefined
-}
-
 /** @internal */
 export function getPayloadSchemas(endpoint: AnyWithProps): Array<Schema.Top> {
   const result: Array<Schema.Top> = []
@@ -830,9 +814,9 @@ function makeProto<
   readonly name: Name
   readonly path: Path
   readonly method: Method
-  readonly params: Schema.Struct.Fields | undefined
-  readonly query: Schema.Struct.Fields | undefined
-  readonly headers: Schema.Struct.Fields | undefined
+  readonly params: Schema.Top | undefined
+  readonly query: Schema.Top | undefined
+  readonly headers: Schema.Top | undefined
   readonly payload: PayloadMap
   readonly success: ReadonlySet<Schema.Top>
   readonly error: ReadonlySet<Schema.Top>
@@ -855,32 +839,28 @@ function makeProto<
 }
 
 /**
- * Params come from the router as `string` (optional params as `undefined`) and
- * must be encodable back into the URL path.
- *
- * We accept "struct fields" (`Record<string, Codec<...>>`) so we can both enforce
- * `Encoded` = `string | undefined` per field and reliably generate OpenAPI
- * `in: path` parameters by iterating object properties.
- *
  * @since 4.0.0
  * @category constraints
  */
-export type ParamsConstraint = Record<string, Schema.Encoder<string | undefined, unknown>>
+export type ParamsConstraint =
+  | Record<string, Schema.Encoder<string | undefined, unknown>>
+  | Schema.Encoder<Record<string, string | undefined>, unknown>
 
 /**
- * URL search params can be repeated, so fields may encode to `string` or
- * `ReadonlyArray<string>` (or be missing).
- *
- * Kept as "struct fields" so OpenAPI can safely expand properties into
- * `in: query` parameters.
- *
  * @since 4.0.0
  * @category constraints
  */
-export type QuerySchemaConstraint = Record<
-  string,
-  Schema.Encoder<string | ReadonlyArray<string> | undefined, unknown>
->
+export type HeadersConstraint =
+  | Record<string, Schema.Encoder<string | undefined, unknown>>
+  | Schema.Encoder<Record<string, string | undefined>, unknown>
+
+/**
+ * @since 4.0.0
+ * @category constraints
+ */
+export type QueryConstraint =
+  | Record<string, Schema.Encoder<string | ReadonlyArray<string> | undefined, unknown>>
+  | Schema.Encoder<Record<string, string | ReadonlyArray<string> | undefined>, unknown>
 
 /**
  * Payload schema depends on the HTTP method:
@@ -893,34 +873,23 @@ export type QuerySchemaConstraint = Record<
  * @since 4.0.0
  * @category constraints
  */
-export type PayloadSchemaConstraint<Method extends HttpMethod> = Method extends HttpMethod.NoBody ? Record<
+export type PayloadConstraint<Method extends HttpMethod> = Method extends HttpMethod.NoBody ? Record<
     string,
     Schema.Encoder<string | ReadonlyArray<string> | undefined, unknown>
   > :
-  SuccessSchemaConstraint
-
-/**
- * HTTP headers are string-valued (or missing).
- *
- * Kept as "struct fields" so OpenAPI can safely expand properties into
- * `in: header` parameters.
- *
- * @since 4.0.0
- * @category constraints
- */
-export type HeadersSchemaConstraint = Record<string, Schema.Encoder<string | undefined, unknown>>
+  SuccessConstraint
 
 /**
  * @since 4.0.0
  * @category constraints
  */
-export type SuccessSchemaConstraint = Schema.Top | ReadonlyArray<Schema.Top>
+export type SuccessConstraint = Schema.Top | ReadonlyArray<Schema.Top>
 
 /**
  * @since 4.0.0
  * @category constraints
  */
-export type ErrorSchemaConstraint = Schema.Top | ReadonlyArray<Schema.Top>
+export type ErrorConstraint = Schema.Top | ReadonlyArray<Schema.Top>
 
 /**
  * @since 4.0.0
@@ -931,11 +900,11 @@ export const make = <Method extends HttpMethod>(method: Method) =>
   const Name extends string,
   const Path extends HttpRouter.PathInput,
   Params extends ParamsConstraint = never,
-  Query extends QuerySchemaConstraint = never,
-  Payload extends PayloadSchemaConstraint<Method> = never,
-  Headers extends HeadersSchemaConstraint = never,
-  const Success extends SuccessSchemaConstraint = HttpApiSchema.NoContent,
-  const Error extends ErrorSchemaConstraint = never
+  Query extends QueryConstraint = never,
+  Payload extends PayloadConstraint<Method> = never,
+  Headers extends HeadersConstraint = never,
+  const Success extends SuccessConstraint = HttpApiSchema.NoContent,
+  const Error extends ErrorConstraint = never
 >(
   name: Name,
   path: Path,
@@ -964,8 +933,8 @@ export const make = <Method extends HttpMethod>(method: Method) =>
     name,
     path,
     method,
-    params: options?.params,
-    query: options?.query,
+    params: getParams(options?.params),
+    query: getQuery(options?.query),
     headers: getHeaders(options?.headers),
     payload: getPayload(options?.payload),
     success: getSuccess(options?.success),
@@ -975,17 +944,23 @@ export const make = <Method extends HttpMethod>(method: Method) =>
   })
 }
 
+function getParams(params: ParamsConstraint | undefined): Schema.Top | undefined {
+  if (params === undefined) return undefined
+  if (Schema.isSchema(params)) return params
+  return Schema.Struct(params)
+}
+
+function getQuery(query: QueryConstraint | undefined): Schema.Top | undefined {
+  if (query === undefined) return undefined
+  if (Schema.isSchema(query)) return query
+  return Schema.Struct(query)
+}
+
 // all keys should be lowercase
-function getHeaders(headers: Schema.Struct.Fields | undefined): Schema.Struct.Fields | undefined {
-  if (headers !== undefined) {
-    for (const key of Object.keys(headers)) {
-      const lowerKey = key.toLowerCase()
-      if (key !== lowerKey) {
-        throw new Error(`Header keys must be lowercase, got ${format(key)} (use ${format(lowerKey)})`)
-      }
-    }
-    return headers
-  }
+function getHeaders(headers: HeadersConstraint | undefined): Schema.Top | undefined {
+  if (headers === undefined) return undefined
+  if (Schema.isSchema(headers)) return headers
+  return Schema.Struct(headers)
 }
 
 function getPayload(