effect 4.0.0-beta.84 → 4.0.0-beta.86

package/src/unstable/cli/internal/ansi.ts

@@ -51,54 +51,21 @@ export const eraseLine = `${ESC}2K`
 /** @internal */
 export const beep = BEL
 
-/** @internal */
-export const black = `${ESC}30m`
-
 /** @internal */
 export const red = `${ESC}31m`
 
 /** @internal */
 export const green = `${ESC}32m`
 
-/** @internal */
-export const yellow = `${ESC}33m`
-
-/** @internal */
-export const blue = `${ESC}34m`
-
-/** @internal */
-export const magenta = `${ESC}35m`
-
-/** @internal */
-export const cyan = `${ESC}36m`
-
 /** @internal */
 export const white = `${ESC}37m`
 
 /** @internal */
 export const blackBright = `${ESC}90m`
 
-/** @internal */
-export const redBright = `${ESC}91m`
-
-/** @internal */
-export const greenBright = `${ESC}92m`
-
-/** @internal */
-export const yellowBright = `${ESC}93m`
-
-/** @internal */
-export const blueBright = `${ESC}94m`
-
-/** @internal */
-export const magentaBright = `${ESC}95m`
-
 /** @internal */
 export const cyanBright = `${ESC}96m`
 
-/** @internal */
-export const whiteBright = `${ESC}97m`
-
 export const annotate = (text: string, ...styles: Array<string | Array<string>>) => {
   const flat = styles.flat()
   return `${flat.join("")}${text}${reset}`

package/src/unstable/cli/internal/config.ts

@@ -46,7 +46,6 @@
  * 1. Flat iteration over all params for parsing/validation
  * 2. Reconstruction of original nested shape for handler input
  */
-import * as Predicate from "../../../Predicate.ts"
 import * as Param from "../Param.ts"
 
 /* ========================================================================== */
@@ -105,13 +104,6 @@ export declare namespace ConfigInternal {
     | { readonly _tag: "Nested"; readonly tree: Tree }
 }
 
-/* ========================================================================== */
-/* Guards                                                                     */
-/* ========================================================================== */
-
-/** @internal */
-export const isConfigInternal = (u: unknown): u is ConfigInternal => Predicate.hasProperty(u, ConfigInternalTypeId)
-
 /* ========================================================================== */
 /* Parsing                                                                    */
 /* ========================================================================== */

package/src/unstable/cli/internal/parser.ts

@@ -27,7 +27,7 @@
 import * as Effect from "../../../Effect.ts"
 import * as Option from "../../../Option.ts"
 import * as CliError from "../CliError.ts"
-import type { Command, ParsedTokens } from "../Command.ts"
+import type { Command, Environment, ParsedTokens } from "../Command.ts"
 import * as Param from "../Param.ts"
 import * as Primitive from "../Primitive.ts"
 import { suggest } from "./auto-suggest.ts"
@@ -50,7 +50,7 @@ export const parseArgs = (
   lexResult: LexResult,
   command: Command.Any,
   commandPath: ReadonlyArray<string> = []
-): Effect.Effect<ParsedTokens, never, Param.Environment> =>
+): Effect.Effect<ParsedTokens, never, Environment> =>
   Effect.gen(function*() {
     const { tokens, trailingOperands: afterEndOfOptions } = lexResult
     const newCommandPath = [...commandPath, command.name]

package/src/unstable/cluster/MessageStorage.ts

@@ -1061,7 +1061,7 @@ export const layerMemory: Layer.Layer<
 
 const EnvelopeWithReply: Schema.Struct<
   {
-    readonly envelope: Schema.Decoder<Envelope.PartialRequest | Envelope.AckChunk | Envelope.Interrupt>
+    readonly envelope: Schema.ConstraintDecoder<Envelope.PartialRequest | Envelope.AckChunk | Envelope.Interrupt>
     readonly lastSentReply: Schema.Option<Schema.Codec<Reply.Encoded>>
   }
 > = Schema.Struct({

package/src/unstable/cluster/Reply.ts

@@ -234,7 +234,7 @@ export class Chunk<R extends Rpc.Any> extends Data.TaggedClass("Chunk")<{
    *
    * @since 4.0.0
    */
-  static schemaFrom<Success extends Schema.Top>(
+  static schemaFrom<Success extends Schema.Constraint>(
     success: Success
   ): Schema.declareConstructor<Chunk<Rpc.Any>, Chunk<Rpc.Any>, readonly [Success]> {
     // TODO: extract to a helper function
@@ -336,7 +336,11 @@ export class WithExit<R extends Rpc.Any> extends Data.TaggedClass("WithExit")<{
    *
    * @since 4.0.0
    */
-  static schemaFrom<Success extends Schema.Top, Error extends Schema.Top, Defect extends Schema.Top>(
+  static schemaFrom<
+    Success extends Schema.Constraint,
+    Error extends Schema.Constraint,
+    Defect extends Schema.Constraint
+  >(
     exitSchema: Schema.Exit<Success, Error, Defect>
   ): Schema.declareConstructor<
     WithExit<Rpc.Any>,

package/src/unstable/devtools/DevToolsSchema.ts

@@ -261,7 +261,7 @@ export const MetricLabel = Schema.Struct({
  */
 export type MetricLabel = Schema.Schema.Type<typeof MetricLabel>
 
-const metric = <Type extends string, State extends Schema.Top>(type: Type, state: State) =>
+const metric = <Type extends string, State extends Schema.Constraint>(type: Type, state: State) =>
   Schema.Struct({
     id: Schema.String,
     type: Schema.tag(type),

package/src/unstable/encoding/Msgpack.ts

@@ -101,7 +101,7 @@ export const encode = <IE = never, Done = unknown>(): Channel.Channel<
  * @category constructors
  * @since 4.0.0
  */
-export const encodeSchema = <S extends Schema.Top>(
+export const encodeSchema = <S extends Schema.Constraint>(
   schema: S
 ) =>
 <IE = never, Done = unknown>(): Channel.Channel<
@@ -181,7 +181,7 @@ export const decode = <IE = never, Done = unknown>(): Channel.Channel<
  * @category constructors
  * @since 4.0.0
  */
-export const decodeSchema = <S extends Schema.Top>(
+export const decodeSchema = <S extends Schema.Constraint>(
   schema: S
 ) =>
 <IE = never, Done = unknown>(): Channel.Channel<
@@ -256,7 +256,7 @@ export const duplexSchema: {
    * @category combinators
    * @since 4.0.0
    */
-  <In extends Schema.Top, Out extends Schema.Top>(
+  <In extends Schema.Constraint, Out extends Schema.Constraint>(
     options: {
       readonly inputSchema: In
       readonly outputSchema: Out
@@ -293,7 +293,7 @@ export const duplexSchema: {
    * @category combinators
    * @since 4.0.0
    */
-  <Out extends Schema.Top, In extends Schema.Top, OutErr, OutDone, InErr, InDone, R>(
+  <Out extends Schema.Constraint, In extends Schema.Constraint, OutErr, OutDone, InErr, InDone, R>(
     self: Channel.Channel<
       Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
       OutErr,
@@ -316,7 +316,7 @@ export const duplexSchema: {
     InDone,
     R | In["EncodingServices"] | Out["DecodingServices"]
   >
-} = dual(2, <Out extends Schema.Top, In extends Schema.Top, OutErr, OutDone, InErr, InDone, R>(
+} = dual(2, <Out extends Schema.Constraint, In extends Schema.Constraint, OutErr, OutDone, InErr, InDone, R>(
   self: Channel.Channel<
     Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
     OutErr,
@@ -351,7 +351,9 @@ export const duplexSchema: {
  * @category schemas
  * @since 4.0.0
  */
-export interface schema<S extends Schema.Top> extends Schema.decodeTo<S, Schema.instanceOf<Uint8Array<ArrayBuffer>>> {}
+export interface schema<S extends Schema.Constraint>
+  extends Schema.decodeTo<S, Schema.instanceOf<Uint8Array<ArrayBuffer>>>
+{}
 
 /**
  * Schema for decoding MessagePack bytes into values and encoding values back to
@@ -403,7 +405,7 @@ export const transformation: SchemaTransformation.Transformation<
  * @category schemas
  * @since 4.0.0
  */
-export const schema = <S extends Schema.Top>(schema: S): schema<S> =>
+export const schema = <S extends Schema.Constraint>(schema: S): schema<S> =>
   (Schema.Uint8Array as Schema.instanceOf<Uint8Array<ArrayBuffer>>).pipe(
     Schema.decodeTo(schema, transformation)
   )

package/src/unstable/encoding/Ndjson.ts

@@ -106,7 +106,7 @@ export const encode = <IE = never, Done = unknown>(): Channel.Channel<
  * @category constructors
  * @since 4.0.0
  */
-export const encodeSchema = <S extends Schema.Top>(
+export const encodeSchema = <S extends Schema.Constraint>(
   schema: S
 ) =>
 <IE = never, Done = unknown>(): Channel.Channel<
@@ -130,7 +130,7 @@ export const encodeSchema = <S extends Schema.Top>(
  * @category constructors
  * @since 4.0.0
  */
-export const encodeSchemaString = <S extends Schema.Top>(
+export const encodeSchemaString = <S extends Schema.Constraint>(
   schema: S
 ) =>
 <IE = never, Done = unknown>(): Channel.Channel<
@@ -222,7 +222,7 @@ export const decode = <IE = never, Done = unknown>(options?: {
  * @category constructors
  * @since 4.0.0
  */
-export const decodeSchema = <S extends Schema.Top>(
+export const decodeSchema = <S extends Schema.Constraint>(
   schema: S
 ) =>
 <IE = never, Done = unknown>(options?: {
@@ -248,7 +248,7 @@ export const decodeSchema = <S extends Schema.Top>(
  * @category constructors
  * @since 4.0.0
  */
-export const decodeSchemaString = <S extends Schema.Top>(
+export const decodeSchemaString = <S extends Schema.Constraint>(
   schema: S
 ) =>
 <IE = never, Done = unknown>(options?: {
@@ -500,7 +500,7 @@ export const duplexSchema: {
    * @category combinators
    * @since 4.0.0
    */
-  <In extends Schema.Top, Out extends Schema.Top>(
+  <In extends Schema.Constraint, Out extends Schema.Constraint>(
     options: {
       readonly inputSchema: In
       readonly outputSchema: Out
@@ -537,7 +537,7 @@ export const duplexSchema: {
    * @category combinators
    * @since 4.0.0
    */
-  <Out extends Schema.Top, In extends Schema.Top, OutErr, OutDone, InErr, InDone, R>(
+  <Out extends Schema.Constraint, In extends Schema.Constraint, OutErr, OutDone, InErr, InDone, R>(
     self: Channel.Channel<
       Arr.NonEmptyReadonlyArray<Uint8Array>,
       OutErr,
@@ -561,7 +561,7 @@ export const duplexSchema: {
     InDone,
     R | In["EncodingServices"] | Out["DecodingServices"]
   >
-} = dual(2, <Out extends Schema.Top, In extends Schema.Top, OutErr, OutDone, InErr, InDone, R>(
+} = dual(2, <Out extends Schema.Constraint, In extends Schema.Constraint, OutErr, OutDone, InErr, InDone, R>(
   self: Channel.Channel<
     Arr.NonEmptyReadonlyArray<Uint8Array>,
     OutErr,
@@ -611,7 +611,7 @@ export const duplexSchemaString: {
    * @category combinators
    * @since 4.0.0
    */
-  <In extends Schema.Top, Out extends Schema.Top>(
+  <In extends Schema.Constraint, Out extends Schema.Constraint>(
     options: {
       readonly inputSchema: In
       readonly outputSchema: Out
@@ -648,7 +648,7 @@ export const duplexSchemaString: {
    * @category combinators
    * @since 4.0.0
    */
-  <Out extends Schema.Top, In extends Schema.Top, OutErr, OutDone, InErr, InDone, R>(
+  <Out extends Schema.Constraint, In extends Schema.Constraint, OutErr, OutDone, InErr, InDone, R>(
     self: Channel.Channel<
       Arr.NonEmptyReadonlyArray<string>,
       OutErr,
@@ -672,7 +672,7 @@ export const duplexSchemaString: {
     InDone,
     R | In["EncodingServices"] | Out["DecodingServices"]
   >
-} = dual(2, <Out extends Schema.Top, In extends Schema.Top, OutErr, OutDone, InErr, InDone, R>(
+} = dual(2, <Out extends Schema.Constraint, In extends Schema.Constraint, OutErr, OutDone, InErr, InDone, R>(
   self: Channel.Channel<
     Arr.NonEmptyReadonlyArray<string>,
     OutErr,

package/src/unstable/encoding/Sse.ts

@@ -137,7 +137,7 @@ export const decodeSchema = <
  * @since 4.0.0
  */
 export const decodeDataSchema = <Type, DecodingServices, IE, Done>(
-  schema: Schema.Decoder<Type, DecodingServices>
+  schema: Schema.ConstraintDecoder<Type, DecodingServices>
 ): Channel.Channel<
   NonEmptyReadonlyArray<{
     readonly event: string

package/src/unstable/eventlog/Event.ts

@@ -404,9 +404,9 @@ export function make<
 export function make(options: {
   readonly tag: string
   readonly primaryKey: (payload: Schema.Schema.Type<Schema.Top>) => string
-  readonly payload?: Schema.Top | undefined
-  readonly success?: Schema.Top | undefined
-  readonly error?: Schema.Top | undefined
+  readonly payload?: Schema.Constraint | undefined
+  readonly success?: Schema.Constraint | undefined
+  readonly error?: Schema.Constraint | undefined
 }): Event<string, Schema.Top, Schema.Top, typeof Schema.Never> {
   const payload = options.payload ?? Schema.Void
   const success = options.success ?? Schema.Void

package/src/unstable/http/HttpBody.ts

@@ -317,7 +317,7 @@ export const json = (body: unknown, contentType?: string): Effect.Effect<Uint8Ar
  * @category constructors
  * @since 4.0.0
  */
-export const jsonSchema = <S extends Schema.Top>(
+export const jsonSchema = <S extends Schema.Constraint>(
   schema: S,
   options?: ParseOptions | undefined
 ) => {

package/src/unstable/http/HttpClientRequest.ts

@@ -974,7 +974,7 @@ export const bodyJsonUnsafe: {
  * @category combinators
  * @since 4.0.0
  */
-export const schemaBodyJson = <S extends Schema.Top>(
+export const schemaBodyJson = <S extends Schema.Constraint>(
   schema: S,
   options?: ParseOptions | undefined
 ): {

package/src/unstable/http/HttpIncomingMessage.ts

@@ -61,7 +61,7 @@ export interface HttpIncomingMessage<E = unknown> extends Inspectable.Inspectabl
  * @category schemas
  * @since 4.0.0
  */
-export const schemaBodyJson = <S extends Schema.Top>(schema: S, options?: ParseOptions | undefined) => {
+export const schemaBodyJson = <S extends Schema.Constraint>(schema: S, options?: ParseOptions | undefined) => {
   const decode = Schema.decodeEffect(Schema.toCodecJson(schema))
   return <E>(
     self: HttpIncomingMessage<E>

package/src/unstable/http/HttpMiddleware.ts

@@ -13,6 +13,7 @@
 import { Clock } from "../../Clock.ts"
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
+import * as Exit from "../../Exit.ts"
 import { constant, constFalse } from "../../Function.ts"
 import * as internalEffect from "../../internal/effect.ts"
 import * as Layer from "../../Layer.ts"
@@ -22,7 +23,7 @@ import type { ReadonlyRecord } from "../../Record.ts"
 import { TracerEnabled } from "../../References.ts"
 import { ParentSpan } from "../../Tracer.ts"
 import * as Headers from "./Headers.ts"
-import { causeResponseStripped, exitResponse } from "./HttpServerError.ts"
+import { causeResponseStripped } from "./HttpServerError.ts"
 import { HttpServerRequest } from "./HttpServerRequest.ts"
 import * as Request from "./HttpServerRequest.ts"
 import * as Response from "./HttpServerResponse.ts"
@@ -218,13 +219,21 @@ export const tracer: <E, R>(
         if (Option.isSome(request.remoteAddress)) {
           span.attribute("client.address", request.remoteAddress.value)
         }
-        const response = exitResponse(exit)
+        let response: HttpServerResponse
+        let spanExit = exit
+        if (Exit.isFailure(exit)) {
+          const [failureResponse, cause] = causeResponseStripped(exit.cause)
+          response = failureResponse
+          spanExit = Option.isSome(cause) ? Exit.failCause(cause.value) : Exit.succeed(response)
+        } else {
+          response = exit.value
+        }
         span.attribute("http.response.status_code", response.status)
         const responseHeaders = Headers.redact(response.headers, redactedHeaderNames)
         for (const name in responseHeaders) {
           span.attribute(`http.response.header.${name}`, String(responseHeaders[name]))
         }
-        span.end(endTime, exit)
+        span.end(endTime, spanExit)
       }, 0)
       return undefined
     }, true)

package/src/unstable/httpapi/HttpApi.ts

@@ -312,5 +312,5 @@ const extractResponseContent = (
  */
 export class AdditionalSchemas extends Context.Service<
   AdditionalSchemas,
-  ReadonlyArray<Schema.Top>
+  ReadonlyArray<Schema.Constraint>
 >()("effect/httpapi/HttpApi/AdditionalSchemas") {}

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -870,7 +870,7 @@ interface SseStreamEncoder {
   readonly encodeCause: (input: unknown) => Effect.Effect<string, Schema.SchemaError, unknown>
 }
 
-function makeSseEncoder<Events extends Sse.EventCodec, Error extends Schema.Top>(
+function makeSseEncoder<Events extends Sse.EventCodec, Error extends Schema.Constraint>(
   streamSchema: HttpApiSchema.StreamSse<Events, Error, unknown>
 ): SseStreamEncoder {
   const CauseSchema = Schema.toCodecJson(Schema.Cause(streamSchema.error, Schema.Defect()))
@@ -929,12 +929,16 @@ function makeSchemaError(issue: SchemaIssue.Issue): Schema.SchemaError {
 const toResponseSuccessSchema = toResponseSchema(HttpApiSchema.getStatusSuccess)
 const toResponseErrorSchema = toResponseSchema(HttpApiSchema.getStatusError)
 
-function makeSuccessSchema(endpoint: HttpApiEndpoint.AnyWithProps): Schema.Encoder<HttpServerResponse, unknown> {
+function makeSuccessSchema(
+  endpoint: HttpApiEndpoint.AnyWithProps
+): Schema.ConstraintEncoder<HttpServerResponse, unknown> {
   const schemas = HttpApiEndpoint.getSuccessSchemas(endpoint).map(toResponseSuccessSchema)
   return schemas.length === 1 ? schemas[0] : Schema.Union(schemas)
 }
 
-function makeErrorSchema(endpoint: HttpApiEndpoint.AnyWithProps): Schema.Encoder<HttpServerResponse, unknown> {
+function makeErrorSchema(
+  endpoint: HttpApiEndpoint.AnyWithProps
+): Schema.ConstraintEncoder<HttpServerResponse, unknown> {
   const schemas = HttpApiEndpoint.getErrorSchemas(endpoint).map(toResponseErrorSchema)
   if (schemas.length === 0) return Schema.Never
   return schemas.length === 1 ? schemas[0] : Schema.Union(schemas)
@@ -943,7 +947,7 @@ function makeErrorSchema(endpoint: HttpApiEndpoint.AnyWithProps): Schema.Encoder
 function toResponseSchema(getStatus: (ast: SchemaAST.AST) => number) {
   const cache = new WeakMap<SchemaAST.AST, Schema.Top>()
 
-  return (schema: Schema.Top): Schema.Encoder<HttpServerResponse, unknown> => {
+  return (schema: Schema.Constraint): Schema.ConstraintEncoder<HttpServerResponse, unknown> => {
     const cached = cache.get(schema.ast)
     if (cached !== undefined) {
       return cached as any
@@ -958,7 +962,7 @@ function toResponseSchema(getStatus: (ast: SchemaAST.AST) => number) {
 
 function getResponseTransformation(
   getStatus: (ast: SchemaAST.AST) => number,
-  schema: Schema.Top
+  schema: Schema.Constraint
 ): SchemaTransformation.Transformation<unknown, Response.HttpServerResponse> {
   const ast = schema.ast
   const encode = getResponseEncode(

package/src/unstable/httpapi/HttpApiClient.ts

@@ -80,7 +80,7 @@ type SuccessType<S> = S extends HttpApiSchema.StreamSse<
     never
   >
   : S extends HttpApiSchema.StreamUint8Array ? Stream.Stream<Uint8Array, HttpClientError.HttpClientError, never>
-  : S extends Schema.Top ? S["Type"]
+  : S extends Schema.Constraint ? S["Type"]
   : never
 
 type SuccessDecodingServices<S> = S extends HttpApiSchema.StreamSse<
@@ -91,7 +91,7 @@ type SuccessDecodingServices<S> = S extends HttpApiSchema.StreamSse<
     | _Events["DecodingServices"]
     | _Error["DecodingServices"]
   : S extends HttpApiSchema.StreamUint8Array ? never
-  : S extends Schema.Top ? S["DecodingServices"]
+  : S extends Schema.Constraint ? S["DecodingServices"]
   : never
 
 /**
@@ -636,10 +636,10 @@ export const urlBuilder = <Api extends HttpApi.Any>(api: Api, options?: {
       const makeUrl = compilePath(endpoint.path)
       const encodeParams = endpoint.params === undefined
         ? undefined
-        : Schema.encodeSync(endpoint.params as Schema.Encoder<unknown>)
+        : Schema.encodeSync(endpoint.params as Schema.Codec<unknown, unknown>)
       const encodeQuery = endpoint.query === undefined
         ? undefined
-        : Schema.encodeSync(endpoint.query as Schema.Encoder<unknown>)
+        : Schema.encodeSync(endpoint.query as Schema.Codec<unknown, unknown>)
 
       const endpointBuilder = (request?: {
         readonly params?: unknown
@@ -687,7 +687,7 @@ const compilePath = (path: string) => {
   }
 }
 
-function schemasToResponse(schemas: readonly [Schema.Top, ...Array<Schema.Top>]) {
+function schemasToResponse(schemas: readonly [Schema.Constraint, ...Array<Schema.Constraint>]) {
   const codec = toCodecArrayBuffer(schemas)
   const decode = Schema.decodeEffect(codec)
   return (response: HttpClientResponse.HttpClientResponse) => Effect.flatMap(response.arrayBuffer, decode)
@@ -795,7 +795,7 @@ function streamToResponse(streamSchema: HttpApiSchema.StreamSchema) {
 
 function decodeSseStream(
   stream: Stream.Stream<Uint8Array, HttpClientError.HttpClientError>,
-  declaration: HttpApiSchema.StreamSse<Sse.EventCodec, Schema.Top, unknown>
+  declaration: HttpApiSchema.StreamSse<Sse.EventCodec, Schema.Constraint, unknown>
 ): Stream.Stream<unknown, unknown, unknown> {
   const Event = Schema.Union([
     declaration.events,
@@ -893,10 +893,10 @@ const UnknownFromArrayBuffer = StringFromArrayBuffer.pipe(Schema.decodeTo(
   ])
 ))
 
-function toCodecArrayBuffer(schemas: readonly [Schema.Top, ...Array<Schema.Top>]): Schema.Top {
+function toCodecArrayBuffer(schemas: readonly [Schema.Constraint, ...Array<Schema.Constraint>]): Schema.Top {
   return Schema.Union(schemas.map(onSchema))
 
-  function onSchema(schema: Schema.Top) {
+  function onSchema(schema: Schema.Constraint) {
     const encoding = HttpApiSchema.getResponseEncoding(schema.ast)
     switch (encoding._tag) {
       case "Json": {
@@ -938,7 +938,7 @@ const statusOrElse = (response: HttpClientResponse.HttpClientResponse) =>
 const $HttpBody = Schema.declare(HttpBody.isHttpBody)
 
 function getEncodePayloadSchema(
-  schemas: readonly [Schema.Top, ...Array<Schema.Top>],
+  schemas: readonly [Schema.Constraint, ...Array<Schema.Constraint>],
   method: HttpMethod.HttpMethod
 ): Schema.Top {
   return Schema.Union(schemas.map((s) => getEncodePayloadSchemaFromBody(s, method)))
@@ -947,7 +947,7 @@ function getEncodePayloadSchema(
 const bodyFromPayloadCache = new WeakMap<SchemaAST.AST, Schema.Top>()
 
 function getEncodePayloadSchemaFromBody(
-  schema: Schema.Top,
+  schema: Schema.Constraint,
   method: HttpMethod.HttpMethod
 ): Schema.Top {
   const ast = schema.ast