effect-start 0.34.0 → 0.35.0

package/src/RouteSchema.ts

@@ -2,6 +2,7 @@ import * as Effect from "effect/Effect"
 import type * as ParseResult from "effect/ParseResult"
 import * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
+import type * as Types from "effect/Types"
 import * as Entity from "./Entity.ts"
 import * as Http from "./_Http.ts"
 import * as PathPattern from "./_PathPattern.ts"
@@ -26,50 +27,113 @@ export const File = Schema.TaggedStruct("File", {
   content: Schema.Uint8ArrayFromSelf,
 })
 
+type SchemaOrFields = Schema.Schema.All | Schema.Struct.Fields
+
+function toSchema(input: SchemaOrFields): Schema.Schema<any, any, any> {
+  return (Schema.isSchema(input) ? input : Schema.Struct(input as any)) as any
+}
+
+function makeSchemaFilter(
+  handler: (ctx: any, decode: (input: unknown) => Effect.Effect<any, any, any>) => Effect.Effect<any, any, any>,
+) {
+  return (fields: SchemaOrFields): any => {
+    const decode = Schema.decodeUnknown(toSchema(fields))
+    return RouteHook.filter((ctx: any) => handler(ctx, decode))
+  }
+}
+
+export function schemaHeaders<F extends Schema.Struct.Fields>(
+  fields: F,
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
+  D,
+  SB,
+  [
+    ...P,
+    Route.Route<
+      {},
+      { headers: Types.Simplify<Schema.Struct.Type<F>> },
+      unknown,
+      ParseResult.ParseError,
+      Schema.Struct.Context<F> | Route.Request
+    >,
+  ]
+>
 export function schemaHeaders<A, I extends Readonly<Record<string, string | undefined>>, R>(
   fields: Schema.Schema<A, I, R>,
 ): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
-  self: Route.RouteSet.RouteSet<D, SB, P>,
-) => Route.RouteSet.RouteSet<
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
   D,
   SB,
-  [...P, Route.Route.Route<{}, { headers: A }, unknown, ParseResult.ParseError, R>]
-> {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx: { request: Request; headers?: {} }) =>
-    Effect.map(decode(Http.mapHeaders(ctx.request.headers)), (parsed) => ({
-      context: {
-        headers: {
-          ...ctx.headers,
-          ...parsed,
-        },
-      },
-    })),
-  )
+  [...P, Route.Route<{}, { headers: A }, unknown, ParseResult.ParseError, R | Route.Request>]
+>
+export function schemaHeaders(fields: SchemaOrFields) {
+  return makeSchemaFilter((ctx, decode) =>
+    Effect.gen(function* () {
+      const request = yield* Route.Request
+      const parsed = yield* decode(Http.mapHeaders(request.headers))
+      return { context: { headers: { ...ctx.headers, ...parsed } } }
+    }),
+  )(fields)
 }
 
+export function schemaCookies<F extends Schema.Struct.Fields>(
+  fields: F,
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
+  D,
+  SB,
+  [
+    ...P,
+    Route.Route<
+      {},
+      { cookies: Types.Simplify<Schema.Struct.Type<F>> },
+      unknown,
+      ParseResult.ParseError,
+      Schema.Struct.Context<F> | Route.Request
+    >,
+  ]
+>
 export function schemaCookies<A, I extends Readonly<Record<string, string | undefined>>, R>(
   fields: Schema.Schema<A, I, R>,
 ): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
-  self: Route.RouteSet.RouteSet<D, SB, P>,
-) => Route.RouteSet.RouteSet<
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
   D,
   SB,
-  [...P, Route.Route.Route<{}, { cookies: A }, unknown, ParseResult.ParseError, R>]
-> {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx: { request: Request; cookies?: {} }) =>
-    Effect.map(decode(Http.parseCookies(ctx.request.headers.get("cookie"))), (parsed) => ({
-      context: {
-        cookies: {
-          ...ctx.cookies,
-          ...parsed,
-        },
-      },
-    })),
-  )
+  [...P, Route.Route<{}, { cookies: A }, unknown, ParseResult.ParseError, R | Route.Request>]
+>
+export function schemaCookies(fields: SchemaOrFields) {
+  return makeSchemaFilter((ctx, decode) =>
+    Effect.gen(function* () {
+      const request = yield* Route.Request
+      const parsed = yield* decode(Http.parseCookies(request.headers.get("cookie")))
+      return { context: { cookies: { ...ctx.cookies, ...parsed } } }
+    }),
+  )(fields)
 }
 
+export function schemaSearchParams<F extends Schema.Struct.Fields>(
+  fields: F,
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
+  D,
+  SB,
+  [
+    ...P,
+    Route.Route<
+      {},
+      { searchParams: Types.Simplify<Schema.Struct.Type<F>> },
+      unknown,
+      ParseResult.ParseError,
+      Schema.Struct.Context<F> | Route.Request
+    >,
+  ]
+>
 export function schemaSearchParams<
   A,
   I extends Readonly<Record<string, string | ReadonlyArray<string> | undefined>>,
@@ -77,80 +141,122 @@ export function schemaSearchParams<
 >(
   fields: Schema.Schema<A, I, R>,
 ): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
-  self: Route.RouteSet.RouteSet<D, SB, P>,
-) => Route.RouteSet.RouteSet<
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
   D,
   SB,
-  [...P, Route.Route.Route<{}, { searchParams: A }, unknown, ParseResult.ParseError, R>]
-> {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx: { request: Request; searchParams?: {} }) => {
-    const url = new URL(ctx.request.url)
-    return Effect.map(decode(Http.mapUrlSearchParams(url.searchParams)), (parsed) => ({
-      context: {
-        searchParams: {
-          ...ctx.searchParams,
-          ...parsed,
-        },
-      },
-    }))
-  })
+  [...P, Route.Route<{}, { searchParams: A }, unknown, ParseResult.ParseError, R | Route.Request>]
+>
+export function schemaSearchParams(fields: SchemaOrFields) {
+  return makeSchemaFilter((ctx, decode) =>
+    Effect.gen(function* () {
+      const request = yield* Route.Request
+      const url = new URL(request.url)
+      const parsed = yield* decode(Http.mapUrlSearchParams(url.searchParams))
+      return { context: { searchParams: { ...ctx.searchParams, ...parsed } } }
+    }),
+  )(fields)
 }
 
+export function schemaPathParams<F extends Schema.Struct.Fields>(
+  fields: F,
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
+  D,
+  SB,
+  [
+    ...P,
+    Route.Route<
+      {},
+      { pathParams: Types.Simplify<Schema.Struct.Type<F>> },
+      unknown,
+      ParseResult.ParseError,
+      Schema.Struct.Context<F> | Route.Request
+    >,
+  ]
+>
 export function schemaPathParams<A, I extends Readonly<Record<string, string | undefined>>, R>(
   fields: Schema.Schema<A, I, R>,
 ): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
-  self: Route.RouteSet.RouteSet<D, SB, P>,
-) => Route.RouteSet.RouteSet<
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
   D,
   SB,
-  [...P, Route.Route.Route<{}, { pathParams: A }, unknown, ParseResult.ParseError, R>]
-> {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx: { request: Request; path?: string; pathParams?: {} }) => {
-    const url = new URL(ctx.request.url)
-    const pattern = ctx.path ?? "/"
-    const params = PathPattern.match(pattern, url.pathname) ?? {}
-    return Effect.map(decode(params), (parsed) => ({
-      context: {
-        pathParams: {
-          ...ctx.pathParams,
-          ...parsed,
-        },
-      },
-    }))
-  })
+  [...P, Route.Route<{}, { pathParams: A }, unknown, ParseResult.ParseError, R | Route.Request>]
+>
+export function schemaPathParams(fields: SchemaOrFields) {
+  return makeSchemaFilter((ctx, decode) =>
+    Effect.gen(function* () {
+      const request = yield* Route.Request
+      const url = new URL(request.url)
+      const pattern = ctx.path ?? "/"
+      const params = PathPattern.match(pattern, url.pathname) ?? {}
+      const parsed = yield* decode(params)
+      return { context: { pathParams: { ...ctx.pathParams, ...parsed } } }
+    }),
+  )(fields)
 }
 
+export function schemaBodyJson<F extends Schema.Struct.Fields>(
+  fields: F,
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
+  D,
+  SB,
+  [
+    ...P,
+    Route.Route<
+      {},
+      { body: Types.Simplify<Schema.Struct.Type<F>> },
+      unknown,
+      RequestBodyError | ParseResult.ParseError,
+      Schema.Struct.Context<F> | Route.Request
+    >,
+  ]
+>
 export function schemaBodyJson<A, I, R>(
   fields: Schema.Schema<A, I, R>,
 ): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
-  self: Route.RouteSet.RouteSet<D, SB, P>,
-) => Route.RouteSet.RouteSet<
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
   D,
   SB,
-  [...P, Route.Route.Route<{}, { body: A }, unknown, RequestBodyError | ParseResult.ParseError, R>]
-> {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx: { request: Request; body?: {} }) =>
+  [...P, Route.Route<{}, { body: A }, unknown, RequestBodyError | ParseResult.ParseError, R | Route.Request>]
+>
+export function schemaBodyJson(fields: SchemaOrFields) {
+  return makeSchemaFilter((ctx, decode) =>
     Effect.gen(function* () {
+      const request = yield* Route.Request
       const json = yield* Effect.tryPromise({
-        try: () => ctx.request.json(),
+        try: () => request.json(),
         catch: (error) => RequestBodyError("JsonError", error),
       })
       const parsed = yield* decode(json)
-      return {
-        context: {
-          body: {
-            ...ctx.body,
-            ...parsed,
-          },
-        },
-      }
+      return { context: { body: { ...ctx.body, ...parsed } } }
     }),
-  )
+  )(fields)
 }
 
+export function schemaBodyUrlParams<F extends Schema.Struct.Fields>(
+  fields: F,
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
+  D,
+  SB,
+  [
+    ...P,
+    Route.Route<
+      {},
+      { body: Types.Simplify<Schema.Struct.Type<F>> },
+      unknown,
+      RequestBodyError | ParseResult.ParseError,
+      Schema.Struct.Context<F> | Route.Request
+    >,
+  ]
+>
 export function schemaBodyUrlParams<
   A,
   I extends Readonly<Record<string, string | ReadonlyArray<string> | undefined>>,
@@ -158,33 +264,45 @@ export function schemaBodyUrlParams<
 >(
   fields: Schema.Schema<A, I, R>,
 ): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
-  self: Route.RouteSet.RouteSet<D, SB, P>,
-) => Route.RouteSet.RouteSet<
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
   D,
   SB,
-  [...P, Route.Route.Route<{}, { body: A }, unknown, RequestBodyError | ParseResult.ParseError, R>]
-> {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx: { request: Request; body?: {} }) =>
+  [...P, Route.Route<{}, { body: A }, unknown, RequestBodyError | ParseResult.ParseError, R | Route.Request>]
+>
+export function schemaBodyUrlParams(fields: SchemaOrFields) {
+  return makeSchemaFilter((ctx, decode) =>
     Effect.gen(function* () {
+      const request = yield* Route.Request
       const text = yield* Effect.tryPromise({
-        try: () => ctx.request.text(),
+        try: () => request.text(),
         catch: (error) => RequestBodyError("UrlParamsError", error),
       })
       const params = new URLSearchParams(text)
       const parsed = yield* decode(Http.mapUrlSearchParams(params))
-      return {
-        context: {
-          body: {
-            ...ctx.body,
-            ...parsed,
-          },
-        },
-      }
+      return { context: { body: { ...ctx.body, ...parsed } } }
     }),
-  )
+  )(fields)
 }
 
+export function schemaBodyMultipart<F extends Schema.Struct.Fields>(
+  fields: F,
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
+  D,
+  SB,
+  [
+    ...P,
+    Route.Route<
+      {},
+      { body: Types.Simplify<Schema.Struct.Type<F>> },
+      unknown,
+      RequestBodyError | ParseResult.ParseError,
+      Schema.Struct.Context<F> | Route.Request | Scope.Scope
+    >,
+  ]
+>
 export function schemaBodyMultipart<
   A,
   I extends Partial<Record<string, ReadonlyArray<Http.FilePart> | ReadonlyArray<string> | string>>,
@@ -192,41 +310,53 @@ export function schemaBodyMultipart<
 >(
   fields: Schema.Schema<A, I, R>,
 ): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
-  self: Route.RouteSet.RouteSet<D, SB, P>,
-) => Route.RouteSet.RouteSet<
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
   D,
   SB,
   [
     ...P,
-    Route.Route.Route<
+    Route.Route<
       {},
       { body: A },
       unknown,
       RequestBodyError | ParseResult.ParseError,
-      R | Scope.Scope
+      R | Route.Request | Scope.Scope
     >,
   ]
-> {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx: { request: Request; body?: {} }) =>
+>
+export function schemaBodyMultipart(fields: SchemaOrFields) {
+  return makeSchemaFilter((ctx, decode) =>
     Effect.gen(function* () {
+      const request = yield* Route.Request
       const record = yield* Effect.tryPromise({
-        try: () => Http.parseFormData(ctx.request),
+        try: () => Http.parseFormData(request),
         catch: (error) => RequestBodyError("MultipartError", error),
       })
       const parsed = yield* decode(record)
-      return {
-        context: {
-          body: {
-            ...ctx.body,
-            ...parsed,
-          },
-        },
-      }
+      return { context: { body: { ...ctx.body, ...parsed } } }
     }),
-  )
+  )(fields)
 }
 
+export function schemaBodyForm<F extends Schema.Struct.Fields>(
+  fields: F,
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
+  D,
+  SB,
+  [
+    ...P,
+    Route.Route<
+      {},
+      { body: Types.Simplify<Schema.Struct.Type<F>> },
+      unknown,
+      RequestBodyError | ParseResult.ParseError,
+      Schema.Struct.Context<F> | Route.Request | Scope.Scope
+    >,
+  ]
+>
 export function schemaBodyForm<
   A,
   I extends Partial<Record<string, ReadonlyArray<Http.FilePart> | ReadonlyArray<string> | string>>,
@@ -234,59 +364,46 @@ export function schemaBodyForm<
 >(
   fields: Schema.Schema<A, I, R>,
 ): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
-  self: Route.RouteSet.RouteSet<D, SB, P>,
-) => Route.RouteSet.RouteSet<
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
   D,
   SB,
   [
     ...P,
-    Route.Route.Route<
+    Route.Route<
       {},
       { body: A },
       unknown,
       RequestBodyError | ParseResult.ParseError,
-      R | Scope.Scope
+      R | Route.Request | Scope.Scope
     >,
   ]
-> {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx: { request: Request; body?: {} }) =>
+>
+export function schemaBodyForm(fields: SchemaOrFields) {
+  return makeSchemaFilter((ctx, decode) =>
     Effect.gen(function* () {
-      const contentType = ctx.request.headers.get("content-type") ?? ""
+      const request = yield* Route.Request
+      const contentType = request.headers.get("content-type") ?? ""
 
       if (contentType.includes("application/x-www-form-urlencoded")) {
         const text = yield* Effect.tryPromise({
-          try: () => ctx.request.text(),
+          try: () => request.text(),
           catch: (error) => RequestBodyError("UrlParamsError", error),
         })
         const params = new URLSearchParams(text)
         const record = Http.mapUrlSearchParams(params)
-        const parsed = yield* decode(record as I)
-        return {
-          context: {
-            body: {
-              ...ctx.body,
-              ...parsed,
-            },
-          },
-        }
+        const parsed = yield* decode(record as any)
+        return { context: { body: { ...ctx.body, ...parsed } } }
       }
 
       const record = yield* Effect.tryPromise({
-        try: () => Http.parseFormData(ctx.request),
+        try: () => Http.parseFormData(request),
         catch: (error) => RequestBodyError("FormDataError", error),
       })
-      const parsed = yield* decode(record as I)
-      return {
-        context: {
-          body: {
-            ...ctx.body,
-            ...parsed,
-          },
-        },
-      }
+      const parsed = yield* decode(record as any)
+      return { context: { body: { ...ctx.body, ...parsed } } }
     }),
-  )
+  )(fields)
 }
 
 /**
@@ -303,20 +420,20 @@ export function schemaBodyForm<
 export function schemaError<A, I, R>(
   schema: Schema.Schema<A, I, R> & { readonly status: number },
 ): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
-  self: Route.RouteSet.RouteSet<D, SB, P>,
-) => Route.RouteSet.RouteSet<D, SB, [...P, Route.Route.Route<{}, {}, unknown, never, R>]>
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<D, SB, [...P, Route.Route<{}, {}, unknown, never, R>]>
 export function schemaError<A, I, R>(
   schema: Schema.Schema<A, I, R>,
   options: { readonly status: number },
 ): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
-  self: Route.RouteSet.RouteSet<D, SB, P>,
-) => Route.RouteSet.RouteSet<D, SB, [...P, Route.Route.Route<{}, {}, unknown, never, R>]>
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<D, SB, [...P, Route.Route<{}, {}, unknown, never, R>]>
 export function schemaError<A, I, R>(
   schema: Schema.Schema<A, I, R> & { readonly status?: number },
   options?: { readonly status: number },
 ): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
-  self: Route.RouteSet.RouteSet<D, SB, P>,
-) => Route.RouteSet.RouteSet<D, SB, [...P, Route.Route.Route<{}, {}, unknown, never, R>]> {
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<D, SB, [...P, Route.Route<{}, {}, unknown, never, R>]> {
   const status = options?.status ?? (schema as any).status
   if (typeof status !== "number") {
     throw new Error(
@@ -326,8 +443,8 @@ export function schemaError<A, I, R>(
   const encode = Schema.encode(schema)
   const is = Schema.is(schema)
   return function <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
-    self: Route.RouteSet.RouteSet<D, SB, P>,
-  ): Route.RouteSet.RouteSet<D, SB, [...P, Route.Route.Route<{}, {}, unknown, never, R>]> {
+    self: Route.RouteSet<D, SB, P>,
+  ): Route.RouteSet<D, SB, [...P, Route.Route<{}, {}, unknown, never, R>]> {
     const route = Route.make<{}, {}, unknown, never, R>((_context, next) =>
       Entity.resolve(next()).pipe(
         Effect.catchIf(is, (error) =>
@@ -336,7 +453,7 @@ export function schemaError<A, I, R>(
       ),
     )
 
-    const items: [...P, Route.Route.Route<{}, {}, unknown, never, R>] = [
+    const items: [...P, Route.Route<{}, {}, unknown, never, R>] = [
       ...Route.items(self),
       route,
     ]
@@ -345,24 +462,40 @@ export function schemaError<A, I, R>(
   }
 }
 
+export function schemaSuccess<F extends Schema.Struct.Fields>(
+  fields: F,
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
+  D,
+  SB,
+  [
+    ...P,
+    Route.Route<
+      {},
+      {},
+      Types.Simplify<Schema.Struct.Encoded<F>>,
+      ParseResult.ParseError,
+      Schema.Struct.Context<F>
+    >,
+  ]
+>
 export function schemaSuccess<A, I, R>(
   schema: Schema.Schema<A, I, R>,
 ): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
-  self: Route.RouteSet.RouteSet<D, SB, P>,
-) => Route.RouteSet.RouteSet<
+  self: Route.RouteSet<D, SB, P>,
+) => Route.RouteSet<
   D,
   SB,
-  [...P, Route.Route.Route<{}, {}, I, ParseResult.ParseError, R>]
-> {
-  const encode = Schema.encodeUnknown(schema)
-  return function <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
-    self: Route.RouteSet.RouteSet<D, SB, P>,
-  ): Route.RouteSet.RouteSet<
-    D,
-    SB,
-    [...P, Route.Route.Route<{}, {}, I, ParseResult.ParseError, R>]
-  > {
-    const route = Route.make<{}, {}, I, ParseResult.ParseError, R>((_context, next) =>
+  [...P, Route.Route<{}, {}, I, ParseResult.ParseError, R>]
+>
+export function schemaSuccess(
+  schema: SchemaOrFields,
+): any {
+  const s = toSchema(schema)
+  const encode = Schema.encodeUnknown(s)
+  return function(self: Route.RouteSet<any, any, any>) {
+    const route = Route.make((_context: any, next: any) =>
       Effect.flatMap(Entity.resolve(next()), (entity) =>
         Effect.map(encode(entity.body), (encoded) =>
           Entity.make(encoded, {
@@ -374,11 +507,11 @@ export function schemaSuccess<A, I, R>(
       ),
     )
 
-    const items: [...P, Route.Route.Route<{}, {}, I, ParseResult.ParseError, R>] = [
+    const items = [
       ...Route.items(self),
       route,
     ]
 
-    return Route.set(items, Route.descriptor(self))
+    return Route.set(items as any, Route.descriptor(self))
   }
 }

package/src/RouteSse.ts

@@ -65,7 +65,7 @@ export function sse<
   E = never,
   R = never,
 >(handler: SseHandlerInput<NoInfer<D & B & Route.ExtractBindings<I> & { format: "sse" }>, E, R>) {
-  return function (self: Route.RouteSet.RouteSet<D, B, I>) {
+  return function (self: Route.RouteSet<D, B, I>) {
     const sseHandler: Route.Route.Handler<
       D & B & Route.ExtractBindings<I> & { format: "sse" },
       Stream.Stream<string, E, R>,
@@ -120,13 +120,13 @@ export function sse<
 
     const items: [
       ...I,
-      Route.Route.Route<{ format: "sse" }, {}, Stream.Stream<string, E, R>, E, R>,
+      Route.Route<{ format: "sse" }, {}, Stream.Stream<string, E, R>, E, R>,
     ] = [...Route.items(self), route]
 
     return Route.set<
       D,
       B,
-      [...I, Route.Route.Route<{ format: "sse" }, {}, Stream.Stream<string, E, R>, E, R>]
+      [...I, Route.Route<{ format: "sse" }, {}, Stream.Stream<string, E, R>, E, R>]
     >(items, Route.descriptor(self))
   }
 }

package/src/Start.ts

@@ -141,7 +141,7 @@ export function build<const Layers extends readonly [Layer.Layer.Any, ...Array<L
               map.delete(layer)
               return map
             })
-            if (Cause.isDie(exit.cause) || Cause.isInterruptedOnly(exit.cause)) {
+            if (Cause.isInterruptedOnly(exit.cause)) {
               return yield* exit
             }
           }