effect 4.0.0-beta.80 → 4.0.0-beta.81

package/src/unstable/httpapi/HttpApiClient.ts

@@ -21,8 +21,10 @@ import * as Schema from "../../Schema.ts"
 import * as SchemaAST from "../../SchemaAST.ts"
 import * as SchemaIssue from "../../SchemaIssue.ts"
 import * as SchemaTransformation from "../../SchemaTransformation.ts"
+import * as Stream from "../../Stream.ts"
 import type { Simplify } from "../../Types.ts"
 import * as UndefinedOr from "../../UndefinedOr.ts"
+import * as Sse from "../encoding/Sse.ts"
 import * as HttpBody from "../http/HttpBody.ts"
 import * as HttpClient from "../http/HttpClient.ts"
 import * as HttpClientError from "../http/HttpClientError.ts"
@@ -68,6 +70,30 @@ export type ForApi<Api extends HttpApi.Any, E = never, R = never> = Api extends
   HttpApi.HttpApi<infer _Id, infer Groups> ? Client<Groups, E, R> :
   never
 
+type SuccessType<S> = S extends HttpApiSchema.StreamSse<
+  infer _Events,
+  infer _Error,
+  infer _Value
+> ? Stream.Stream<
+    _Value,
+    _Error["Type"] | HttpClientError.HttpClientError | Schema.SchemaError | Sse.Retry,
+    never
+  >
+  : S extends HttpApiSchema.StreamUint8Array ? Stream.Stream<Uint8Array, HttpClientError.HttpClientError, never>
+  : S extends Schema.Top ? S["Type"]
+  : never
+
+type SuccessDecodingServices<S> = S extends HttpApiSchema.StreamSse<
+  infer _Events,
+  infer _Error,
+  infer _Value
+> ?
+    | _Events["DecodingServices"]
+    | _Error["DecodingServices"]
+  : S extends HttpApiSchema.StreamUint8Array ? never
+  : S extends Schema.Top ? S["DecodingServices"]
+  : never
+
 /**
  * Helper types used to describe generated HTTP API clients, including endpoint
  * methods, response modes, and grouped client shapes.
@@ -135,7 +161,7 @@ export declare namespace Client {
   ] ? <Mode extends ResponseMode = ResponseMode>(
       request: Simplify<HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, Mode>>
     ) => Effect.Effect<
-      Response<_Success["Type"], Mode>,
+      Response<SuccessType<_Success>, Mode>,
       | HttpApiMiddleware.Error<_Middleware>
       | HttpApiMiddleware.ClientError<_Middleware>
       | E
@@ -146,7 +172,10 @@ export declare namespace Client {
       | _Query["EncodingServices"]
       | _Payload["EncodingServices"]
       | _Headers["EncodingServices"]
-      | ([Mode] extends ["response-only"] ? never : _Success["DecodingServices"] | _Error["DecodingServices"])
+      | ([Mode] extends ["response-only"] ? never
+        :
+          | SuccessDecodingServices<_Success>
+          | _Error["DecodingServices"])
     > :
     never
 
@@ -312,9 +341,25 @@ export const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any
               Effect.fail
             )
         })
-        successes.forEach((schemas, status) => {
-          decodeMap[status] = schemasToResponse(schemas)
-        })
+
+        const successAlternatives = new Map<number, Array<ResponseAlternative>>()
+        for (const [status, schemas] of successes.entries()) {
+          const grouped = groupSchemasByContentType(schemas)
+          for (const [contentType, schemas] of grouped.entries()) {
+            addResponseAlternative(successAlternatives, status, contentType, schemasToResponse(schemas))
+          }
+        }
+        for (const streamSuccess of getStreamSuccessSchemas(endpoint)) {
+          addResponseAlternative(
+            successAlternatives,
+            HttpApiSchema.getStatusStream(streamSuccess),
+            streamSuccess.contentType,
+            streamToResponse(streamSuccess)
+          )
+        }
+        for (const [status, alternatives] of successAlternatives.entries()) {
+          decodeMap[status] = makeResponseDecoder(alternatives)
+        }
 
         // encoders
         const encodeParams = UndefinedOr.map(endpoint.params, Schema.encodeUnknownEffect)
@@ -648,6 +693,152 @@ function schemasToResponse(schemas: readonly [Schema.Top, ...Array<Schema.Top>])
   return (response: HttpClientResponse.HttpClientResponse) => Effect.flatMap(response.arrayBuffer, decode)
 }
 
+type ResponseDecoder = (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<unknown, unknown, unknown>
+
+interface ResponseAlternative {
+  readonly contentType: string
+  readonly decode: ResponseDecoder
+}
+
+function addResponseAlternative(
+  map: Map<number, Array<ResponseAlternative>>,
+  status: number,
+  contentType: string,
+  decode: ResponseDecoder
+) {
+  const normalizedContentType = normalizeContentType(contentType)
+  const alternatives = map.get(status)
+  if (alternatives === undefined) {
+    map.set(status, [{ contentType: normalizedContentType, decode }])
+  } else {
+    alternatives.push({ contentType: normalizedContentType, decode })
+  }
+}
+
+function makeResponseDecoder(alternatives: ReadonlyArray<ResponseAlternative>): ResponseDecoder {
+  const first = alternatives[0]
+  if (alternatives.length === 1 && first !== undefined) {
+    return first.decode
+  }
+  return (response) => {
+    const contentType = normalizeContentType(response.headers["content-type"] ?? "")
+    const alternative = alternatives.find((alternative) => alternative.contentType === contentType)
+    return alternative === undefined
+      ? failUnsupportedContentType(response, contentType, alternatives)
+      : alternative.decode(response)
+  }
+}
+
+function groupSchemasByContentType(
+  schemas: Arr.NonEmptyReadonlyArray<Schema.Top>
+): Map<string, Arr.NonEmptyReadonlyArray<Schema.Top>> {
+  const grouped = new Map<string, [Schema.Top, ...Array<Schema.Top>]>()
+  for (const schema of schemas) {
+    const contentType = HttpApiSchema.getResponseEncoding(schema.ast).contentType
+    const existing = grouped.get(contentType)
+    if (existing === undefined) {
+      grouped.set(contentType, [schema])
+    } else {
+      existing.push(schema)
+    }
+  }
+  return grouped
+}
+
+function normalizeContentType(contentType: string): string {
+  const normalized = contentType.toLowerCase().trim()
+  const index = normalized.indexOf(";")
+  return index === -1 ? normalized : normalized.slice(0, index).trim()
+}
+
+function failUnsupportedContentType(
+  response: HttpClientResponse.HttpClientResponse,
+  contentType: string,
+  alternatives: ReadonlyArray<ResponseAlternative>
+) {
+  const expected = Array.from(new Set(alternatives.map((alternative) => alternative.contentType))).join(", ")
+  return Effect.fail(
+    new HttpClientError.HttpClientError({
+      reason: new HttpClientError.DecodeError({
+        request: response.request,
+        response,
+        description: `Unsupported response content-type for status ${response.status}: ${
+          contentType || "<missing>"
+        }. Expected one of: ${expected}`
+      })
+    })
+  )
+}
+
+const reservedStreamFailureEvent = "effect/httpapi/stream/failure"
+
+function getStreamSuccessSchemas(endpoint: HttpApiEndpoint.AnyWithProps): Array<HttpApiSchema.StreamSchema> {
+  const schemas: Array<HttpApiSchema.StreamSchema> = []
+  for (const schema of endpoint.success) {
+    if (HttpApiSchema.isStreamSchema(schema)) {
+      schemas.push(schema)
+    }
+  }
+  return schemas
+}
+
+function streamToResponse(streamSchema: HttpApiSchema.StreamSchema) {
+  return (response: HttpClientResponse.HttpClientResponse) =>
+    Effect.map(Effect.context<never>(), (context) =>
+      Stream.provideContext(
+        HttpApiSchema.isStreamUint8Array(streamSchema) ?
+          response.stream :
+          decodeSseStream(response.stream, streamSchema),
+        context as Context.Context<unknown>
+      ))
+}
+
+function decodeSseStream(
+  stream: Stream.Stream<Uint8Array, HttpClientError.HttpClientError>,
+  declaration: HttpApiSchema.StreamSse<Sse.EventCodec, Schema.Top, unknown>
+): Stream.Stream<unknown, unknown, unknown> {
+  const Event = Schema.Union([
+    declaration.events,
+    Schema.Struct({
+      event: Schema.Literal(reservedStreamFailureEvent),
+      data: Schema.fromJsonString(Schema.toCodecJson(Schema.Cause(declaration.error, Schema.Defect())))
+    })
+  ])
+  const events = Stream.transformPull(
+    stream.pipe(
+      Stream.decodeText,
+      Stream.pipeThroughChannel(Sse.decodeSchema(Event))
+    ),
+    (pull) =>
+      Effect.sync(() => {
+        let failureCause: Cause.Cause<unknown> | undefined = undefined
+        return Effect.suspend(() => {
+          if (failureCause) {
+            return Effect.failCause(failureCause)
+          }
+          return Effect.flatMap(pull, (events) => {
+            for (let i = 0; i < events.length; i++) {
+              const event = events[i]
+              if (event.event === reservedStreamFailureEvent) {
+                if (i === 0) {
+                  return Effect.failCause(event.data)
+                }
+                failureCause = event.data
+                events = events.slice(0, i) as any
+                break
+              }
+            }
+            return Effect.succeed(events)
+          })
+        })
+      })
+  )
+  if (declaration.sseMode === "data") {
+    return Stream.map(events, (event) => event.data)
+  }
+  return events
+}
+
 const ArrayBuffer = Schema.instanceOf(globalThis.ArrayBuffer, {
   expected: "ArrayBuffer"
 })

package/src/unstable/httpapi/HttpApiEndpoint.ts

@@ -19,6 +19,7 @@ import { identity } from "../../Function.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
+import * as AST from "../../SchemaAST.ts"
 import type * as Stream from "../../Stream.ts"
 import type * as Types from "../../Types.ts"
 import type { HttpMethod } from "../http/HttpMethod.ts"
@@ -53,6 +54,48 @@ export type PayloadMap = ReadonlyMap<string, {
   readonly schemas: [Schema.Top, ...Array<Schema.Top>]
 }>
 
+type SuccessType<S> = S extends HttpApiSchema.StreamSse<
+  infer _Events,
+  infer _Error,
+  infer _Value
+> ? Stream.Stream<_Value, _Error["Type"], never>
+  : S extends HttpApiSchema.StreamUint8Array ? Stream.Stream<Uint8Array, unknown, never>
+  : S extends Schema.Top ? S["Type"]
+  : never
+
+type SuccessEncodingServices<S> = S extends HttpApiSchema.StreamSse<
+  infer _Events,
+  infer _Error,
+  infer _Value
+> ? _Events["EncodingServices"] | _Error["EncodingServices"]
+  : S extends HttpApiSchema.StreamUint8Array ? never
+  : S extends Schema.Top ? S["EncodingServices"]
+  : never
+
+type SuccessDecodingServices<S> = S extends HttpApiSchema.StreamSse<
+  infer _Events,
+  infer _Error,
+  infer _Value
+> ? _Events["DecodingServices"] | _Error["DecodingServices"]
+  : S extends HttpApiSchema.StreamUint8Array ? never
+  : S extends Schema.Top ? S["DecodingServices"]
+  : never
+
+type ExtractSuccessOrArray<S extends SuccessConstraint> = S extends ReadonlyArray<Schema.Top> ? S[number] : S
+
+type ExtractBufferedSuccess<S extends SuccessConstraint> = Exclude<
+  Extract<ExtractSuccessOrArray<S>, Schema.Top>,
+  HttpApiSchema.StreamSchema
+>
+
+type ExtractStreamSuccess<S extends SuccessConstraint> = ExtractSuccessOrArray<S> extends infer Success ?
+  Success extends HttpApiSchema.StreamSchema ? Success : never
+  : never
+
+type JsonSuccessOrArray<S extends SuccessConstraint> = [ExtractBufferedSuccess<S>] extends [never] ?
+  ExtractStreamSuccess<S>
+  : Json<ExtractBufferedSuccess<S>> | ExtractStreamSuccess<S>
+
 /**
  * Represents an API endpoint. An API endpoint is mapped to a single route on
  * the underlying `HttpRouter`.
@@ -587,7 +630,7 @@ export type ServerServices<Endpoint> = Endpoint extends HttpApiEndpoint<
     | _Query["DecodingServices"]
     | _Payload["DecodingServices"]
     | _Headers["DecodingServices"]
-    | _Success["EncodingServices"]
+    | SuccessEncodingServices<_Success>
     | _Error["EncodingServices"]
     | HttpApiMiddleware.ErrorServicesEncode<_M>
   : never
@@ -616,7 +659,7 @@ export type ClientServices<Endpoint> = Endpoint extends HttpApiEndpoint<
     | _Query["EncodingServices"]
     | _Payload["EncodingServices"]
     | _Headers["EncodingServices"]
-    | _Success["DecodingServices"]
+    | SuccessDecodingServices<_Success>
     | _Error["DecodingServices"]
   : never
 
@@ -672,7 +715,7 @@ export type ErrorServicesDecode<Endpoint> = Endpoint extends HttpApiEndpoint<
  */
 export type Handler<Endpoint extends Any, E, R> = (
   request: Types.Simplify<Request<Endpoint>>
-) => Effect<Endpoint["~Success"]["Type"] | HttpServerResponse, Endpoint["~Error"]["Type"] | E, R>
+) => Effect<SuccessType<Endpoint["~Success"]> | HttpServerResponse, Endpoint["~Error"]["Type"] | E, R>
 
 /**
  * The raw server handler for an endpoint, receiving a request shape without a
@@ -683,7 +726,7 @@ export type Handler<Endpoint extends Any, E, R> = (
  */
 export type HandlerRaw<Endpoint extends Any, E, R> = (
   request: Types.Simplify<RequestRaw<Endpoint>>
-) => Effect<Endpoint["~Success"]["Type"] | HttpServerResponse, Endpoint["~Error"]["Type"] | E, R>
+) => Effect<SuccessType<Endpoint["~Success"]> | HttpServerResponse, Endpoint["~Error"]["Type"] | E, R>
 
 /**
  * Selects the endpoint with the specified name from a union of endpoints.
@@ -736,7 +779,7 @@ export type HandlerRawWithName<Endpoints extends Any, Name extends string, E, R>
  */
 export type SuccessWithName<Endpoints extends Any, Name extends string> = Success<
   WithName<Endpoints, Name>
->["Type"]
+> extends infer S ? SuccessType<S> : never
 
 /**
  * Computes the full error value union for the endpoint with the specified name in
@@ -1024,7 +1067,7 @@ export type PayloadConstraint<Method extends HttpMethod> = Method extends HttpMe
     string,
     Schema.Encoder<string | ReadonlyArray<string> | undefined, unknown>
   > :
-  SuccessConstraint
+  Schema.Top | ReadonlyArray<Schema.Top>
 
 /**
  * Payload constraint used when automatic codecs are enabled: no-body methods
@@ -1056,6 +1099,13 @@ export type SuccessConstraint = Schema.Top | ReadonlyArray<Schema.Top>
  */
 export type ErrorConstraint = Schema.Top | ReadonlyArray<Schema.Top>
 
+type ErrorWithoutStream<S extends ErrorConstraint> = [
+  Extract<
+    S extends ReadonlyArray<Schema.Top> ? S[number] : S,
+    HttpApiSchema.StreamSchema
+  >
+] extends [never] ? S : never
+
 /**
  * Creates endpoint constructors for a specific HTTP method. The resulting
  * constructor builds an `HttpApiEndpoint` from a name, path, and optional request
@@ -1073,7 +1123,7 @@ export const make = <Method extends HttpMethod>(method: Method): {
     Query extends Schema.Top | Schema.Struct.Fields = never,
     Payload extends PayloadConstraintCodecs<Method> = never,
     Headers extends Schema.Top | Schema.Struct.Fields = never,
-    const Success extends Schema.Top | ReadonlyArray<Schema.Top> = HttpApiSchema.NoContent,
+    const Success extends SuccessConstraint = HttpApiSchema.NoContent,
     const Error extends Schema.Top | ReadonlyArray<Schema.Top> = never
   >(
     name: Name,
@@ -1085,7 +1135,7 @@ export const make = <Method extends HttpMethod>(method: Method): {
       readonly headers?: Headers | undefined
       readonly payload?: Payload | undefined
       readonly success?: Success | undefined
-      readonly error?: Error | undefined
+      readonly error?: ErrorWithoutStream<Error> | undefined
     }
   ): HttpApiEndpoint<
     Name,
@@ -1096,7 +1146,7 @@ export const make = <Method extends HttpMethod>(method: Method): {
     Method extends HttpMethod.WithBody ? Json<ExtractSchemaOrArray<Payload>>
       : StringTree<ExtractSchemaOrArray<Payload>>,
     StringTree<Headers extends Schema.Struct.Fields ? Schema.Struct<Headers> : Headers>,
-    Json<Success extends ReadonlyArray<Schema.Top> ? Success[number] : Success>,
+    JsonSuccessOrArray<Success>,
     Json<Error extends ReadonlyArray<Schema.Top> ? Error[number] : Error>
   >
   <
@@ -1118,7 +1168,7 @@ export const make = <Method extends HttpMethod>(method: Method): {
       readonly headers?: Headers | undefined
       readonly payload?: Payload | undefined
       readonly success?: Success | undefined
-      readonly error?: Error | undefined
+      readonly error?: ErrorWithoutStream<Error> | undefined
     }
   ): HttpApiEndpoint<
     Name,
@@ -1128,7 +1178,7 @@ export const make = <Method extends HttpMethod>(method: Method): {
     Query extends Schema.Struct.Fields ? Schema.Struct<Query> : Query,
     ExtractSchemaOrArray<Payload>,
     ExtractSchemaOrArray<Headers>,
-    Success extends ReadonlyArray<Schema.Top> ? Success[number] : Success,
+    ExtractSuccessOrArray<Success>,
     Error extends ReadonlyArray<Schema.Top> ? Error[number] : Error
   >
 } =>
@@ -1151,7 +1201,7 @@ export const make = <Method extends HttpMethod>(method: Method): {
     readonly headers?: Headers | undefined
     readonly payload?: Payload | undefined
     readonly success?: Success | undefined
-    readonly error?: Error | undefined
+    readonly error?: ErrorWithoutStream<Error> | undefined
   }
 ): HttpApiEndpoint<
   Name,
@@ -1163,7 +1213,7 @@ export const make = <Method extends HttpMethod>(method: Method): {
     : Payload extends ReadonlyArray<Schema.Top> ? Payload[number]
     : Payload,
   Headers extends Schema.Struct.Fields ? Schema.Struct<Headers> : Headers,
-  Success extends ReadonlyArray<Schema.Top> ? Success[number] : Success,
+  ExtractSuccessOrArray<Success>,
   Error extends ReadonlyArray<Schema.Top> ? Error[number] : Error
 > => {
   const disableCodecs = options?.disableCodecs ?? false
@@ -1176,8 +1226,8 @@ export const make = <Method extends HttpMethod>(method: Method): {
     query: ensureStruct(options?.query, transformStringTree),
     headers: ensureStruct(options?.headers, transformStringTree),
     payload: getPayload(options?.payload, method, disableCodecs),
-    success: getResponse(options?.success, disableCodecs),
-    error: getResponse(options?.error, disableCodecs),
+    success: getSuccessResponse(options?.success, method, disableCodecs),
+    error: getErrorResponse(options?.error, disableCodecs),
     annotations: Context.empty(),
     middlewares: new Set()
   })
@@ -1257,13 +1307,154 @@ function getPayload(
   return result
 }
 
-function getResponse(
+const reservedStreamFailureEvent = "effect/httpapi/stream/failure"
+
+function getSuccessResponse(
   success: Schema.Top | ReadonlyArray<Schema.Top> | undefined,
+  method: HttpMethod,
   disableCodecs: boolean
 ): Set<Schema.Top> {
   if (success === undefined) return new Set()
-  const arr = Arr.ensure(success)
-  return new Set(disableCodecs ? arr : arr.map(transformResponse))
+  const schemas = Arr.ensure(success)
+  validateSuccessResponse(schemas, method)
+  return new Set(
+    disableCodecs ?
+      schemas :
+      schemas.map((schema) => HttpApiSchema.isStreamSchema(schema) ? schema : transformResponse(schema))
+  )
+}
+
+function getErrorResponse(
+  error: Schema.Top | ReadonlyArray<Schema.Top> | undefined,
+  disableCodecs: boolean
+): Set<Schema.Top> {
+  if (error === undefined) return new Set()
+  const schemas = Arr.ensure(error)
+  for (const schema of schemas) {
+    if (HttpApiSchema.isStreamSchema(schema)) {
+      throw new Error("Streaming schemas are not supported in error responses")
+    }
+  }
+  return new Set(disableCodecs ? schemas : schemas.map(transformResponse))
+}
+
+function validateSuccessResponse(schemas: ReadonlyArray<Schema.Top>, method: HttpMethod) {
+  const statuses = new Map<number, {
+    readonly stream?: HttpApiSchema.StreamSchema | undefined
+    bufferedContentTypes: Set<string>
+    noContent: boolean
+  }>()
+
+  for (const schema of schemas) {
+    if (HttpApiSchema.isStreamSchema(schema)) {
+      validateStreamSuccess(schema, method)
+      const status = HttpApiSchema.getStatusStream(schema)
+      const entry = getStatusEntry(statuses, status)
+      if (entry.stream !== undefined) {
+        throw new Error(`Multiple streaming success responses for status: ${status}`)
+      }
+      if (entry.noContent) {
+        throw new Error(`Cannot combine no-content and streaming success responses for status: ${status}`)
+      }
+      if (entry.bufferedContentTypes.has(normalizeResponseContentType(schema.contentType))) {
+        throw new Error(
+          `Cannot combine buffered and streaming success responses for status ${status} and content-type: ${schema.contentType}`
+        )
+      }
+      statuses.set(status, { ...entry, stream: schema })
+    } else {
+      const status = HttpApiSchema.getStatusSuccess(schema.ast)
+      const entry = getStatusEntry(statuses, status)
+      const noContent = HttpApiSchema.isNoContent(schema.ast)
+      if (entry.stream !== undefined) {
+        if (noContent) {
+          throw new Error(`Cannot combine no-content and streaming success responses for status: ${status}`)
+        }
+        const encoding = HttpApiSchema.getResponseEncoding(schema.ast)
+        if (
+          normalizeResponseContentType(encoding.contentType) === normalizeResponseContentType(entry.stream.contentType)
+        ) {
+          throw new Error(
+            `Cannot combine buffered and streaming success responses for status ${status} and content-type: ${encoding.contentType}`
+          )
+        }
+      }
+      if (!noContent) {
+        entry.bufferedContentTypes.add(
+          normalizeResponseContentType(HttpApiSchema.getResponseEncoding(schema.ast).contentType)
+        )
+      }
+      entry.noContent = entry.noContent || noContent
+    }
+  }
+}
+
+function normalizeResponseContentType(contentType: string): string {
+  const normalized = contentType.toLowerCase().trim()
+  const index = normalized.indexOf(";")
+  return index === -1 ? normalized : normalized.slice(0, index).trim()
+}
+
+function getStatusEntry(
+  statuses: Map<number, {
+    readonly stream?: HttpApiSchema.StreamSchema | undefined
+    bufferedContentTypes: Set<string>
+    noContent: boolean
+  }>,
+  status: number
+) {
+  let entry = statuses.get(status)
+  if (entry === undefined) {
+    entry = { bufferedContentTypes: new Set(), noContent: false }
+    statuses.set(status, entry)
+  }
+  return entry
+}
+
+function validateStreamSuccess(schema: HttpApiSchema.StreamSchema, method: HttpMethod) {
+  if (method === "HEAD") {
+    throw new Error("HEAD endpoints cannot declare streaming success responses")
+  }
+  if (HttpApiSchema.isStreamSse(schema) && hasReservedSseEventName(schema.events.ast)) {
+    throw new Error(`SSE event name is reserved: ${reservedStreamFailureEvent}`)
+  }
+}
+
+function hasReservedSseEventName(ast: AST.AST): boolean {
+  return hasReservedEventName(AST.toEncoded(ast), new Set())
+}
+
+function hasReservedEventName(ast: AST.AST, seen: Set<AST.AST>): boolean {
+  if (seen.has(ast)) return false
+  seen.add(ast)
+  if (AST.isUnion(ast)) {
+    return ast.types.some((type) => hasReservedEventName(type, seen))
+  }
+  if (AST.isSuspend(ast)) {
+    return hasReservedEventName(ast.thunk(), seen)
+  }
+  if (!AST.isObjects(ast)) return false
+  const event = ast.propertySignatures.find((ps) => ps.name === "event")
+  return event !== undefined && hasReservedEventLiteral(event.type, seen)
+}
+
+function hasReservedEventLiteral(ast: AST.AST, seen: Set<AST.AST>): boolean {
+  if (seen.has(ast)) return false
+  seen.add(ast)
+  const encoded = AST.toEncoded(ast)
+  if (encoded !== ast) {
+    return hasReservedEventLiteral(encoded, seen)
+  }
+  if (AST.isLiteral(ast)) {
+    return ast.literal === reservedStreamFailureEvent
+  }
+  if (AST.isUnion(ast)) {
+    return ast.types.some((type) => hasReservedEventLiteral(type, seen))
+  }
+  if (AST.isSuspend(ast)) {
+    return hasReservedEventLiteral(ast.thunk(), seen)
+  }
+  return false
 }
 
 function transformResponse(schema: Schema.Top): Schema.Top {

package/src/unstable/httpapi/HttpApiGroup.ts

@@ -57,7 +57,7 @@ export interface HttpApiGroup<
   /**
    * Add an `HttpApiEndpoint` to an `HttpApiGroup`.
    */
-  add<A extends NonEmptyReadonlyArray<HttpApiEndpoint.Any>>(
+  add<const A extends NonEmptyReadonlyArray<HttpApiEndpoint.Any>>(
     ...endpoints: A
   ): HttpApiGroup<Id, Endpoints | A[number], TopLevel>