effect 4.0.0-rc.111 → 4.0.0-rc.113

package/src/unstable/httpapi/HttpApiClient.ts

@@ -29,7 +29,7 @@ import * as HttpBody from "../http/HttpBody.ts"
 import * as HttpClient from "../http/HttpClient.ts"
 import * as HttpClientError from "../http/HttpClientError.ts"
 import * as HttpClientRequest from "../http/HttpClientRequest.ts"
-import * as HttpClientResponse from "../http/HttpClientResponse.ts"
+import type * as HttpClientResponse from "../http/HttpClientResponse.ts"
 import * as HttpMethod from "../http/HttpMethod.ts"
 import * as UrlParams from "../http/UrlParams.ts"
 import * as HttpApi from "./HttpApi.ts"
@@ -164,8 +164,9 @@ export declare namespace Client {
 
   /**
    * The typed function generated for an endpoint, accepting the endpoint request
-   * shape and returning an effect whose success, error, and service channels reflect
-   * the endpoint schemas, middleware, and selected response mode.
+   * shape, including optional per-call SSE decoding options. The returned effect's success,
+   * error, and service channels reflect the endpoint schemas, middleware, and
+   * selected response mode.
    *
    * @category models
    * @since 4.0.0
@@ -330,11 +331,7 @@ export const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Con
       onEndpoint(onEndpointOptions) {
         const { group, endpoint, errors, successes } = onEndpointOptions
         const makeUrl = compilePath(endpoint.path)
-        const decodeMap: Record<
-          number | "orElse",
-          (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<unknown, unknown, unknown>
-        > = { orElse: statusOrElse }
-        const decodeResponse = HttpClientResponse.matchStatus(decodeMap)
+        const decodeMap: Record<number | "orElse", ResponseDecoder> = { orElse: statusOrElse }
         const errorAlternatives = new Map<number, Array<ResponseAlternative>>()
         for (const [status, schemas] of errors.entries()) {
           const grouped = groupSchemasByContentType(schemas)
@@ -404,6 +401,7 @@ export const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Con
             readonly payload: unknown
             readonly headers: Record<string, string> | undefined
             readonly responseMode?: HttpApiEndpoint.ClientResponseMode
+            readonly sseOptions?: Sse.DecodeOptions | undefined
           } | undefined
         ) {
           let httpRequest = HttpClientRequest.make(endpoint.method)(endpoint.path)
@@ -455,9 +453,10 @@ export const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Con
             return response
           }
 
+          const decoded = (decodeMap[response.status] ?? decodeMap.orElse)(response, request?.sseOptions)
           const value = yield* (options.transformResponse === undefined
-            ? decodeResponse(response)
-            : options.transformResponse(decodeResponse(response)))
+            ? decoded
+            : options.transformResponse(decoded))
 
           return request?.responseMode === "decoded-and-response" ? [value, response] : value
         })
@@ -687,9 +686,20 @@ export const urlBuilder = <Api extends HttpApi.Constraint>(api: Api, options?: {
         const queryInput = request?.query === undefined
           ? undefined
           : (encodeQuery === undefined ? request.query : encodeQuery(request.query)) as UrlParams.Input
-        const query = queryInput === undefined ? "" : UrlParams.toString(UrlParams.fromInput(queryInput))
-        const url = query === "" ? path : `${path}?${query}`
-        return options?.baseUrl === undefined ? url : new URL(url, options.baseUrl.toString()).toString()
+        const urlParams = queryInput === undefined ? UrlParams.empty : UrlParams.fromInput(queryInput)
+        if (options?.baseUrl === undefined) {
+          const query = UrlParams.toString(urlParams)
+          return query === "" ? path : `${path}?${query}`
+        }
+        const url = new URL(
+          HttpClientRequest.prependUrl(HttpClientRequest.get(path), options.baseUrl.toString()).url
+        )
+        for (const [key, value] of urlParams.params) {
+          if (value !== undefined) {
+            url.searchParams.append(key, value)
+          }
+        }
+        return url.toString()
       }
       InternalRecord.assignProperty(
         group.topLevel ? builder : builder[group.identifier],
@@ -767,7 +777,10 @@ function toCodecArrayBufferWithHeaders(schema: Schema.Constraint): Schema.Top {
   )
 }
 
-type ResponseDecoder = (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<unknown, unknown, unknown>
+type ResponseDecoder = (
+  response: HttpClientResponse.HttpClientResponse,
+  sseOptions?: Sse.DecodeOptions
+) => Effect.Effect<unknown, unknown, unknown>
 
 interface ResponseAlternative {
   readonly contentType: string
@@ -794,12 +807,12 @@ function makeResponseDecoder(alternatives: ReadonlyArray<ResponseAlternative>):
   if (alternatives.length === 1 && first !== undefined) {
     return first.decode
   }
-  return (response) => {
+  return (response, sseOptions) => {
     const contentType = MediaType.normalize(response.headers["content-type"] ?? "")
     const alternative = alternatives.find((alternative) => alternative.contentType === contentType)
     return alternative === undefined
       ? failUnsupportedContentType(response, contentType, alternatives)
-      : alternative.decode(response)
+      : alternative.decode(response, sseOptions)
   }
 }
 
@@ -871,21 +884,21 @@ function streamToResponse(successSchema: StreamSuccessSchema) {
       declaration: streamSchema,
       decoder: makeSseDecoder(streamSchema)
     }
-  const toStream = (response: HttpClientResponse.HttpClientResponse) =>
+  const toStream: ResponseDecoder = (response, sseOptions) =>
     Effect.map(Effect.context<never>(), (context) =>
       Stream.provideContext(
         sse === undefined ?
           response.stream :
-          decodeSseStream(response.stream, sse.declaration, sse.decoder),
+          decodeSseStream(response.stream, sse.declaration, sse.decoder(sseOptions)),
         context as Context.Context<unknown>
       ))
   if (!isWithHeaders) return toStream
 
   const decodeHeaders = Schema.decodeUnknownEffect(successSchema.headers)
-  return (response: HttpClientResponse.HttpClientResponse) =>
+  return (response: HttpClientResponse.HttpClientResponse, sseOptions?: Sse.DecodeOptions) =>
     Effect.flatMap(
       decodeHeaders(response.headers),
-      (headers) => Effect.map(toStream(response), (body) => HttpApiSchema.withHeaders({ body, headers }))
+      (headers) => Effect.map(toStream(response, sseOptions), (body) => HttpApiSchema.withHeaders({ body, headers }))
     )
 }
 
@@ -899,13 +912,14 @@ function makeSseDecoder(
     }),
     declaration.events
   ])
-  return Sse.decodeSchema(Event)
+  const defaultDecoder = Sse.decodeSchema(Event)
+  return (options?: Sse.DecodeOptions) => options === undefined ? defaultDecoder : Sse.decodeSchema(Event, options)
 }
 
 function decodeSseStream(
   stream: Stream.Stream<Uint8Array, HttpClientError.HttpClientError>,
   declaration: HttpApiSchema.StreamSse<Sse.EventCodec, Schema.Constraint, unknown>,
-  decoder: ReturnType<typeof makeSseDecoder>
+  decoder: ReturnType<ReturnType<typeof makeSseDecoder>>
 ): Stream.Stream<unknown, unknown, unknown> {
   const events = Stream.transformPull(
     stream.pipe(
@@ -1023,7 +1037,13 @@ function fromArrayBuffer(schema: Schema.Constraint): Schema.Top {
         : UnknownFromArrayBuffer
     }
     case "FormUrlEncoded":
-      return StringFromArrayBuffer.pipe(Schema.decodeTo(UrlParams.schemaRecord))
+      return StringFromArrayBuffer.pipe(Schema.decodeTo(
+        Schema.RecordFromUrlParams,
+        SchemaTransformation.transform({
+          decode: (text) => UrlParams.fromInput(new URLSearchParams(text)),
+          encode: UrlParams.toString
+        })
+      ))
     case "Uint8Array":
       return Uint8ArrayFromArrayBuffer
     case "Text":
@@ -1064,7 +1084,7 @@ function getEncodePayloadSchemaFromBody(
   const encoding = HttpApiSchema.getPayloadEncoding(ast, method)
   const out = $HttpBody.pipe(Schema.decodeTo(
     schema,
-    SchemaTransformation.transformOrFail<unknown, HttpBody.HttpBody>({
+    SchemaTransformation.transformEffect<unknown, HttpBody.HttpBody>({
       decode(input, options) {
         return Effect.fail(
           new SchemaIssue.Forbidden({ message: "Encode only schema" }, input, options)

package/src/unstable/httpapi/HttpApiEndpoint.ts

@@ -15,7 +15,7 @@ import * as Arr from "../../Array.ts"
 import type { Brand } from "../../Brand.ts"
 import * as Context from "../../Context.ts"
 import type { Effect } from "../../Effect.ts"
-import { identity } from "../../Function.ts"
+import { identity, memoize } from "../../Function.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
@@ -23,6 +23,7 @@ import * as AST from "../../SchemaAST.ts"
 import type * as Stream from "../../Stream.ts"
 import type { Simplify } from "../../Struct.ts"
 import type * as Types from "../../Types.ts"
+import type * as Sse from "../encoding/Sse.ts"
 import type { HttpMethod } from "../http/HttpMethod.ts"
 import * as HttpRouter from "../http/HttpRouter.ts"
 import type { HttpServerRequest } from "../http/HttpServerRequest.ts"
@@ -187,6 +188,7 @@ export interface HttpApiEndpoint<
   readonly error: ReadonlySet<Schema.Top>
   readonly annotations: Context.Context<never>
   readonly middlewares: ReadonlySet<Context.Key<Middleware, any>>
+  readonly disableCodecs: boolean
 
   /**
    * Add a prefix to the path of the endpoint.
@@ -282,10 +284,11 @@ export function getSuccessSchemas(endpoint: Top): [Schema.Top, ...Array<Schema.T
 /** @internal */
 export function getErrorSchemas(endpoint: Top): Array<Schema.Top> {
   const schemas = new Set<Schema.Top>(endpoint.error)
+  const transform = endpoint.disableCodecs ? identity : transformResponseSchema
   for (const middleware of endpoint.middlewares) {
     const key = middleware as any as HttpApiMiddleware.AnyService
     for (const schema of key.error) {
-      schemas.add(schema)
+      schemas.add(transform(schema))
     }
   }
   return Array.from(schemas)
@@ -484,9 +487,10 @@ export type RequestRaw<Endpoint> = Endpoint extends ConstraintRequest ? Endpoint
   : {}
 
 /**
- * Builds the request object accepted by a generated client method, including only
- * the params, query, headers, payload, and response mode fields required by the
- * endpoint. Multipart payloads are supplied as `FormData`.
+ * Builds the request object accepted by a generated client method, including the
+ * params, query, headers, and payload required by the endpoint, plus optional
+ * response mode and SSE decoding options. Multipart payloads are supplied as
+ * `FormData`.
  *
  * @category utility types
  * @since 4.0.0
@@ -507,8 +511,14 @@ export type ClientRequest<
         ? { readonly payload: FormData }
       : { readonly payload: Payload["Type"] }
     : { readonly payload: Payload["Type"] })
-) extends infer Req ? keyof Req extends never ? (void | { readonly responseMode?: ResponseMode }) :
-  Req & { readonly responseMode?: ResponseMode } :
+) extends infer Req ? keyof Req extends never ? (void | {
+      readonly responseMode?: ResponseMode
+      readonly sseOptions?: Sse.DecodeOptions | undefined
+    }) :
+  Req & {
+    readonly responseMode?: ResponseMode
+    readonly sseOptions?: Sse.DecodeOptions | undefined
+  } :
   void
 
 /**
@@ -833,7 +843,8 @@ const optionsFromEndpoint = (endpoint: Top) => ({
   success: endpoint.success,
   error: endpoint.error,
   annotations: endpoint.annotations,
-  middlewares: endpoint.middlewares
+  middlewares: endpoint.middlewares,
+  disableCodecs: endpoint.disableCodecs
 })
 
 function makeProto<
@@ -860,6 +871,7 @@ function makeProto<
   readonly error: ReadonlySet<Schema.Top>
   readonly annotations: Context.Context<never>
   readonly middlewares: ReadonlySet<Context.Key<Middleware, any>>
+  readonly disableCodecs: boolean
 }): HttpApiEndpoint<
   Identifier,
   Method,
@@ -1090,7 +1102,8 @@ export const make = <Method extends HttpMethod>(method: Method): {
     success: getSuccessResponse(options?.success, method, disableCodecs),
     error: getErrorResponse(options?.error, disableCodecs),
     annotations: Context.empty(),
-    middlewares: new Set()
+    middlewares: new Set(),
+    disableCodecs
   })
 }
 
@@ -1157,7 +1170,7 @@ function getSuccessResponse(
   return new Set(disableCodecs ? schemas : schemas.map(transformResponseSchema))
 }
 
-function transformResponseSchema(schema: Schema.Top): Schema.Top {
+const transformResponseSchema = memoize((schema: Schema.Top): Schema.Top => {
   if (HttpApiSchema.isStreamSchema(schema)) return schema
   if (HttpApiSchema.isWithHeaders(schema)) {
     const inner = HttpApiSchema.isStreamSchema(schema.schema)
@@ -1166,7 +1179,7 @@ function transformResponseSchema(schema: Schema.Top): Schema.Top {
     return HttpApiSchema.rebuildWithHeaders(schema, inner, Schema.toCodecStringTree(schema.headers))
   }
   return transformResponse(schema)
-}
+})
 
 function getErrorResponse(
   error: Schema.Top | ReadonlyArray<Schema.Top> | undefined,

package/src/unstable/httpapi/HttpApiError.ts

@@ -458,7 +458,9 @@ export class HttpApiSchemaError extends Data.TaggedClass("HttpApiSchemaError")<{
     kind: HttpApiSchemaError["kind"],
     effect: Effect.Effect<A, Schema.SchemaError, R>
   ): Effect.Effect<A, HttpApiSchemaError, R> {
-    return Effect.mapError(effect, (error) => new HttpApiSchemaError({ kind, cause: error }))
+    // Decoders return completed Exit values for synchronous results, so map
+    // eagerly and skip the error wrapper when nothing remains to run.
+    return Effect.mapErrorEager(effect, (error) => new HttpApiSchemaError({ kind, cause: error }))
   }
 
   readonly name = "HttpApiSchemaError"

package/src/unstable/httpapi/HttpApiMiddleware.ts

@@ -352,17 +352,19 @@ export const Service = <
     readonly requiredForClient?: boolean | undefined
   } | undefined
 ) => {
-  const Err = globalThis.Error as any
   const limit = getStackTraceLimit()
-  setStackTraceLimit(2)
-  const creationError = new Err()
-  setStackTraceLimit(limit)
+  let creationError: globalThis.Error | undefined
+  if (limit !== 0) {
+    setStackTraceLimit(2)
+    creationError = new globalThis.Error()
+    setStackTraceLimit(limit)
+  }
 
   class Service extends Context.Service<Self, any>()(id) {}
   const self = Service as any
   Object.defineProperty(Service, "stack", {
     get() {
-      return creationError.stack
+      return creationError?.stack
     }
   })
   self[TypeId] = TypeId

package/src/unstable/httpapi/HttpApiScalar.ts

@@ -9,6 +9,7 @@
  * @since 4.0.0
  */
 import * as Effect from "../../Effect.ts"
+import * as Function from "../../Function.ts"
 import type * as Layer from "../../Layer.ts"
 import * as HttpRouter from "../http/HttpRouter.ts"
 import * as HttpServerResponse from "../http/HttpServerResponse.ts"
@@ -144,36 +145,37 @@ const makeHandler = <Id extends string, Groups extends HttpApiGroup.Constraint>(
   readonly source: ScalarSource
   readonly scalar: ScalarConfig | undefined
 }) => {
-  const spec = OpenApi.fromApi(options.api)
-  const { customFetch, ...scalar } = options.scalar ?? {}
-  const scalarConfig = {
-    _integration: "html",
-    ...scalar
-  }
-  const scalarScript = options.source._tag === "Cdn"
-    ? `<script src="${
-      Html.escapeAttribute(
-        `https://cdn.jsdelivr.net/npm/@scalar/api-reference@${
-          encodeURIComponent(options.source.version ?? "latest")
-        }/dist/browser/standalone.min.js`
-      )
-    }" crossorigin></script>`
-    : `<script>${options.source.source}</script>`
-  const response = HttpServerResponse.html(`<!doctype html>
+  const makeResponse = Function.memoize((api: HttpApi.HttpApi<Id, Groups>) => {
+    const spec = OpenApi.fromApi(api)
+    const { customFetch, ...scalar } = options.scalar ?? {}
+    const scalarConfig = {
+      _integration: "html",
+      ...scalar
+    }
+    const scalarScript = options.source._tag === "Cdn"
+      ? `<script src="${
+        Html.escapeAttribute(
+          `https://cdn.jsdelivr.net/npm/@scalar/api-reference@${
+            encodeURIComponent(options.source.version ?? "latest")
+          }/dist/browser/standalone.min.js`
+        )
+      }" crossorigin></script>`
+      : `<script>${options.source.source}</script>`
+    return HttpServerResponse.html(`<!doctype html>
 <html>
   <head>
     <meta charset="utf-8" />
     <title>${Html.escape(spec.info.title)}</title>
     ${
-    !spec.info.description
-      ? ""
-      : `<meta name="description" content="${Html.escapeAttribute(spec.info.description)}"/>`
-  }
+      !spec.info.description
+        ? ""
+        : `<meta name="description" content="${Html.escapeAttribute(spec.info.description)}"/>`
+    }
     ${
-    !spec.info.description
-      ? ""
-      : `<meta name="og:description" content="${Html.escapeAttribute(spec.info.description)}"/>`
-  }
+      !spec.info.description
+        ? ""
+        : `<meta name="og:description" content="${Html.escapeAttribute(spec.info.description)}"/>`
+    }
     <meta
       name="viewport"
       content="width=device-width, initial-scale=1" />
@@ -185,14 +187,15 @@ const makeHandler = <Id extends string, Groups extends HttpApiGroup.Constraint>(
       window.Scalar.createApiReference(document.getElementById('api-reference-container'), {
         ...${Html.escapeJson(scalarConfig)},
         content: ${Html.escapeJson(spec)}${
-    customFetch === undefined ? "" : `,
+      customFetch === undefined ? "" : `,
         customFetch: ${customFetch}`
-  }
+    }
       })
     </script>
   </body>
 </html>`)
-  return Effect.succeed(response)
+  })
+  return Effect.sync(() => makeResponse(options.api))
 }
 
 /**

package/src/unstable/httpapi/HttpApiSchema.ts

@@ -518,6 +518,8 @@ export interface WithHeaders<S extends Schema.Top, H extends Schema.Top> extends
  * The Type of a `WithHeaders` schema: what handlers return and what the
  * client resolves to, constructed via {@link withHeaders}.
  *
+ * **Details**
+ *
  * `body` is the inner success value. For stream success schemas it is the
  * `Stream` itself, so headers are decided before the body starts streaming.
  *
@@ -539,9 +541,13 @@ const withHeadersValueSchema = Schema.declare(isWithHeadersValue)
 /**
  * Wraps a success schema with a response headers schema.
  *
+ * **Details**
+ *
  * Headers accept either a schema or a fields shorthand, mirroring the
  * request-side headers option.
  *
+ * **Example** (Adding response headers to a success schema)
+ *
  * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { HttpApiSchema } from "effect/unstable/httpapi"
@@ -587,6 +593,8 @@ export function WithHeaders(
 /**
  * Constructs a `WithHeaders` response value from a body and headers.
  *
+ * **Details**
+ *
  * The returned value is branded so servers and clients can detect it exactly,
  * including in mixed success unions. The same shape is used on both sides: a
  * value received from a client can be returned from another handler unchanged.
@@ -609,6 +617,8 @@ export const withHeaders = <A, H>(options: {
 /**
  * Returns `true` when a schema is a `WithHeaders` response schema.
  *
+ * **Example** (Detecting a response headers schema)
+ *
  * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { HttpApiSchema } from "effect/unstable/httpapi"
@@ -679,6 +689,8 @@ export interface encodeToWithHeaders<
  * defects on the client. Stream responses should use {@link WithHeaders},
  * which preserves the body stream's error channel in the generated client.
  *
+ * **Example** (Encoding an error with headers)
+ *
  * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { HttpApiSchema } from "effect/unstable/httpapi"
@@ -739,8 +751,8 @@ export function encodeToWithHeaders<
       )
     ).annotate({
       "~httpApiWithHeaders": { body, headers, headersCodec: Schema.toEncoded(headers) },
-      ...(status !== undefined ? { httpApiStatus: status } : undefined),
-      ...(encoding !== undefined ? { "~httpApiEncoding": encoding } : undefined)
+      httpApiStatus: status,
+      "~httpApiEncoding": encoding
     })
   }
 }
@@ -1000,11 +1012,6 @@ export function getResponseEncodingSchema(schema: Schema.Constraint): ResponseEn
   return getResponseEncoding(schema.ast)
 }
 
-/** @internal */
-export function getStatusStream(self: StreamSchema): number {
-  return getStatusSuccess(self.ast)
-}
-
 /** @internal */
 export function getStatusError(self: SchemaAST.AST): number {
   return resolveHttpApiStatus(self) ?? 500

package/src/unstable/httpapi/HttpApiSwagger.ts

@@ -9,6 +9,7 @@
  * @since 4.0.0
  */
 import * as Effect from "../../Effect.ts"
+import * as Function from "../../Function.ts"
 import type * as Layer from "../../Layer.ts"
 import * as HttpRouter from "../http/HttpRouter.ts"
 import * as HttpServerResponse from "../http/HttpServerResponse.ts"
@@ -21,8 +22,9 @@ import * as OpenApi from "./OpenApi.ts"
 const makeHandler = <Id extends string, Groups extends HttpApiGroup.Constraint>(options: {
   readonly api: HttpApi.HttpApi<Id, Groups>
 }) => {
-  const spec = OpenApi.fromApi(options.api)
-  const response = HttpServerResponse.html(`<!DOCTYPE html>
+  const makeResponse = Function.memoize((api: HttpApi.HttpApi<Id, Groups>) => {
+    const spec = OpenApi.fromApi(api)
+    return HttpServerResponse.html(`<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8" />
@@ -46,7 +48,8 @@ const makeHandler = <Id extends string, Groups extends HttpApiGroup.Constraint>(
   </script>
 </body>
 </html>`)
-  return Effect.succeed(response)
+  })
+  return Effect.sync(() => makeResponse(options.api))
 }
 
 /**

package/src/unstable/httpapi/HttpApiTest.ts

@@ -20,6 +20,7 @@ import type { HttpPlatform } from "../http/HttpPlatform.ts"
 import * as HttpRouter from "../http/HttpRouter.ts"
 import * as HttpServerRequest from "../http/HttpServerRequest.ts"
 import * as HttpServerResponse from "../http/HttpServerResponse.ts"
+import * as preResponseHandler from "../http/internal/preResponseHandler.ts"
 import type * as HttpApi from "./HttpApi.ts"
 import type { HandlerRuntime } from "./HttpApiBuilder.ts"
 import * as HttpApiBuilder from "./HttpApiBuilder.ts"
@@ -100,10 +101,14 @@ export const groups = Effect.fnUntraced(function*<
   const httpClient = HttpClient.make(Effect.fnUntraced(function*(request) {
     const serverRequest = HttpServerRequest.fromClientRequest(request)
     const response = yield* handler.pipe(
+      Effect.flatMap((response) => {
+        const preResponse = preResponseHandler.requestPreResponseHandlers.get(serverRequest.source)
+        return preResponse === undefined ? Effect.succeed(response) : preResponse(serverRequest, response)
+      }),
       Effect.provideService(HttpServerRequest.HttpServerRequest, serverRequest),
       Effect.orDie
     )
-    return HttpServerResponse.toClientResponse(response)
+    return HttpServerResponse.toClientResponse(response, { request })
   }, Effect.scoped))
 
   return yield* HttpApiClient.makeWith(api, {

package/src/unstable/httpapi/OpenApi.ts

@@ -14,6 +14,7 @@ import * as Context from "../../Context.ts"
 import * as Equal from "../../Equal.ts"
 import { constFalse } from "../../Function.ts"
 import * as InternalRecord from "../../internal/record.ts"
+import * as InternalToCodec from "../../internal/schema/toCodec.ts"
 import * as InternalToJsonSchemaDocument from "../../internal/schema/toJsonSchemaDocument.ts"
 import * as InternalToRepresentation from "../../internal/schema/toRepresentation.ts"
 import * as JsonPatch from "../../JsonPatch.ts"
@@ -328,6 +329,7 @@ function makeOpenApi<Id extends string, Groups extends HttpApiGroup.Constraint>(
   > = []
   const pathOperations = new Set<string>()
   const operationIds = new Set<string>()
+  const finalizeOperations: Array<() => void> = []
 
   processAnnotation(api.annotations, Title, (title) => {
     spec.info.title = title
@@ -378,7 +380,7 @@ function makeOpenApi<Id extends string, Groups extends HttpApiGroup.Constraint>(
       if (Context.get(mergedAnnotations, Exclude)) {
         return
       }
-      let op: OpenAPISpecOperation = {
+      const op: OpenAPISpecOperation = {
         tags: [Context.getOrElse(group.annotations, Title, () => group.identifier)],
         operationId: Context.getOrElse(
           endpoint.annotations,
@@ -422,7 +424,7 @@ function makeOpenApi<Id extends string, Groups extends HttpApiGroup.Constraint>(
             content.forEach((map, encoding) => {
               map.forEach((schemas, contentType) => {
                 const asts = Array.from(schemas, SchemaAST.getAST)
-                const ast = asts.length === 1 ? asts[0] : new SchemaAST.Union(asts, "anyOf")
+                const ast = asts.length === 1 ? asts[0] : new SchemaAST.Union(asts)
 
                 pathOps.push({
                   _tag: "schema",
@@ -583,7 +585,7 @@ function makeOpenApi<Id extends string, Groups extends HttpApiGroup.Constraint>(
           const content: OpenApiSpecContent = {}
           for (const [contentType, { encoding, schemas }] of schemasByContentType) {
             const asts = schemas.map(SchemaAST.getAST)
-            const ast = asts.length === 1 ? asts[0] : new SchemaAST.Union(asts, "anyOf")
+            const ast = asts.length === 1 ? asts[0] : new SchemaAST.Union(asts)
             pathOps.push({
               _tag: "schema",
               ast: toEncodingAST(ast, encoding._tag),
@@ -618,32 +620,35 @@ function makeOpenApi<Id extends string, Groups extends HttpApiGroup.Constraint>(
         () => "Error"
       )
 
-      processAnnotation(endpoint.annotations, Override, (override) => {
-        // OpenAPI documents are JSON, so symbol keys are intentionally ignored.
-        for (const [key, value] of Object.entries(override)) {
-          InternalRecord.assignProperty(op as any, key, value)
-        }
-      })
-      processAnnotation(endpoint.annotations, Transform, (transformFn) => {
-        op = transformFn(op) as OpenAPISpecOperation
-      })
-
       const pathOperation = `${method} ${path.replace(/\{[^}]+\}/g, "{}")}`
       if (pathOperations.has(pathOperation)) {
         throw new globalThis.Error(`Duplicate OpenAPI operation for ${endpoint.method} ${path}`)
       }
-      const operationId = op.operationId
-      if (operationId !== undefined) {
-        if (operationIds.has(operationId)) {
-          throw new globalThis.Error(`Duplicate OpenAPI operationId: ${operationId}`)
-        }
-        operationIds.add(operationId)
-      }
       pathOperations.add(pathOperation)
       if (!Object.hasOwn(spec.paths, path)) {
         InternalRecord.assignProperty(spec.paths, path, {})
       }
       spec.paths[path][method] = op
+      finalizeOperations.push(() => {
+        let op = spec.paths[path][method]!
+        processAnnotation(endpoint.annotations, Override, (override) => {
+          // OpenAPI documents are JSON, so symbol keys are intentionally ignored.
+          for (const [key, value] of Object.entries(override)) {
+            InternalRecord.assignProperty(op as any, key, value)
+          }
+        })
+        processAnnotation(endpoint.annotations, Transform, (transformFn) => {
+          op = transformFn(op) as OpenAPISpecOperation
+        })
+        const operationId = op.operationId
+        if (operationId !== undefined) {
+          if (operationIds.has(operationId)) {
+            throw new globalThis.Error(`Duplicate OpenAPI operationId: ${operationId}`)
+          }
+          operationIds.add(operationId)
+        }
+        spec.paths[path][method] = op
+      })
     }
   })
 
@@ -672,9 +677,10 @@ function makeOpenApi<Id extends string, Groups extends HttpApiGroup.Constraint>(
     const jsonSchemaMultiDocument = JsonSchema.toMultiDocumentOpenApi3_1(
       InternalToJsonSchemaDocument.toJsonSchemaMultiDocument(
         InternalToRepresentation.toRepresentations(
-          Arr.map(pathOps, (op) => Schema.toCodecJsonAST(op.ast)),
+          Arr.map(pathOps, (op) => InternalToCodec.toCodecJsonAST(op.ast)),
           options
-        )
+        ),
+        { onExcessProperty: "error" }
       )
     )
     const patchOps: Array<JsonPatch.JsonPatchOperation> = pathOps.map((op, i) => {
@@ -698,6 +704,10 @@ function makeOpenApi<Id extends string, Groups extends HttpApiGroup.Constraint>(
     spec = JsonPatch.apply(patchOps, spec as any) as any
   }
 
+  for (const finalize of finalizeOperations) {
+    finalize()
+  }
+
   Object.keys(spec.components.schemas).forEach((key) => {
     if (!JsonSchema.VALID_OPEN_API_COMPONENTS_SCHEMAS_KEY_REGEXP.test(key)) {
       throw new globalThis.Error(`Invalid component schema key: ${key}`)