effect 4.0.0-beta.30 → 4.0.0-beta.32

package/src/unstable/http/HttpTraceContext.ts

@@ -1,6 +1,7 @@
 /**
  * @since 4.0.0
  */
+import * as Option from "../../Option.ts"
 import * as Tracer from "../../Tracer.ts"
 import * as Headers from "./Headers.ts"
 
@@ -9,7 +10,7 @@ import * as Headers from "./Headers.ts"
  * @category models
  */
 export interface FromHeaders {
-  (headers: Headers.Headers): Tracer.ExternalSpan | undefined
+  (headers: Headers.Headers): Option.Option<Tracer.ExternalSpan>
 }
 
 /**
@@ -18,7 +19,12 @@ export interface FromHeaders {
  */
 export const toHeaders = (span: Tracer.Span): Headers.Headers =>
   Headers.fromRecordUnsafe({
-    b3: `${span.traceId}-${span.spanId}-${span.sampled ? "1" : "0"}${span.parent ? `-${span.parent.spanId}` : ""}`,
+    b3: `${span.traceId}-${span.spanId}-${span.sampled ? "1" : "0"}${
+      Option.match(span.parent, {
+        onNone: () => "",
+        onSome: (parent) => `-${parent.spanId}`
+      })
+    }`,
     traceparent: `00-${span.traceId}-${span.spanId}-${span.sampled ? "01" : "00"}`
   })
 
@@ -26,8 +32,16 @@ export const toHeaders = (span: Tracer.Span): Headers.Headers =>
  * @since 4.0.0
  * @category decoding
  */
-export const fromHeaders = (headers: Headers.Headers): Tracer.ExternalSpan | undefined => {
-  return w3c(headers) ?? b3(headers) ?? xb3(headers)
+export const fromHeaders = (headers: Headers.Headers): Option.Option<Tracer.ExternalSpan> => {
+  let span = w3c(headers)
+  if (Option.isSome(span)) {
+    return span
+  }
+  span = b3(headers)
+  if (Option.isSome(span)) {
+    return span
+  }
+  return xb3(headers)
 }
 
 /**
@@ -36,17 +50,17 @@ export const fromHeaders = (headers: Headers.Headers): Tracer.ExternalSpan | und
  */
 export const b3: FromHeaders = (headers) => {
   if (!("b3" in headers)) {
-    return undefined
+    return Option.none()
   }
   const parts = headers["b3"].split("-")
   if (parts.length < 2) {
-    return undefined
+    return Option.none()
   }
-  return Tracer.externalSpan({
+  return Option.some(Tracer.externalSpan({
     traceId: parts[0],
     spanId: parts[1],
     sampled: parts[2] ? parts[2] === "1" : true
-  })
+  }))
 }
 
 /**
@@ -55,13 +69,13 @@ export const b3: FromHeaders = (headers) => {
  */
 export const xb3: FromHeaders = (headers) => {
   if (!(headers["x-b3-traceid"]) || !(headers["x-b3-spanid"])) {
-    return undefined
+    return Option.none()
   }
-  return Tracer.externalSpan({
+  return Option.some(Tracer.externalSpan({
     traceId: headers["x-b3-traceid"],
     spanId: headers["x-b3-spanid"],
     sampled: headers["x-b3-sampled"] ? headers["x-b3-sampled"] === "1" : true
-  })
+  }))
 }
 
 const w3cTraceId = /^[0-9a-f]{32}$/i
@@ -73,26 +87,26 @@ const w3cSpanId = /^[0-9a-f]{16}$/i
  */
 export const w3c: FromHeaders = (headers) => {
   if (!(headers["traceparent"])) {
-    return undefined
+    return Option.none()
   }
   const parts = headers["traceparent"].split("-")
   if (parts.length !== 4) {
-    return undefined
+    return Option.none()
   }
   const [version, traceId, spanId, flags] = parts
   switch (version) {
     case "00": {
       if (w3cTraceId.test(traceId) === false || w3cSpanId.test(spanId) === false) {
-        return undefined
+        return Option.none()
       }
-      return Tracer.externalSpan({
+      return Option.some(Tracer.externalSpan({
         traceId,
         spanId,
         sampled: (parseInt(flags, 16) & 1) === 1
-      })
+      }))
     }
     default: {
-      return undefined
+      return Option.none()
     }
   }
 }

package/src/unstable/http/UrlParams.ts

@@ -19,7 +19,6 @@ import * as Schema from "../../Schema.ts"
 import * as Issue from "../../SchemaIssue.ts"
 import * as Transformation from "../../SchemaTransformation.ts"
 import * as Tuple from "../../Tuple.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 
 const TypeId = "~effect/http/UrlParams"
 
@@ -234,18 +233,17 @@ export const getFirst: {
    * @since 4.0.0
    * @category combinators
    */
-  (key: string): (self: UrlParams) => string | undefined
+  (key: string): (self: UrlParams) => Option.Option<string>
   /**
    * @since 4.0.0
    * @category combinators
    */
-  (self: UrlParams, key: string): string | undefined
+  (self: UrlParams, key: string): Option.Option<string>
 } = dual(
   2,
-  (self: UrlParams, key: string): string | undefined =>
+  (self: UrlParams, key: string): Option.Option<string> =>
     Arr.findFirst(self.params, ([k]) => k === key).pipe(
-      Option.map(([, value]) => value),
-      Option.getOrUndefined
+      Option.map(([, value]) => value)
     )
 )
 
@@ -258,16 +256,15 @@ export const getLast: {
    * @since 4.0.0
    * @category combinators
    */
-  (key: string): (self: UrlParams) => string | undefined
+  (key: string): (self: UrlParams) => Option.Option<string>
   /**
    * @since 4.0.0
    * @category combinators
    */
-  (self: UrlParams, key: string): string | undefined
-} = dual(2, (self: UrlParams, key: string): string | undefined =>
+  (self: UrlParams, key: string): Option.Option<string>
+} = dual(2, (self: UrlParams, key: string): Option.Option<string> =>
   Arr.findLast(self.params, ([k]) => k === key).pipe(
-    Option.map(([, value]) => value),
-    Option.getOrUndefined
+    Option.map(([, value]) => value)
   ))
 
 /**
@@ -537,9 +534,9 @@ export const schemaJsonField = (field: string): schemaJsonField =>
       Schema.UnknownFromJsonString,
       Transformation.transformOrFail({
         decode: (params) =>
-          UndefinedOr.match(getFirst(params, field), {
-            onUndefined: () => Effect.fail(new Issue.Pointer([field], new Issue.MissingKey(undefined))),
-            onDefined: Effect.succeed
+          Option.match(getFirst(params, field), {
+            onNone: () => Effect.fail(new Issue.Pointer([field], new Issue.MissingKey(undefined))),
+            onSome: Effect.succeed
           }),
         encode: (value) => Effect.succeed(make([[field, value]]))
       })

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -72,10 +72,16 @@ export const layer = <Id extends string, Groups extends HttpApiGroup.Any>(
       | Path
     >()
     const routes: Array<HttpRouter.Route<any, any>> = []
+    const availableGroups = Array.from(services.mapUnsafe.keys()).filter((key) =>
+      key.startsWith("effect/httpapi/HttpApiGroup/")
+    )
     for (const group of Object.values(api.groups)) {
       const groupRoutes = services.mapUnsafe.get(group.key) as Array<HttpRouter.Route<any, any>>
       if (groupRoutes === undefined) {
-        return yield* Effect.die(`HttpApiGroup "${group.key}" not found`)
+        const available = availableGroups.length === 0 ? "none" : availableGroups.join(", ")
+        return yield* Effect.die(
+          `HttpApiGroup "${group.identifier}" not found (key: "${group.key}"). Did you forget to provide HttpApiBuilder.group(api, "${group.identifier}", ...)? Available groups: ${available}`
+        )
       }
       routes.push(...groupRoutes)
     }
@@ -166,11 +172,11 @@ export interface Handlers<
     | R
     | HttpApiEndpoint.MiddlewareWithName<Endpoints, Name>
     | HttpApiEndpoint.MiddlewareServicesWithName<Endpoints, Name>
-    | HttpApiEndpoint.ExcludeProvidedWithName<
+    | (HttpApiEndpoint.ExcludeProvidedWithName<
       Endpoints,
       Name,
       R1 | HttpApiEndpoint.ServerServicesWithName<Endpoints, Name>
-    >,
+    > extends infer _R ? _R extends never ? never : HttpRouter.Request<"Requires", _R> : never),
     HttpApiEndpoint.ExcludeName<Endpoints, Name>
   >
 
@@ -186,11 +192,11 @@ export interface Handlers<
     | R
     | HttpApiEndpoint.MiddlewareWithName<Endpoints, Name>
     | HttpApiEndpoint.MiddlewareServicesWithName<Endpoints, Name>
-    | HttpApiEndpoint.ExcludeProvidedWithName<
+    | (HttpApiEndpoint.ExcludeProvidedWithName<
       Endpoints,
       Name,
       R1 | HttpApiEndpoint.ServerServicesWithName<Endpoints, Name>
-    >,
+    > extends infer _R ? _R extends never ? never : HttpRouter.Request<"Requires", _R> : never),
     HttpApiEndpoint.ExcludeName<Endpoints, Name>
   >
 }
@@ -630,13 +636,13 @@ const getRequestMediaType = (request: HttpServerRequest): string => {
 const applyMiddleware = <A extends Effect.Effect<any, any, any>>(
   group: HttpApiGroup.AnyWithProps,
   endpoint: HttpApiEndpoint.AnyWithProps,
-  services: ServiceMap.ServiceMap<never>,
+  services: ServiceMap.ServiceMap<any>,
   handler: A
 ) => {
   const options = { group, endpoint }
   for (const key_ of endpoint.middlewares) {
     const key = key_ as any as HttpApiMiddleware.AnyService
-    const service = services.mapUnsafe.get(key_.key) as HttpApiMiddleware.HttpApiMiddleware<any, any, any>
+    const service = ServiceMap.getUnsafe(services, key as any) as HttpApiMiddleware.HttpApiMiddleware<any, any, any>
     const apply = HttpApiMiddleware.isSecurity(key)
       ? makeSecurityMiddleware(key, service as any)
       : service

package/src/unstable/httpapi/HttpApiError.ts

@@ -1,12 +1,28 @@
 /**
  * @since 4.0.0
  */
+import * as Effect from "../../Effect.ts"
 import * as ErrorReporter from "../../ErrorReporter.ts"
 import { identity } from "../../Function.ts"
 import * as Schema from "../../Schema.ts"
 import * as Transformation from "../../SchemaTransformation.ts"
+import * as HttpServerRespondable from "../http/HttpServerRespondable.ts"
+import * as HttpServerResponse from "../http/HttpServerResponse.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
 
+const badRequestResponse = HttpServerResponse.empty({ status: 400 })
+const unauthorizedResponse = HttpServerResponse.empty({ status: 401 })
+const forbiddenResponse = HttpServerResponse.empty({ status: 403 })
+const notFoundResponse = HttpServerResponse.empty({ status: 404 })
+const methodNotAllowedResponse = HttpServerResponse.empty({ status: 405 })
+const notAcceptableResponse = HttpServerResponse.empty({ status: 406 })
+const requestTimeoutResponse = HttpServerResponse.empty({ status: 408 })
+const conflictResponse = HttpServerResponse.empty({ status: 409 })
+const goneResponse = HttpServerResponse.empty({ status: 410 })
+const internalServerErrorResponse = HttpServerResponse.empty({ status: 500 })
+const notImplementedResponse = HttpServerResponse.empty({ status: 501 })
+const serviceUnavailableResponse = HttpServerResponse.empty({ status: 503 })
+
 /**
  * @category Built-in errors
  * @since 4.0.0
@@ -17,7 +33,10 @@ export class BadRequest extends Schema.ErrorClass<BadRequest>("effect/HttpApiErr
   description: "BadRequest",
   httpApiStatus: 400
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(badRequestResponse)
+  }
   static readonly singleton = new BadRequest()
 }
 
@@ -59,7 +78,10 @@ export class Unauthorized extends Schema.ErrorClass<Unauthorized>("effect/HttpAp
   description: "Unauthorized",
   httpApiStatus: 401
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(unauthorizedResponse)
+  }
 }
 
 /**
@@ -80,7 +102,10 @@ export class Forbidden extends Schema.ErrorClass<Forbidden>("effect/HttpApiError
   description: "Forbidden",
   httpApiStatus: 403
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(forbiddenResponse)
+  }
 }
 
 /**
@@ -101,7 +126,10 @@ export class NotFound extends Schema.ErrorClass<NotFound>("effect/HttpApiError/N
   description: "NotFound",
   httpApiStatus: 404
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(notFoundResponse)
+  }
 }
 
 /**
@@ -122,7 +150,10 @@ export class MethodNotAllowed extends Schema.ErrorClass<MethodNotAllowed>("effec
   description: "MethodNotAllowed",
   httpApiStatus: 405
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(methodNotAllowedResponse)
+  }
 }
 
 /**
@@ -143,7 +174,10 @@ export class NotAcceptable extends Schema.ErrorClass<NotAcceptable>("effect/Http
   description: "NotAcceptable",
   httpApiStatus: 406
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(notAcceptableResponse)
+  }
 }
 
 /**
@@ -164,7 +198,10 @@ export class RequestTimeout extends Schema.ErrorClass<RequestTimeout>("effect/Ht
   description: "RequestTimeout",
   httpApiStatus: 408
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(requestTimeoutResponse)
+  }
 }
 
 /**
@@ -185,7 +222,10 @@ export class Conflict extends Schema.ErrorClass<Conflict>("effect/HttpApiError/C
   description: "Conflict",
   httpApiStatus: 409
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(conflictResponse)
+  }
 }
 
 /**
@@ -206,7 +246,10 @@ export class Gone extends Schema.ErrorClass<Gone>("effect/HttpApiError/Gone")({
   description: "Gone",
   httpApiStatus: 410
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(goneResponse)
+  }
 }
 
 /**
@@ -228,7 +271,11 @@ export class InternalServerError
     description: "InternalServerError",
     httpApiStatus: 500
   })
-{}
+{
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(internalServerErrorResponse)
+  }
+}
 
 /**
  * @category NoContent errors
@@ -247,7 +294,11 @@ export class NotImplemented extends Schema.ErrorClass<NotImplemented>("effect/Ht
 }, {
   description: "NotImplemented",
   httpApiStatus: 501
-}) {}
+}) {
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(notImplementedResponse)
+  }
+}
 
 /**
  * @category NoContent errors
@@ -268,7 +319,11 @@ export class ServiceUnavailable
     description: "ServiceUnavailable",
     httpApiStatus: 503
   })
-{}
+{
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(serviceUnavailableResponse)
+  }
+}
 
 /**
  * @category NoContent errors

package/src/unstable/observability/OtlpExporter.ts

@@ -6,10 +6,10 @@ import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Fiber from "../../Fiber.ts"
 import * as Num from "../../Number.ts"
+import * as Option from "../../Option.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 import * as Headers from "../../unstable/http/Headers.ts"
 import * as HttpClient from "../../unstable/http/HttpClient.ts"
 import * as HttpClientError from "../../unstable/http/HttpClientError.ts"
@@ -24,7 +24,10 @@ const policy = Schedule.forever.pipe(
       && error.reason._tag === "StatusCodeError"
       && error.reason.response.status === 429
     ) {
-      const retryAfter = UndefinedOr.map(error.reason.response.headers["retry-after"], Num.parse) ?? 5
+      const retryAfter = Option.fromUndefinedOr(error.reason.response.headers["retry-after"]).pipe(
+        Option.flatMap(Num.parse),
+        Option.getOrElse(() => 5)
+      )
       return Effect.succeed(Duration.seconds(retryAfter))
     }
     return Effect.succeed(Duration.seconds(1))

package/src/unstable/observability/OtlpTracer.ts

@@ -7,6 +7,7 @@ import * as Effect from "../../Effect.ts"
 import type * as Exit from "../../Exit.ts"
 import { flow } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import type * as Scope from "../../Scope.ts"
 import type * as ServiceMap from "../../ServiceMap.ts"
 import * as Tracer from "../../Tracer.ts"
@@ -150,7 +151,7 @@ type RemainingSpanImpl = Omit<Tracer.Span, (keyof typeof SpanProto) | "traceId"
 
 const makeSpan = (options: {
   readonly name: string
-  readonly parent: Tracer.AnySpan | undefined
+  readonly parent: Option.Option<Tracer.AnySpan>
   readonly annotations: ServiceMap.ServiceMap<never>
   readonly status: Tracer.SpanStatus
   readonly attributes: ReadonlyMap<string, unknown>
@@ -163,8 +164,8 @@ const makeSpan = (options: {
     Object.create(SpanProto),
     options satisfies RemainingSpanImpl
   )
-  if (self.parent) {
-    self.traceId = self.parent.traceId
+  if (Option.isSome(self.parent)) {
+    self.traceId = self.parent.value.traceId
   } else {
     self.traceId = generateId(32)
   }
@@ -249,7 +250,10 @@ const makeOtlpSpan = (self: SpanImpl): OtlpSpan => {
   return {
     traceId: self.traceId,
     spanId: self.spanId,
-    parentSpanId: self.parent ? self.parent.spanId : undefined,
+    parentSpanId: Option.match(self.parent, {
+      onNone: () => undefined,
+      onSome: (parent) => parent.spanId
+    }),
     name: self.name,
     kind: SpanKind[self.kind],
     startTimeUnixNano: String(status.startTime),

package/src/unstable/persistence/Persistable.ts

@@ -194,5 +194,5 @@ export const deserializeExit = <A extends Schema.Top, E extends Schema.Top>(
   A["DecodingServices"] | E["DecodingServices"]
 > => {
   const schema = Schema.toCodecJson(exitSchema(self))
-  return Schema.decodeEffect(schema)(encoded)
+  return Schema.decodeUnknownEffect(schema)(encoded)
 }

package/src/unstable/reactivity/Atom.ts

@@ -607,11 +607,8 @@ function runCallbackSync<R, A, E, ER = never>(
     return undefined
   }
   const runFork = Effect.runForkWith(services)
-  const scheduler = ServiceMap.get(services, Scheduler.Scheduler)
   const fiber = runFork(effect)
-  if ("flush" in scheduler) {
-    ;(scheduler as Scheduler.MixedScheduler).flush()
-  }
+  fiber.currentDispatcher?.flush()
   const result = fiber.pollUnsafe()
   if (result) {
     onExit(result)

package/src/unstable/reactivity/AtomRegistry.ts

@@ -9,7 +9,7 @@ import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import { hasProperty } from "../../Predicate.ts"
 import * as Queue from "../../Queue.ts"
-import type { Scheduler } from "../../Scheduler.ts"
+import type { Scheduler, SchedulerDispatcher } from "../../Scheduler.ts"
 import { MixedScheduler } from "../../Scheduler.ts"
 import * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
@@ -296,6 +296,7 @@ class RegistryImpl implements AtomRegistry {
   readonly defaultIdleTTL: number | undefined
   readonly scheduler: Scheduler
   readonly schedulerAsync: Scheduler
+  readonly dispatcher: SchedulerDispatcher
   onNodeAdded?: ((node: Node<any>) => void) | undefined
   onNodeRemoved?: ((node: Node<any>) => void) | undefined
 
@@ -308,6 +309,7 @@ class RegistryImpl implements AtomRegistry {
     this[TypeId] = TypeId
     this.scheduler = new MixedScheduler("sync", scheduleTask)
     this.schedulerAsync = new MixedScheduler("async", scheduleTask)
+    this.dispatcher = this.schedulerAsync.makeDispatcher()
     this.defaultIdleTTL = defaultIdleTTL
 
     if (timeoutResolution === undefined && defaultIdleTTL !== undefined) {
@@ -427,7 +429,7 @@ class RegistryImpl implements AtomRegistry {
   }
 
   scheduleAtomRemoval(atom: Atom.Atom<any>): void {
-    this.schedulerAsync.scheduleTask(() => {
+    this.dispatcher.scheduleTask(() => {
       const node = this.nodes.get(atomKey(atom))
       if (node !== undefined && node.canBeRemoved) {
         this.removeNode(node)
@@ -436,7 +438,7 @@ class RegistryImpl implements AtomRegistry {
   }
 
   scheduleNodeRemoval(node: NodeImpl<any>): void {
-    this.schedulerAsync.scheduleTask(() => {
+    this.dispatcher.scheduleTask(() => {
       if (node.canBeRemoved) {
         this.removeNode(node)
       }

package/src/unstable/rpc/Rpc.ts

@@ -4,6 +4,7 @@
 import type * as Cause from "../../Cause.ts"
 import type { Effect } from "../../Effect.ts"
 import type { Exit as Exit_ } from "../../Exit.ts"
+import * as Option from "../../Option.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
@@ -780,14 +781,14 @@ export const exitSchema = <R extends Any>(
   const rpc = self as any as AnyWithProps
   const failures = new Set<Schema.Top>([rpc.errorSchema])
   const streamSchemas = RpcSchema.getStreamSchemas(rpc.successSchema)
-  if (streamSchemas) {
-    failures.add(streamSchemas.error)
+  if (Option.isSome(streamSchemas)) {
+    failures.add(streamSchemas.value.error)
   }
   for (const middleware of rpc.middlewares) {
     failures.add(middleware.error)
   }
   const schema = Schema.Exit(
-    streamSchemas ? Schema.Void : rpc.successSchema,
+    Option.isSome(streamSchemas) ? Schema.Void : rpc.successSchema,
     Schema.Union([...failures]),
     rpc.defectSchema
   )

package/src/unstable/rpc/RpcClient.ts

@@ -366,7 +366,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
             resume(exit) {
               resume(exit)
               if (fiber && !fiber.pollUnsafe()) {
-                parentFiber.currentScheduler.scheduleTask(() => {
+                parentFiber.currentDispatcher.scheduleTask(() => {
                   fiber.interruptUnsafe(parentFiber.id)
                 }, 0)
               }
@@ -683,8 +683,8 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
       case "Chunk": {
         const requestId = RequestId(message.requestId)
         const entry = entries.get(requestId)
-        if (!entry || !entry.schemas.decodeChunk) return Effect.void
-        return entry.schemas.decodeChunk(message.values).pipe(
+        if (!entry || Option.isNone(entry.schemas.decodeChunk)) return Effect.void
+        return entry.schemas.decodeChunk.value(message.values).pipe(
           Effect.provideServices(entry.context),
           Effect.orDie,
           Effect.flatMap((chunk) =>
@@ -738,9 +738,9 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
 })
 
 interface RpcSchemas {
-  readonly decodeChunk:
-    | ((chunk: ReadonlyArray<unknown>) => Effect.Effect<NonEmptyReadonlyArray<any>, Schema.SchemaError, unknown>)
-    | undefined
+  readonly decodeChunk: Option.Option<
+    (chunk: ReadonlyArray<unknown>) => Effect.Effect<NonEmptyReadonlyArray<any>, Schema.SchemaError, unknown>
+  >
   readonly encodePayload: (payload: any) => Effect.Effect<any, Schema.SchemaError, unknown>
   readonly decodeExit: (encoded: unknown) => Effect.Effect<Exit.Exit<any, any>, Schema.SchemaError, unknown>
 }
@@ -752,9 +752,10 @@ const rpcSchemas = (rpc: Rpc.AnyWithProps) => {
   }
   const streamSchemas = RpcSchema.getStreamSchemas(rpc.successSchema)
   entry = {
-    decodeChunk: streamSchemas ?
-      Schema.decodeUnknownEffect(Schema.toCodecJson(Schema.NonEmptyArray(streamSchemas.success))) :
-      undefined,
+    decodeChunk: Option.map(
+      streamSchemas,
+      (streamSchemas) => Schema.decodeUnknownEffect(Schema.toCodecJson(Schema.NonEmptyArray(streamSchemas.success)))
+    ),
     encodePayload: Schema.encodeEffect(Schema.toCodecJson(rpc.payloadSchema)),
     decodeExit: Schema.decodeUnknownEffect(Schema.toCodecJson(Rpc.exitSchema(rpc as any)))
   }

package/src/unstable/rpc/RpcGroup.ts

@@ -184,8 +184,8 @@ export type HandlersServices<Rpcs extends Rpc.Any, Handlers> = keyof Handlers ex
  * @since 4.0.0
  * @category groups
  */
-export type HandlerServices<Rpcs extends Rpc.Any, K extends Rpcs["_tag"], Handler> = [Rpc.IsStream<Rpcs, K>] extends
-  [true] ? Handler extends (...args: any) =>
+export type HandlerServices<Rpcs extends Rpc.Any, K extends Rpcs["_tag"], Handler> = true extends
+  Rpc.IsStream<Rpcs, K> ? Handler extends (...args: any) =>
     | Stream.Stream<infer _A, infer _E, infer _R>
     | Rpc.Wrapper<Stream.Stream<infer _A, infer _E, infer _R>>
     | Effect.Effect<
@@ -204,7 +204,7 @@ export type HandlerServices<Rpcs extends Rpc.Any, K extends Rpcs["_tag"], Handle
   Handler extends (
     ...args: any
   ) => Effect.Effect<infer _A, infer _E, infer _R> | Rpc.Wrapper<Effect.Effect<infer _A, infer _E, infer _R>> ?
-    Rpc.ExcludeProvides<_R, Rpcs, K> | Rpc.ExtractRequires<Rpcs, K>
+    Exclude<Rpc.ExcludeProvides<_R, Rpcs, K>, Scope> | Rpc.ExtractRequires<Rpcs, K>
   : never
 
 /**

package/src/unstable/rpc/RpcSchema.ts

@@ -3,6 +3,7 @@
  */
 import * as Cause from "../../Cause.ts"
 import { constUndefined } from "../../Function.ts"
+import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import type * as AST from "../../SchemaAST.ts"
@@ -20,16 +21,16 @@ export function isStreamSchema(schema: Schema.Top): schema is Stream<Schema.Top,
 }
 
 /** @internal */
-export function getStreamSchemas(schema: Schema.Top): {
+export function getStreamSchemas(schema: Schema.Top): Option.Option<{
   readonly success: Schema.Top
   readonly error: Schema.Top
-} | undefined {
+}> {
   return isStreamSchema(schema) ?
-    {
+    Option.some({
       success: schema.success,
       error: schema.error
-    } :
-    undefined
+    }) :
+    Option.none()
 }
 
 /**