effect 4.0.0-beta.6 → 4.0.0-beta.60

package/src/unstable/httpapi/HttpApiSchema.ts

@@ -31,6 +31,7 @@ import { constVoid, type LazyArg } from "../../Function.ts"
 import * as Schema from "../../Schema.ts"
 import * as AST from "../../SchemaAST.ts"
 import * as Transformation from "../../SchemaTransformation.ts"
+import { hasBody, type HttpMethod } from "../http/HttpMethod.ts"
 import type * as Multipart_ from "../http/Multipart.ts"
 
 declare module "../../Schema.ts" {
@@ -77,17 +78,96 @@ export type ResponseEncoding = {
   readonly contentType: string
 }
 
+const statusCodeByLiteral = {
+  Continue: 100,
+  SwitchingProtocols: 101,
+  Processing: 102,
+  EarlyHints: 103,
+  OK: 200,
+  Ok: 200,
+  Created: 201,
+  Accepted: 202,
+  NonAuthoritativeInformation: 203,
+  NoContent: 204,
+  ResetContent: 205,
+  PartialContent: 206,
+  MultiStatus: 207,
+  AlreadyReported: 208,
+  ImUsed: 226,
+  MultipleChoices: 300,
+  MovedPermanently: 301,
+  Found: 302,
+  SeeOther: 303,
+  NotModified: 304,
+  TemporaryRedirect: 307,
+  PermanentRedirect: 308,
+  BadRequest: 400,
+  Unauthorized: 401,
+  PaymentRequired: 402,
+  Forbidden: 403,
+  NotFound: 404,
+  MethodNotAllowed: 405,
+  NotAcceptable: 406,
+  ProxyAuthenticationRequired: 407,
+  RequestTimeout: 408,
+  Conflict: 409,
+  Gone: 410,
+  LengthRequired: 411,
+  PreconditionFailed: 412,
+  PayloadTooLarge: 413,
+  UriTooLong: 414,
+  UnsupportedMediaType: 415,
+  RangeNotSatisfiable: 416,
+  ExpectationFailed: 417,
+  ImATeapot: 418,
+  MisdirectedRequest: 421,
+  UnprocessableEntity: 422,
+  Locked: 423,
+  FailedDependency: 424,
+  TooEarly: 425,
+  UpgradeRequired: 426,
+  PreconditionRequired: 428,
+  TooManyRequests: 429,
+  RequestHeaderFieldsTooLarge: 431,
+  UnavailableForLegalReasons: 451,
+  InternalServerError: 500,
+  NotImplemented: 501,
+  BadGateway: 502,
+  ServiceUnavailable: 503,
+  GatewayTimeout: 504,
+  HttpVersionNotSupported: 505,
+  VariantAlsoNegotiates: 506,
+  InsufficientStorage: 507,
+  LoopDetected: 508,
+  NotExtended: 510,
+  NetworkAuthenticationRequired: 511
+} as const
+
+/**
+ * Common HTTP status code literals accepted by {@link status}.
+ *
+ * @category status
+ * @since 4.0.0
+ */
+export type StatusLiteral = keyof typeof statusCodeByLiteral
+
 /**
  * A convenience function to set the HTTP status code of a schema.
  *
  * This is equivalent to calling `.annotate({ httpApiStatus: code })` on the schema.
  *
+ * You can pass either a numeric status code (for example, `201`) or a common
+ * literal name (for example, `"Created"`).
+ *
  * @category status
  * @since 4.0.0
  */
-export function status(code: number) {
-  return <S extends Schema.Top>(self: S): S["~rebuild.out"] => {
-    return self.annotate({ httpApiStatus: code })
+export function status(code: number): <S extends Schema.Top>(self: S) => S["Rebuild"]
+export function status(code: StatusLiteral): <S extends Schema.Top>(self: S) => S["Rebuild"]
+export function status(code: number | StatusLiteral) {
+  const statusCode = typeof code === "string" ? statusCodeByLiteral[code] : code
+  return <S extends Schema.Top>(self: S): S["Rebuild"] => {
+    return self.annotate({ httpApiStatus: statusCode })
   }
 }
 
@@ -189,7 +269,7 @@ export type MultipartTypeId = typeof MultipartTypeId
 /**
  * @since 4.0.0
  */
-export interface asMultipart<S extends Schema.Top> extends Schema.brand<S["~rebuild.out"], MultipartTypeId> {}
+export interface asMultipart<S extends Schema.Top> extends Schema.brand<S["Rebuild"], MultipartTypeId> {}
 
 /**
  * Marks a schema as a multipart payload.
@@ -224,9 +304,7 @@ export type MultipartStreamTypeId = typeof MultipartStreamTypeId
 /**
  * @since 4.0.0
  */
-export interface asMultipartStream<S extends Schema.Top>
-  extends Schema.brand<S["~rebuild.out"], MultipartStreamTypeId>
-{}
+export interface asMultipartStream<S extends Schema.Top> extends Schema.brand<S["Rebuild"], MultipartStreamTypeId> {}
 
 /**
  * Marks a schema as a multipart stream payload.
@@ -251,7 +329,7 @@ export function asMultipartStream(options?: Multipart_.withLimits.Options) {
 function asNonMultipartEncoding<S extends Schema.Top>(self: S, options: {
   readonly _tag: "Json" | "FormUrlEncoded" | "Uint8Array" | "Text"
   readonly contentType?: string | undefined
-}): S["~rebuild.out"] {
+}): S["Rebuild"] {
   return self.annotate({
     "~httpApiEncoding": {
       _tag: options._tag,
@@ -298,7 +376,7 @@ export function asJson(options?: {
 export function asFormUrlEncoded(options?: {
   readonly contentType?: string
 }) {
-  return <S extends Schema.Top & { readonly Encoded: Record<string, string | ReadonlyArray<string> | undefined> }>(
+  return <S extends Schema.Top>(
     self: S
   ) => asNonMultipartEncoding(self, { _tag: "FormUrlEncoded", ...options })
 }
@@ -332,6 +410,17 @@ export function asUint8Array(options?: {
   return <S extends Schema.Top & { readonly Encoded: Uint8Array }>(self: S) =>
     asNonMultipartEncoding(self, { _tag: "Uint8Array", ...options })
 }
+/**
+ * @since 4.0.0
+ */
+export const isNoContent = (ast: AST.AST): boolean => {
+  if (AST.isVoid(ast)) return true
+  const encoded = AST.toEncoded(ast)
+  if (AST.isVoid(encoded)) return true
+  const target = ast.encoding?.[0].to
+  if (target === undefined) return false
+  return AST.isVoid(target)
+}
 
 const resolveHttpApiEncoding = AST.resolveAt<Encoding>("~httpApiEncoding")
 
@@ -341,14 +430,20 @@ const defaultJsonEncoding: Encoding = {
   _tag: "Json",
   contentType: "application/json"
 }
+const defaultUrlEncodedEncoding: Encoding = {
+  _tag: "FormUrlEncoded",
+  contentType: "application/x-www-form-urlencoded"
+}
 
 function getEncoding(ast: AST.AST): Encoding {
   return resolveHttpApiEncoding(ast) ?? defaultJsonEncoding
 }
 
 /** @internal */
-export function getPayloadEncoding(ast: AST.AST): PayloadEncoding {
-  return getEncoding(ast)
+export function getPayloadEncoding(ast: AST.AST, method: HttpMethod): PayloadEncoding {
+  const encoding = resolveHttpApiEncoding(ast)
+  if (encoding) return encoding
+  return hasBody(method) ? defaultJsonEncoding : defaultUrlEncodedEncoding
 }
 
 /** @internal */

package/src/unstable/httpapi/HttpApiSecurity.ts

@@ -1,10 +1,10 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import { dual } from "../../Function.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import type { Redacted } from "../../Redacted.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { Covariant } from "../../Types.ts"
 
 const TypeId = "~effect/httpapi/HttpApiSecurity"
@@ -28,7 +28,7 @@ export declare namespace HttpApiSecurity {
     readonly [TypeId]: {
       readonly _A: Covariant<A>
     }
-    readonly annotations: ServiceMap.ServiceMap<never>
+    readonly annotations: Context.Context<never>
   }
 
   /**
@@ -91,7 +91,7 @@ const Proto = {
  */
 export const bearer: Bearer = Object.assign(Object.create(Proto), {
   _tag: "Bearer",
-  annotations: ServiceMap.empty()
+  annotations: Context.empty()
 })
 
 /**
@@ -116,7 +116,7 @@ export const apiKey = (options: {
     _tag: "ApiKey",
     key: options.key,
     in: options.in ?? "header",
-    annotations: ServiceMap.empty()
+    annotations: Context.empty()
   })
 
 /**
@@ -125,7 +125,7 @@ export const apiKey = (options: {
  */
 export const basic: Basic = Object.assign(Object.create(Proto), {
   _tag: "Basic",
-  annotations: ServiceMap.empty()
+  annotations: Context.empty()
 })
 
 /**
@@ -137,18 +137,18 @@ export const annotateMerge: {
    * @since 4.0.0
    * @category annotations
    */
-  <I>(annotations: ServiceMap.ServiceMap<I>): <A extends HttpApiSecurity>(self: A) => A
+  <I>(annotations: Context.Context<I>): <A extends HttpApiSecurity>(self: A) => A
   /**
    * @since 4.0.0
    * @category annotations
    */
-  <A extends HttpApiSecurity, I>(self: A, annotations: ServiceMap.ServiceMap<I>): A
+  <A extends HttpApiSecurity, I>(self: A, annotations: Context.Context<I>): A
 } = dual(
   2,
-  <A extends HttpApiSecurity, I>(self: A, annotations: ServiceMap.ServiceMap<I>): A =>
+  <A extends HttpApiSecurity, I>(self: A, annotations: Context.Context<I>): A =>
     Object.assign(Object.create(Proto), {
       ...self,
-      annotations: ServiceMap.merge(self.annotations, annotations)
+      annotations: Context.merge(self.annotations, annotations)
     })
 )
 
@@ -161,17 +161,17 @@ export const annotate: {
    * @since 4.0.0
    * @category annotations
    */
-  <I, S>(service: ServiceMap.Service<I, S>, value: S): <A extends HttpApiSecurity>(self: A) => A
+  <I, S>(service: Context.Key<I, S>, value: S): <A extends HttpApiSecurity>(self: A) => A
   /**
    * @since 4.0.0
    * @category annotations
    */
-  <A extends HttpApiSecurity, I, S>(self: A, service: ServiceMap.Service<I, S>, value: S): A
+  <A extends HttpApiSecurity, I, S>(self: A, service: Context.Key<I, S>, value: S): A
 } = dual(
   3,
-  <A extends HttpApiSecurity, I, S>(self: A, service: ServiceMap.Service<I, S>, value: S): A =>
+  <A extends HttpApiSecurity, I, S>(self: A, service: Context.Key<I, S>, value: S): A =>
     Object.assign(Object.create(Proto), {
       ...self,
-      annotations: ServiceMap.add(self.annotations, service, value)
+      annotations: Context.add(self.annotations, service, value)
     })
 )

package/src/unstable/httpapi/OpenApi.ts

@@ -3,6 +3,7 @@
  */
 import * as Arr from "../../Array.ts"
 import type { NonEmptyArray } from "../../Array.ts"
+import * as Context from "../../Context.ts"
 import { constFalse } from "../../Function.ts"
 import * as JsonPatch from "../../JsonPatch.ts"
 import { escapeToken } from "../../JsonPointer.ts"
@@ -11,7 +12,6 @@ import * as Option from "../../Option.ts"
 import * as Schema from "../../Schema.ts"
 import * as AST from "../../SchemaAST.ts"
 import * as SchemaRepresentation from "../../SchemaRepresentation.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as HttpMethod from "../http/HttpMethod.ts"
 import * as HttpApi from "./HttpApi.ts"
 import * as HttpApiEndpoint from "./HttpApiEndpoint.ts"
@@ -24,38 +24,38 @@ import type { HttpApiSecurity } from "./HttpApiSecurity.ts"
  * @since 4.0.0
  * @category annotations
  */
-export class Identifier extends ServiceMap.Service<Identifier, string>()("effect/httpapi/OpenApi/Identifier") {}
+export class Identifier extends Context.Service<Identifier, string>()("effect/httpapi/OpenApi/Identifier") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class Title extends ServiceMap.Service<Title, string>()("effect/httpapi/OpenApi/Title") {}
+export class Title extends Context.Service<Title, string>()("effect/httpapi/OpenApi/Title") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class Version extends ServiceMap.Service<Version, string>()("effect/httpapi/OpenApi/Version") {}
+export class Version extends Context.Service<Version, string>()("effect/httpapi/OpenApi/Version") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class Description extends ServiceMap.Service<Description, string>()("effect/httpapi/OpenApi/Description") {}
+export class Description extends Context.Service<Description, string>()("effect/httpapi/OpenApi/Description") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class License extends ServiceMap.Service<License, OpenAPISpecLicense>()("effect/httpapi/OpenApi/License") {}
+export class License extends Context.Service<License, OpenAPISpecLicense>()("effect/httpapi/OpenApi/License") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
 export class ExternalDocs
-  extends ServiceMap.Service<ExternalDocs, OpenAPISpecExternalDocs>()("effect/httpapi/OpenApi/ExternalDocs")
+  extends Context.Service<ExternalDocs, OpenAPISpecExternalDocs>()("effect/httpapi/OpenApi/ExternalDocs")
 {}
 
 /**
@@ -63,40 +63,38 @@ export class ExternalDocs
  * @category annotations
  */
 export class Servers
-  extends ServiceMap.Service<Servers, ReadonlyArray<OpenAPISpecServer>>()("effect/httpapi/OpenApi/Servers")
+  extends Context.Service<Servers, ReadonlyArray<OpenAPISpecServer>>()("effect/httpapi/OpenApi/Servers")
 {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class Format extends ServiceMap.Service<Format, string>()("effect/httpapi/OpenApi/Format") {}
+export class Format extends Context.Service<Format, string>()("effect/httpapi/OpenApi/Format") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class Summary extends ServiceMap.Service<Summary, string>()("effect/httpapi/OpenApi/Summary") {}
+export class Summary extends Context.Service<Summary, string>()("effect/httpapi/OpenApi/Summary") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class Deprecated extends ServiceMap.Service<Deprecated, boolean>()("effect/httpapi/OpenApi/Deprecated") {}
+export class Deprecated extends Context.Service<Deprecated, boolean>()("effect/httpapi/OpenApi/Deprecated") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class Override
-  extends ServiceMap.Service<Override, Record<string, unknown>>()("effect/httpapi/OpenApi/Override")
-{}
+export class Override extends Context.Service<Override, Record<string, unknown>>()("effect/httpapi/OpenApi/Override") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export const Exclude = ServiceMap.Reference<boolean>("effect/httpapi/OpenApi/Exclude", {
+export const Exclude = Context.Reference<boolean>("effect/httpapi/OpenApi/Exclude", {
   defaultValue: constFalse
 })
 
@@ -106,24 +104,24 @@ export const Exclude = ServiceMap.Reference<boolean>("effect/httpapi/OpenApi/Exc
  * @since 4.0.0
  * @category annotations
  */
-export class Transform extends ServiceMap.Service<
+export class Transform extends Context.Service<
   Transform,
   (openApiSpec: Record<string, any>) => Record<string, any>
 >()("effect/httpapi/OpenApi/Transform") {}
 
-const servicesPartial = <Tags extends Record<string, ServiceMap.Service<any, any> | ServiceMap.Service<never, any>>>(
+const servicesPartial = <Tags extends Record<string, Context.Key<any, any> | Context.Key<never, any>>>(
   tags: Tags
 ): (
   options: {
-    readonly [K in keyof Tags]?: ServiceMap.Service.Shape<Tags[K]> | undefined
+    readonly [K in keyof Tags]?: Context.Service.Shape<Tags[K]> | undefined
   }
-) => ServiceMap.ServiceMap<never> => {
+) => Context.Context<never> => {
   const entries = Object.entries(tags)
   return (options) => {
-    let context = ServiceMap.empty()
+    let context = Context.empty()
     for (const [key, tag] of entries) {
       if (options[key] !== undefined) {
-        context = ServiceMap.add(context, tag as any, options[key]!)
+        context = Context.add(context, tag as any, options[key]!)
       }
     }
     return context
@@ -150,7 +148,7 @@ export const annotations: (
     readonly exclude?: boolean | undefined
     readonly transform?: ((openApiSpec: Record<string, any>) => Record<string, any>) | undefined
   }
-) => ServiceMap.ServiceMap<never> = servicesPartial({
+) => Context.Context<never> = servicesPartial({
   identifier: Identifier,
   title: Title,
   version: Version,
@@ -174,11 +172,11 @@ const apiCache = new WeakMap<HttpApi.Any, OpenAPISpec>()
  * callback function to it. If the tag is not found, the function does nothing.
  */
 function processAnnotation<Services, S, I>(
-  ctx: ServiceMap.ServiceMap<Services>,
-  annotation: ServiceMap.Service<I, S>,
+  ctx: Context.Context<Services>,
+  annotation: Context.Key<I, S>,
   f: (s: S) => void
 ) {
-  const o = ServiceMap.getOption(ctx, annotation)
+  const o = Context.getOption(ctx, annotation)
   if (Option.isSome(o)) {
     f(o.value)
   }
@@ -201,21 +199,11 @@ function processAnnotation<Services, S, I>(
  * and overrides. Cached results are used for better performance when the same
  * `HttpApi` instance is processed multiple times.
  *
- * **Options**
- *
- * - `additionalProperties`: Controls how additional properties are handled while resolving the JSON schema. Possible values include:
- *   - `false`: Disallow additional properties (default)
- *   - `true`: Allow additional properties
- *   - `JsonSchema`: Use the provided JSON Schema for additional properties
- *
  * @category constructors
  * @since 4.0.0
  */
 export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
-  api: HttpApi.HttpApi<Id, Groups>,
-  options?: {
-    readonly additionalProperties?: boolean | JsonSchema.JsonSchema | undefined
-  } | undefined
+  api: HttpApi.HttpApi<Id, Groups>
 ): OpenAPISpec {
   const cached = apiCache.get(api)
   if (cached !== undefined) {
@@ -269,11 +257,11 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
 
   HttpApi.reflect(api, {
     onGroup({ group }) {
-      if (ServiceMap.get(group.annotations, Exclude)) {
+      if (Context.get(group.annotations, Exclude)) {
         return
       }
       let tag: OpenAPISpecTag = {
-        name: ServiceMap.getOrElse(group.annotations, Title, () => group.identifier)
+        name: Context.getOrElse(group.annotations, Title, () => group.identifier)
       }
       processAnnotation(group.annotations, Description, (description) => {
         tag.description = description
@@ -291,12 +279,12 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
       spec.tags.push(tag)
     },
     onEndpoint({ endpoint, group, mergedAnnotations, middleware }) {
-      if (ServiceMap.get(mergedAnnotations, Exclude)) {
+      if (Context.get(mergedAnnotations, Exclude)) {
         return
       }
       let op: OpenAPISpecOperation = {
-        tags: [ServiceMap.getOrElse(group.annotations, Title, () => group.identifier)],
-        operationId: ServiceMap.getOrElse(
+        tags: [Context.getOrElse(group.annotations, Title, () => group.identifier)],
+        operationId: Context.getOrElse(
           endpoint.annotations,
           Identifier,
           () => group.topLevel ? endpoint.name : `${group.identifier}.${endpoint.name}`
@@ -314,7 +302,7 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
           const c: OpenApiSpecContent = {}
           let hasContent = false
           payloadMap.forEach(({ encoding, schemas }, contentType) => {
-            const filtered = schemas.filter((s) => !isNoContent(s.ast))
+            const filtered = schemas.filter((s) => !HttpApiSchema.isNoContent(s.ast))
             if (filtered.length === 0) return
             hasContent = true
             const asts = filtered.map(AST.getAST)
@@ -351,10 +339,9 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
                   ast: toEncodingAST(ast, encoding),
                   path: ["paths", path, method, "responses", String(status), "content", contentType, "schema"]
                 })
-                op.responses[status].content = {
-                  [contentType]: {
-                    schema: {}
-                  }
+                op.responses[status].content ??= {}
+                op.responses[status].content[contentType] = {
+                  schema: {}
                 }
               })
             })
@@ -362,20 +349,23 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
         }
       }
 
-      function processParameters(fields: Schema.Struct.Fields | undefined, i: OpenAPISpecParameter["in"]) {
-        if (fields) {
-          for (const [name, field] of Object.entries(fields)) {
-            op.parameters.push({
-              name: String(name),
-              in: i,
-              schema: {},
-              required: i === "path" || !AST.isOptional(field.ast)
-            })
-            pathOps.push({
-              _tag: "parameter",
-              ast: AST.toEncoded(field.ast),
-              path: ["paths", path, method, "parameters", String(op.parameters.length - 1), "schema"]
-            })
+      function processParameters(schema: Schema.Top | undefined, i: OpenAPISpecParameter["in"]) {
+        if (schema) {
+          const ast = AST.getLastEncoding(schema.ast)
+          if (AST.isObjects(ast)) {
+            for (const ps of ast.propertySignatures) {
+              op.parameters.push({
+                name: String(ps.name),
+                in: i,
+                schema: {},
+                required: i === "path" || !AST.isOptional(ps.type)
+              })
+              pathOps.push({
+                _tag: "parameter",
+                ast: ps.type,
+                path: ["paths", path, method, "parameters", String(op.parameters.length - 1), "schema"]
+              })
+            }
           }
         }
       }
@@ -421,8 +411,7 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
       processParameters(endpoint.params, "path")
       if (!hasBody && endpoint.payload.size === 1) {
         const entry = endpoint.payload.values().next().value!
-        const schema = entry.schemas[0] as Schema.Struct<Schema.Struct.Fields>
-        processParameters(schema.fields, "query")
+        processParameters(entry.schemas[0], "query")
       }
       processParameters(endpoint.headers, "header")
       processParameters(endpoint.query, "query")
@@ -485,9 +474,7 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
       Arr.map(pathOps, (op) => op.ast)
     )
     const jsonSchemaMultiDocument = JsonSchema.toMultiDocumentOpenApi3_1(
-      SchemaRepresentation.toJsonSchemaMultiDocument(multiDocument, {
-        additionalProperties: options?.additionalProperties
-      })
+      SchemaRepresentation.toJsonSchemaMultiDocument(multiDocument)
     )
     const patchOps: Array<JsonPatch.JsonPatchOperation> = pathOps.map((op, i) => {
       const oppath = escapePath(op.path)
@@ -528,10 +515,6 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
   return spec
 }
 
-function isNoContent(ast: AST.AST): boolean {
-  return AST.isVoid(AST.toEncoded(ast))
-}
-
 type ResponseBodies = Map<
   number, // status
   {
@@ -541,7 +524,7 @@ type ResponseBodies = Map<
 >
 
 function extractResponseBodies(
-  schemas: readonly [Schema.Top, ...Array<Schema.Top>],
+  schemas: Array<Schema.Top>,
   getStatus: (ast: AST.AST) => number,
   getDescription: (ast: AST.AST) => string | undefined
 ): ResponseBodies {
@@ -557,7 +540,7 @@ function extractResponseBodies(
   function process(schema: Schema.Top) {
     const ast = schema.ast
     const status = getStatus(ast)
-    if (isNoContent(ast)) {
+    if (HttpApiSchema.isNoContent(ast)) {
       addNoContent(status, getDescription(schema.ast) ?? "<No Content>")
     } else {
       addContent(schema, status, HttpApiSchema.getResponseEncoding(ast))
@@ -634,9 +617,26 @@ function toEncodingAST(ast: AST.AST, _tag: HttpApiSchema.Encoding["_tag"]): AST.
       return Schema.String.ast
     case "FormUrlEncoded":
     case "Json":
-    case "Multipart":
       return ast
+    case "Multipart":
+      return persistedFileToBinaryEncoding(ast)
+  }
+}
+
+function persistedFileToBinaryEncoding(ast: AST.AST): AST.AST {
+  if (
+    AST.isDeclaration(ast) &&
+    ((ast.annotations as (Schema.Annotations.Declaration<unknown, readonly []> | undefined))?.typeConstructor?._tag ===
+      "effect/http/PersistedFile")
+  ) {
+    return Uint8ArrayEncoding.ast
   }
+
+  if (typeof (ast as any)?.recur === "function") {
+    return (ast as any).recur(persistedFileToBinaryEncoding)
+  }
+
+  return ast
 }
 
 const makeSecurityScheme = (security: HttpApiSecurity): OpenAPISecurityScheme => {
@@ -653,7 +653,7 @@ const makeSecurityScheme = (security: HttpApiSecurity): OpenAPISecurityScheme =>
       }
     }
     case "Bearer": {
-      const format = ServiceMap.getOption(security.annotations, Format).pipe(
+      const format = Context.getOption(security.annotations, Format).pipe(
         Option.map((format) => ({ bearerFormat: format })),
         Option.getOrUndefined
       )
@@ -731,6 +731,7 @@ export interface OpenAPISpecExternalDocs {
 export interface OpenAPISpecLicense {
   name: string
   url?: string
+  [key: string]: unknown
 }
 
 /**