@effect/platform 0.42.6 → 0.43.0

package/src/Http/UrlParams.ts

@@ -207,18 +207,18 @@ const baseUrl = (): string | undefined => {
  * @since 1.0.0
  * @category schema
  */
-export const schemaJson = <I, A>(schema: Schema.Schema<I, A>): {
+export const schemaJson = <R, I, A>(schema: Schema.Schema<R, I, A>): {
   (
     field: string
-  ): (self: UrlParams) => Effect.Effect<never, ParseResult.ParseError, A>
+  ): (self: UrlParams) => Effect.Effect<R, ParseResult.ParseError, A>
   (
     self: UrlParams,
     field: string
-  ): Effect.Effect<never, ParseResult.ParseError, A>
+  ): Effect.Effect<R, ParseResult.ParseError, A>
 } => {
-  const parse = Schema.parse(Schema.parseJson(schema))
+  const parse = Schema.decodeUnknown(Schema.parseJson(schema))
   return dual<
-    (field: string) => (self: UrlParams) => Effect.Effect<never, ParseResult.ParseError, A>,
-    (self: UrlParams, field: string) => Effect.Effect<never, ParseResult.ParseError, A>
+    (field: string) => (self: UrlParams) => Effect.Effect<R, ParseResult.ParseError, A>,
+    (self: UrlParams, field: string) => Effect.Effect<R, ParseResult.ParseError, A>
   >(2, (self, field) => parse(Option.getOrElse(getLast(self, field), () => "")))
 }

package/src/KeyValueStore.ts

@@ -76,7 +76,7 @@ export interface KeyValueStore {
   /**
    * Create a SchemaStore for the specified schema.
    */
-  readonly forSchema: <I, A>(schema: Schema.Schema<I, A>) => SchemaStore<A>
+  readonly forSchema: <R, I, A>(schema: Schema.Schema<R, I, A>) => SchemaStore<R, A>
 }
 
 /**
@@ -86,7 +86,7 @@ export declare namespace KeyValueStore {
   /**
    * @since 1.0.0
    */
-  export type AnyStore = KeyValueStore | SchemaStore<any>
+  export type AnyStore = KeyValueStore | SchemaStore<any, any>
 }
 
 /**
@@ -143,14 +143,14 @@ export type SchemaStoreTypeId = typeof SchemaStoreTypeId
  * @since 1.0.0
  * @category models
  */
-export interface SchemaStore<A> {
+export interface SchemaStore<R, A> {
   readonly [SchemaStoreTypeId]: SchemaStoreTypeId
   /**
    * Returns the value of the specified key if it exists.
    */
   readonly get: (
     key: string
-  ) => Effect.Effect<never, PlatformError.PlatformError | ParseResult.ParseError, Option.Option<A>>
+  ) => Effect.Effect<R, PlatformError.PlatformError | ParseResult.ParseError, Option.Option<A>>
 
   /**
    * Sets the value of the specified key.
@@ -158,7 +158,7 @@ export interface SchemaStore<A> {
   readonly set: (
     key: string,
     value: A
-  ) => Effect.Effect<never, PlatformError.PlatformError | ParseResult.ParseError, void>
+  ) => Effect.Effect<R, PlatformError.PlatformError | ParseResult.ParseError, void>
 
   /**
    * Removes the specified key.
@@ -181,7 +181,7 @@ export interface SchemaStore<A> {
   readonly modify: (
     key: string,
     f: (value: A) => A
-  ) => Effect.Effect<never, PlatformError.PlatformError | ParseResult.ParseError, Option.Option<A>>
+  ) => Effect.Effect<R, PlatformError.PlatformError | ParseResult.ParseError, Option.Option<A>>
 
   /**
    * Returns true if the KeyValueStore contains the specified key.
@@ -198,10 +198,10 @@ export interface SchemaStore<A> {
  * @since 1.0.0
  * @category layers
  */
-export const layerSchema: <I, A>(
-  schema: Schema.Schema<I, A>,
+export const layerSchema: <R, I, A>(
+  schema: Schema.Schema<R, I, A>,
   tagIdentifier?: unknown
 ) => {
-  readonly tag: Context.Tag<SchemaStore<A>, SchemaStore<A>>
-  readonly layer: Layer.Layer<KeyValueStore, never, SchemaStore<A>>
+  readonly tag: Context.Tag<SchemaStore<R, A>, SchemaStore<R, A>>
+  readonly layer: Layer.Layer<KeyValueStore, never, SchemaStore<R, A>>
 } = internal.layerSchema

package/src/Transferable.ts

@@ -2,10 +2,9 @@
  * @since 1.0.0
  */
 
-import * as AST from "@effect/schema/AST"
 import * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
-import { dual } from "effect/Function"
+import { dual, identity } from "effect/Function"
 
 /**
  * @since 1.0.0
@@ -43,18 +42,20 @@ export const get = (u: unknown): ReadonlyArray<globalThis.Transferable> => {
  * @category schema
  */
 export const schema: {
-  <A>(f: (_: A) => ReadonlyArray<globalThis.Transferable>): <I>(self: Schema.Schema<I, A>) => Schema.Schema<I, A>
-  <I, A>(self: Schema.Schema<I, A>, f: (_: A) => ReadonlyArray<globalThis.Transferable>): Schema.Schema<I, A>
+  <A>(
+    f: (_: A) => ReadonlyArray<globalThis.Transferable>
+  ): <R, I>(self: Schema.Schema<R, I, A>) => Schema.Schema<R, I, A>
+  <R, I, A>(self: Schema.Schema<R, I, A>, f: (_: A) => ReadonlyArray<globalThis.Transferable>): Schema.Schema<R, I, A>
 } = dual<
   <A>(
     f: (_: A) => ReadonlyArray<globalThis.Transferable>
-  ) => <I>(self: Schema.Schema<I, A>) => Schema.Schema<I, A>,
-  <I, A>(
-    self: Schema.Schema<I, A>,
+  ) => <R, I>(self: Schema.Schema<R, I, A>) => Schema.Schema<R, I, A>,
+  <R, I, A>(
+    self: Schema.Schema<R, I, A>,
     f: (_: A) => ReadonlyArray<globalThis.Transferable>
-  ) => Schema.Schema<I, A>
->(2, <I, A>(
-  self: Schema.Schema<I, A>,
+  ) => Schema.Schema<R, I, A>
+>(2, <R, I, A>(
+  self: Schema.Schema<R, I, A>,
   f: (_: A) => ReadonlyArray<globalThis.Transferable>
 ) =>
   Schema.transform(
@@ -67,35 +68,32 @@ export const schema: {
           return f(this as any)
         }
       }) as A,
-    (output) => output as A
+    identity
   ))
 
+const schemaParse =
+  <R, A>(parse: ParseResult.DecodeUnknown<R, A>): ParseResult.DeclarationDecodeUnknown<R, A> => (u, options, ast) => {
+    if (!isTransferable(u)) {
+      return ParseResult.fail(ParseResult.type(ast, u))
+    }
+    const proto = {
+      __proto__: Object.getPrototypeOf(u),
+      [symbol]: u[symbol]
+    }
+    return ParseResult.map(parse(u, options), (a): A => Object.setPrototypeOf(a, proto))
+  }
+
 /**
  * @since 1.0.0
  * @category schema
  */
-export const schemaFromSelf = <I, A>(
-  item: Schema.Schema<I, A>
-): Schema.Schema<I, A> => {
+export const schemaFromSelf = <R, I, A>(
+  item: Schema.Schema<R, I, A>
+): Schema.Schema<R, I, A> => {
   return Schema.declare(
     [item],
-    item,
-    (isDecoding, item) => {
-      const parse = isDecoding ? Schema.parse(item) : Schema.encode(item)
-      return (u, options, ast) => {
-        if (!isTransferable(u)) {
-          return ParseResult.fail(ParseResult.type(ast, u))
-        }
-        const proto = {
-          __proto__: Object.getPrototypeOf(u),
-          [symbol]: u[symbol]
-        }
-        return ParseResult.map(
-          parse(u, options),
-          (a) => Object.setPrototypeOf(a, proto)
-        )
-      }
-    },
-    { [AST.IdentifierAnnotationId]: "Transferable" }
+    (item) => schemaParse(ParseResult.decodeUnknown(item)),
+    (item) => schemaParse(ParseResult.encodeUnknown(item)),
+    { identifier: "Transferable" }
   )
 }

package/src/Worker.ts

@@ -233,13 +233,13 @@ export interface SerializedWorker<I extends Schema.TaggedRequest.Any> {
   readonly id: number
   readonly execute: <Req extends I>(
     message: Req
-  ) => Req extends Serializable.WithResult<infer _IE, infer E, infer _IA, infer A>
-    ? Stream.Stream<never, E | WorkerError | ParseResult.ParseError, A>
+  ) => Req extends Serializable.WithResult<infer R, infer _IE, infer E, infer _IA, infer A>
+    ? Stream.Stream<R, E | WorkerError | ParseResult.ParseError, A>
     : never
   readonly executeEffect: <Req extends I>(
     message: Req
-  ) => Req extends Serializable.WithResult<infer _IE, infer E, infer _IA, infer A>
-    ? Effect.Effect<never, E | WorkerError | ParseResult.ParseError, A>
+  ) => Req extends Serializable.WithResult<infer R, infer _IE, infer E, infer _IA, infer A>
+    ? Effect.Effect<R, E | WorkerError | ParseResult.ParseError, A>
     : never
 }
 
@@ -279,18 +279,18 @@ export interface SerializedWorkerPool<I extends Schema.TaggedRequest.Any> {
   readonly backing: Pool.Pool<WorkerError, SerializedWorker<I>>
   readonly broadcast: <Req extends I>(
     message: Req
-  ) => Req extends Serializable.WithResult<infer _IE, infer E, infer _IA, infer _A>
-    ? Effect.Effect<never, E | WorkerError | ParseResult.ParseError, void>
+  ) => Req extends Serializable.WithResult<infer R, infer _IE, infer E, infer _IA, infer _A>
+    ? Effect.Effect<R, E | WorkerError | ParseResult.ParseError, void>
     : never
   readonly execute: <Req extends I>(
     message: Req
-  ) => Req extends Serializable.WithResult<infer _IE, infer E, infer _IA, infer A>
-    ? Stream.Stream<never, E | WorkerError | ParseResult.ParseError, A>
+  ) => Req extends Serializable.WithResult<infer R, infer _IE, infer E, infer _IA, infer A>
+    ? Stream.Stream<R, E | WorkerError | ParseResult.ParseError, A>
     : never
   readonly executeEffect: <Req extends I>(
     message: Req
-  ) => Req extends Serializable.WithResult<infer _IE, infer E, infer _IA, infer A>
-    ? Effect.Effect<never, E | WorkerError | ParseResult.ParseError, A>
+  ) => Req extends Serializable.WithResult<infer R, infer _IE, infer E, infer _IA, infer A>
+    ? Effect.Effect<R, E | WorkerError | ParseResult.ParseError, A>
     : never
 }
 

package/src/WorkerRunner.ts

@@ -18,7 +18,10 @@ import type { WorkerError } from "./WorkerError.js"
  */
 export interface BackingRunner<I, O> {
   readonly queue: Queue.Dequeue<I>
-  readonly send: (message: O, transfers?: ReadonlyArray<unknown>) => Effect.Effect<never, never, void>
+  readonly send: (
+    message: O,
+    transfers?: ReadonlyArray<unknown>
+  ) => Effect.Effect<never, never, void>
 }
 
 /**
@@ -72,9 +75,17 @@ export declare namespace Runner {
    * @category models
    */
   export interface Options<I, E, O> {
-    readonly decode?: (message: unknown) => Effect.Effect<never, WorkerError, I>
-    readonly encodeOutput?: (request: I, message: O) => Effect.Effect<never, WorkerError, unknown>
-    readonly encodeError?: (request: I, error: E) => Effect.Effect<never, WorkerError, unknown>
+    readonly decode?: (
+      message: unknown
+    ) => Effect.Effect<never, WorkerError, I>
+    readonly encodeOutput?: (
+      request: I,
+      message: O
+    ) => Effect.Effect<never, WorkerError, unknown>
+    readonly encodeError?: (
+      request: I,
+      error: E
+    ) => Effect.Effect<never, WorkerError, unknown>
     readonly transfers?: (message: O | E) => ReadonlyArray<unknown>
   }
 }
@@ -106,8 +117,19 @@ export declare namespace SerializedRunner {
    * @since 1.0.0
    */
   export type Handlers<A extends Schema.TaggedRequest.Any> = {
-    readonly [K in A["_tag"]]: Extract<A, { readonly _tag: K }> extends
-      Serializable.SerializableWithResult<infer _IS, infer S, infer _IE, infer E, infer _IO, infer O> ? (
+    readonly [K in A["_tag"]]: Extract<
+      A,
+      { readonly _tag: K }
+    > extends Serializable.SerializableWithResult<
+      infer _RS,
+      infer _IS,
+      infer S,
+      infer _RR,
+      infer _IE,
+      infer E,
+      infer _IO,
+      infer O
+    > ? (
         _: S
       ) =>
         | Stream.Stream<any, E, O>
@@ -120,10 +142,17 @@ export declare namespace SerializedRunner {
   /**
    * @since 1.0.0
    */
-  export type HandlersContext<Handlers extends Record<string, (...args: ReadonlyArray<any>) => any>> =
+  export type HandlersContext<
+    Handlers extends Record<string, (...args: ReadonlyArray<any>) => any>
+  > =
     | Exclude<
       {
-        [K in keyof Handlers]: ReturnType<Handlers[K]> extends Stream.Stream<infer R, infer _E, infer _A> ? R : never
+        [K in keyof Handlers]: ReturnType<Handlers[K]> extends Stream.Stream<
+          infer R,
+          infer _E,
+          infer _A
+        > ? R
+          : never
       }[keyof Handlers],
       InitialContext<Handlers>
     >
@@ -132,16 +161,22 @@ export declare namespace SerializedRunner {
   /**
    * @since 1.0.0
    */
-  type InitialContext<Handlers extends Record<string, (...args: ReadonlyArray<any>) => any>> =
-    Handlers["InitialMessage"] extends (...args: ReadonlyArray<any>) => Layer.Layer<infer _R, infer _E, infer A> ? A
-      : never
+  type InitialContext<
+    Handlers extends Record<string, (...args: ReadonlyArray<any>) => any>
+  > = Handlers["InitialMessage"] extends (
+    ...args: ReadonlyArray<any>
+  ) => Layer.Layer<infer _R, infer _E, infer A> ? A
+    : never
 
   /**
    * @since 1.0.0
    */
-  type InitialEnv<Handlers extends Record<string, (...args: ReadonlyArray<any>) => any>> =
-    Handlers["InitialMessage"] extends (...args: ReadonlyArray<any>) => Layer.Layer<infer R, infer _E, infer _A> ? R
-      : never
+  type InitialEnv<
+    Handlers extends Record<string, (...args: ReadonlyArray<any>) => any>
+  > = Handlers["InitialMessage"] extends (
+    ...args: ReadonlyArray<any>
+  ) => Layer.Layer<infer R, infer _E, infer _A> ? R
+    : never
 }
 
 /**
@@ -149,13 +184,14 @@ export declare namespace SerializedRunner {
  * @category constructors
  */
 export const makeSerialized: <
+  R,
   I,
   A extends Schema.TaggedRequest.Any,
   const Handlers extends SerializedRunner.Handlers<A>
 >(
-  schema: Schema.Schema<I, A>,
+  schema: Schema.Schema<R, I, A>,
   handlers: Handlers
-) => Effect.Effect<PlatformRunner | Scope.Scope | SerializedRunner.HandlersContext<Handlers>, WorkerError, void> =
+) => Effect.Effect<PlatformRunner | Scope.Scope | R | SerializedRunner.HandlersContext<Handlers>, WorkerError, void> =
   internal.makeSerialized
 
 /**
@@ -163,11 +199,12 @@ export const makeSerialized: <
  * @category layers
  */
 export const layerSerialized: <
+  R,
   I,
   A extends Schema.TaggedRequest.Any,
   const Handlers extends SerializedRunner.Handlers<A>
 >(
-  schema: Schema.Schema<I, A>,
+  schema: Schema.Schema<R, I, A>,
   handlers: Handlers
-) => Layer.Layer<PlatformRunner | SerializedRunner.HandlersContext<Handlers>, WorkerError, never> =
+) => Layer.Layer<PlatformRunner | R | SerializedRunner.HandlersContext<Handlers>, WorkerError, never> =
   internal.layerSerialized

package/src/internal/http/body.ts

@@ -90,9 +90,9 @@ export const urlParams = (urlParams: UrlParams.UrlParams): Body.Uint8Array =>
   text(UrlParams.toString(urlParams), "application/x-www-form-urlencoded")
 
 /** @internal */
-export const jsonSchema = <I, A>(schema: Schema.Schema<I, A>) => {
+export const jsonSchema = <R, I, A>(schema: Schema.Schema<R, I, A>) => {
   const encode = Schema.encode(schema)
-  return (body: A): Effect.Effect<never, Body.BodyError, Body.Uint8Array> =>
+  return (body: A): Effect.Effect<R, Body.BodyError, Body.Uint8Array> =>
     Effect.flatMap(
       Effect.mapError(encode(body), (error) => BodyError({ _tag: "SchemaError", error })),
       json

package/src/internal/http/client.ts

@@ -103,8 +103,9 @@ export const fetch = (options?: RequestInit): Client.Client.Default =>
                     method: request.method,
                     headers,
                     body,
+                    duplex: request.body._tag === "Stream" ? "half" : undefined,
                     signal
-                  }),
+                  } as any),
                 catch: (_) =>
                   internalError.requestError({
                     request,
@@ -527,23 +528,23 @@ export const retry: {
 
 /** @internal */
 export const schemaFunction = dual<
-  <SI, SA>(
-    schema: Schema.Schema<SI, SA>
+  <SR, SI, SA>(
+    schema: Schema.Schema<SR, SI, SA>
   ) => <R, E, A>(
     self: Client.Client<R, E, A>
   ) => (
     request: ClientRequest.ClientRequest
   ) => (
     a: SA
-  ) => Effect.Effect<R, E | ParseResult.ParseError | Error.RequestError, A>,
-  <R, E, A, SI, SA>(
+  ) => Effect.Effect<R | SR, E | ParseResult.ParseError | Error.RequestError, A>,
+  <R, E, A, SR, SI, SA>(
     self: Client.Client<R, E, A>,
-    schema: Schema.Schema<SI, SA>
+    schema: Schema.Schema<SR, SI, SA>
   ) => (
     request: ClientRequest.ClientRequest
   ) => (
     a: SA
-  ) => Effect.Effect<R, E | ParseResult.ParseError | Error.RequestError, A>
+  ) => Effect.Effect<R | SR, E | ParseResult.ParseError | Error.RequestError, A>
 >(2, (self, schema) => {
   const encode = Schema.encode(schema)
   return (request) => (a) =>

package/src/internal/http/clientRequest.ts

@@ -6,7 +6,6 @@ import type * as Stream from "effect/Stream"
 import type * as PlatformError from "../../Error.js"
 import type * as FileSystem from "../../FileSystem.js"
 import type * as Body from "../../Http/Body.js"
-import type * as Error from "../../Http/ClientError.js"
 import type * as ClientRequest from "../../Http/ClientRequest.js"
 import * as Headers from "../../Http/Headers.js"
 import type { Method } from "../../Http/Method.js"
@@ -363,16 +362,16 @@ export const fileWebBody = dual<
 >(2, (self, file) => setBody(self, internalBody.fileWeb(file)))
 
 /** @internal */
-export const schemaBody = <I, A>(schema: Schema.Schema<I, A>): {
-  (body: A): (self: ClientRequest.ClientRequest) => Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>
-  (self: ClientRequest.ClientRequest, body: A): Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>
+export const schemaBody = <R, I, A>(schema: Schema.Schema<R, I, A>): {
+  (body: A): (self: ClientRequest.ClientRequest) => Effect.Effect<R, Body.BodyError, ClientRequest.ClientRequest>
+  (self: ClientRequest.ClientRequest, body: A): Effect.Effect<R, Body.BodyError, ClientRequest.ClientRequest>
 } => {
   const encode = internalBody.jsonSchema(schema)
   return dual<
     (
       body: A
-    ) => (self: ClientRequest.ClientRequest) => Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>,
-    (self: ClientRequest.ClientRequest, body: A) => Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>
+    ) => (self: ClientRequest.ClientRequest) => Effect.Effect<R, Body.BodyError, ClientRequest.ClientRequest>,
+    (self: ClientRequest.ClientRequest, body: A) => Effect.Effect<R, Body.BodyError, ClientRequest.ClientRequest>
   >(2, (self, body) => Effect.map(encode(body), (body) => setBody(self, body)))
 }
 
@@ -398,7 +397,7 @@ export const formDataBody = dual<
 /** @internal */
 export const streamBody = dual<
   (
-    body: Stream.Stream<never, Error.RequestError, Uint8Array>,
+    body: Stream.Stream<never, unknown, Uint8Array>,
     options?: {
       readonly contentType?: string
       readonly contentLength?: number
@@ -406,7 +405,7 @@ export const streamBody = dual<
   ) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
   (
     self: ClientRequest.ClientRequest,
-    body: Stream.Stream<never, Error.RequestError, Uint8Array>,
+    body: Stream.Stream<never, unknown, Uint8Array>,
     options?: {
       readonly contentType?: string
       readonly contentLength?: number

package/src/internal/http/clientResponse.ts

@@ -133,15 +133,16 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
 
 /** @internal */
 export const schemaJson = <
+  R,
   I extends {
     readonly status?: number
     readonly headers?: Readonly<Record<string, string>>
     readonly body?: unknown
   },
   A
->(schema: Schema.Schema<I, A>) => {
-  const parse = Schema.parse(schema)
-  return (self: ClientResponse.ClientResponse): Effect.Effect<never, Error.ResponseError | ParseResult.ParseError, A> =>
+>(schema: Schema.Schema<R, I, A>) => {
+  const parse = Schema.decodeUnknown(schema)
+  return (self: ClientResponse.ClientResponse): Effect.Effect<R, Error.ResponseError | ParseResult.ParseError, A> =>
     Effect.flatMap(
       self.json,
       (body) =>
@@ -155,14 +156,15 @@ export const schemaJson = <
 
 /** @internal */
 export const schemaNoBody = <
+  R,
   I extends {
     readonly status?: number
     readonly headers?: Readonly<Record<string, string>>
   },
   A
->(schema: Schema.Schema<I, A>) => {
-  const parse = Schema.parse(schema)
-  return (self: ClientResponse.ClientResponse): Effect.Effect<never, ParseResult.ParseError, A> =>
+>(schema: Schema.Schema<R, I, A>) => {
+  const parse = Schema.decodeUnknown(schema)
+  return (self: ClientResponse.ClientResponse): Effect.Effect<R, ParseResult.ParseError, A> =>
     parse({
       status: self.status,
       headers: self.headers

package/src/internal/http/multipart.ts

@@ -89,7 +89,7 @@ export const withFieldMimeTypes = dual<
   <R, E, A>(effect: Effect.Effect<R, E, A>, mimeTypes: ReadonlyArray<string>) => Effect.Effect<R, E, A>
 >(2, (effect, mimeTypes) => Effect.locally(effect, fieldMimeTypes, Chunk.fromIterable(mimeTypes)))
 
-const fileSchema: Schema.Schema<Multipart.PersistedFile, Multipart.PersistedFile> = Schema.struct({
+const fileSchema: Schema.Schema<never, Multipart.PersistedFile, Multipart.PersistedFile> = Schema.struct({
   [TypeId]: Schema.uniqueSymbol(TypeId),
   _tag: Schema.literal("PersistedFile"),
   key: Schema.string,
@@ -100,27 +100,28 @@ const fileSchema: Schema.Schema<Multipart.PersistedFile, Multipart.PersistedFile
 
 /** @internal */
 export const filesSchema: Schema.Schema<
+  never,
   ReadonlyArray<Multipart.PersistedFile>,
   ReadonlyArray<Multipart.PersistedFile>
 > = Schema.array(fileSchema)
 
 /** @internal */
-export const schemaPersisted = <I extends Multipart.Persisted, A>(
-  schema: Schema.Schema<I, A>
+export const schemaPersisted = <R, I extends Multipart.Persisted, A>(
+  schema: Schema.Schema<R, I, A>
 ) => {
-  const parse = Schema.parse(schema)
+  const parse = Schema.decodeUnknown(schema)
   return (persisted: Multipart.Persisted) => parse(persisted)
 }
 
 /** @internal */
-export const schemaJson = <I, A>(schema: Schema.Schema<I, A>): {
+export const schemaJson = <R, I, A>(schema: Schema.Schema<R, I, A>): {
   (
     field: string
-  ): (persisted: Multipart.Persisted) => Effect.Effect<never, ParseResult.ParseError, A>
+  ): (persisted: Multipart.Persisted) => Effect.Effect<R, ParseResult.ParseError, A>
   (
     persisted: Multipart.Persisted,
     field: string
-  ): Effect.Effect<never, ParseResult.ParseError, A>
+  ): Effect.Effect<R, ParseResult.ParseError, A>
 } => {
   const fromJson = Schema.parseJson(schema)
   return dual<
@@ -128,14 +129,14 @@ export const schemaJson = <I, A>(schema: Schema.Schema<I, A>): {
       field: string
     ) => (
       persisted: Multipart.Persisted
-    ) => Effect.Effect<never, ParseResult.ParseError, A>,
+    ) => Effect.Effect<R, ParseResult.ParseError, A>,
     (
       persisted: Multipart.Persisted,
       field: string
-    ) => Effect.Effect<never, ParseResult.ParseError, A>
+    ) => Effect.Effect<R, ParseResult.ParseError, A>
   >(2, (persisted, field) =>
     Effect.map(
-      Schema.parse(
+      Schema.decodeUnknown(
         Schema.struct({
           [field]: fromJson
         })

package/src/internal/http/router.ts

@@ -36,20 +36,22 @@ export const params = Effect.map(RouteContext, (_) => _.params)
 export const searchParams = Effect.map(RouteContext, (_) => _.searchParams)
 
 /** @internal */
-export const schemaParams = <I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<I, A>) => {
-  const parse = Schema.parse(schema)
+export const schemaParams = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<R, I, A>) => {
+  const parse = Schema.decodeUnknown(schema)
   return Effect.flatMap(RouteContext, (_) => parse({ ..._.searchParams, ..._.params }))
 }
 
 /** @internal */
-export const schemaPathParams = <I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<I, A>) => {
-  const parse = Schema.parse(schema)
+export const schemaPathParams = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<R, I, A>) => {
+  const parse = Schema.decodeUnknown(schema)
   return Effect.flatMap(RouteContext, (_) => parse(_.params))
 }
 
 /** @internal */
-export const schemaSearchParams = <I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<I, A>) => {
-  const parse = Schema.parse(schema)
+export const schemaSearchParams = <R, I extends Readonly<Record<string, string>>, A>(
+  schema: Schema.Schema<R, I, A>
+) => {
+  const parse = Schema.decodeUnknown(schema)
   return Effect.flatMap(RouteContext, (_) => parse(_.searchParams))
 }