effect 4.0.0-beta.82 → 4.0.0-beta.84

package/src/SchemaTransformation.ts

@@ -447,7 +447,7 @@ export function trim(): Transformation<string, string> {
  * Encoding converts values such as `"myFieldName"` back to `"my_field_name"`.
  * The transformation is round-trippable for standard snake_case and camelCase.
  *
- * **Example** (Snake to camel conversion)
+ * **Example** (Converting snake case to camel case)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -722,7 +722,7 @@ export function passthrough<T>(): Transformation<T, T> {
  * Both decode and encode are no-ops and return a shared singleton
  * transformation.
  *
- * **Example** (Supertype passthrough)
+ * **Example** (Passing through supertypes)
  *
  * ```ts
  * import { SchemaTransformation } from "effect"
@@ -755,7 +755,7 @@ export function passthroughSupertype<T>(): Transformation<T, T> {
  * - Both decode and encode are no-ops (same as {@link passthrough}).
  * - Returns a shared singleton instance.
  *
- * **Example** (Subtype passthrough)
+ * **Example** (Passing through subtypes)
  *
  * ```ts
  * import { SchemaTransformation } from "effect"
@@ -790,7 +790,7 @@ export function passthroughSubtype<T>(): Transformation<T, T> {
  * result is finite; combine with `Schema.Finite` or `Schema.Int` for stricter
  * checks.
  *
- * **Example** (Number from string)
+ * **Example** (Converting a string to a number)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -826,7 +826,7 @@ export const numberFromString = new Transformation(
  * the bigint to a string like `String(n)`. Decoding fails if the string is not
  * a valid bigint representation.
  *
- * **Example** (BigInt from string)
+ * **Example** (Converting a string to a BigInt)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -861,7 +861,7 @@ export const bigintFromString = new Transformation(
  * converts the `Date` to an ISO string like `date.toISOString()`, returning
  * `"Invalid Date"` for invalid dates.
  *
- * **Example** (Date from string)
+ * **Example** (Converting a string to a Date)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -898,7 +898,7 @@ export const dateFromString: Transformation<globalThis.Date, string> = new Trans
  * producing strings such as `"2000 millis"` or `"10 nanos"` that round-trip
  * through the parser.
  *
- * **Example** (Duration from string)
+ * **Example** (Converting a string to a Duration)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -942,7 +942,7 @@ export const durationFromString: Transformation<Duration.Duration, string> = tra
  * fails with `InvalidValue` if the `Duration` cannot be represented as a
  * `bigint`, such as `Duration.infinity`.
  *
- * **Example** (Duration from nanoseconds)
+ * **Example** (Converting nanoseconds to a Duration)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -983,7 +983,7 @@ export const durationFromNanos: Transformation<Duration.Duration, bigint> = tran
  * Decode creates a duration from the number, and encode returns the duration
  * length in milliseconds.
  *
- * **Example** (Duration from milliseconds)
+ * **Example** (Converting milliseconds to a Duration)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1098,7 +1098,7 @@ export const defectFromJson = (options?: ErrorOptions) =>
  * `Option.some(value)`. Encoding maps `Option.none()` to `null` and
  * `Option.some(value)` to `value`. The transformation is pure and synchronous.
  *
- * **Example** (Option from nullable)
+ * **Example** (Converting nullable values to an Option)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1138,7 +1138,7 @@ export function optionFromNullOr<T>(): Transformation<Option.Option<T>, T | null
  * `Option.some(value)`. Encoding maps `Option.none()` to `undefined` and
  * `Option.some(value)` to `value`. The transformation is pure and synchronous.
  *
- * **Example** (Option from undefined-or)
+ * **Example** (Converting undefined-or values to an Option)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1181,7 +1181,7 @@ export function optionFromUndefinedOr<T>(): Transformation<Option.Option<T>, T |
  * `undefined` according to `options.onNoneEncoding`, and maps
  * `Option.some(value)` to `value`. The transformation is pure and synchronous.
  *
- * **Example** (Option from nullish, encoding None as null)
+ * **Example** (Converting nullish values to an Option and encoding None as null)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1227,7 +1227,7 @@ export function optionFromNullishOr<T>(
  * the key, and maps `Some(Some(v))` to `Some(v)`. This uses
  * `transformOptional` under the hood.
  *
- * **Example** (Optional key to Option)
+ * **Example** (Converting an optional key to an Option)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1272,7 +1272,7 @@ export function optionFromOptionalKey<T>(): Transformation<Option.Option<T>, T>
  * value, and maps `Some(Some(v))` to `Some(v)`. This uses
  * `transformOptional` under the hood and filters out `undefined` on decode.
  *
- * **Example** (Optional value to Option)
+ * **Example** (Converting an optional value to an Option)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1315,7 +1315,7 @@ export function optionFromOptional<T>(): Transformation<Option.Option<T>, T | un
  * Decoding calls `new URL(s)` and fails with `InvalidValue` if the string is
  * not a valid URL. Encoding returns `url.href`.
  *
- * **Example** (URL from string)
+ * **Example** (Converting a string to a URL)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1385,7 +1385,7 @@ export const bigDecimalFromString: Transformation<BigDecimal.BigDecimal, string>
  * Decoding parses the Base64 string into bytes. Encoding writes the byte array
  * as a Base64 string.
  *
- * **Example** (Uint8Array from Base64)
+ * **Example** (Converting Base64 to a Uint8Array)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1420,7 +1420,7 @@ export const uint8ArrayFromBase64String: Transformation<Uint8Array<ArrayBufferLi
  * Decoding parses the Base64 string into a UTF-8 string. Encoding writes the
  * string as a Base64 string.
  *
- * **Example** (String from Base64)
+ * **Example** (Converting Base64 to a string)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1454,7 +1454,7 @@ export const stringFromBase64String: Transformation<string, string> = new Transf
  * Decoding parses the Base64 URL string into a UTF-8 string. Encoding writes
  * the string as a Base64 URL string.
  *
- * **Example** (String from Base64Url)
+ * **Example** (Converting Base64Url to a string)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1488,7 +1488,7 @@ export const stringFromBase64UrlString: Transformation<string, string> = new Tra
  * Decoding parses the hex string into a UTF-8 string. Encoding writes the
  * string as a hex string.
  *
- * **Example** (String from Hex)
+ * **Example** (Converting hex to a string)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1524,7 +1524,7 @@ export const stringFromHexString: Transformation<string, string> = new Transform
  * Decoding calls `decodeURIComponent` and fails if the input contains malformed
  * percent-encoding sequences. Encoding calls `encodeURIComponent`.
  *
- * **Example** (URI component schema)
+ * **Example** (Defining a URI component schema)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"

package/src/Stream.ts

@@ -2905,7 +2905,7 @@ export const tapSink: {
  * multiple inner streams may run at the same time and their outputs are merged
  * as they arrive.
  *
- * **Example** (FlatMapping stream values)
+ * **Example** (Flat mapping stream values)
  *
  * ```ts
  * import { Console, Effect, Stream } from "effect"
@@ -2936,7 +2936,7 @@ export const flatMap: {
    * multiple inner streams may run at the same time and their outputs are merged
    * as they arrive.
    *
-   * **Example** (FlatMapping stream values)
+   * **Example** (Flat mapping stream values)
    *
    * ```ts
    * import { Console, Effect, Stream } from "effect"
@@ -2973,7 +2973,7 @@ export const flatMap: {
    * multiple inner streams may run at the same time and their outputs are merged
    * as they arrive.
    *
-   * **Example** (FlatMapping stream values)
+   * **Example** (Flat mapping stream values)
    *
    * ```ts
    * import { Console, Effect, Stream } from "effect"
@@ -19522,7 +19522,7 @@ export const runForEachWhile: {
           if (!b) done = true
         }
       }),
-      () => done
+      () => !done
     )
   }))
 

package/src/String.ts

@@ -102,7 +102,7 @@ export const Equivalence: Equ.Equivalence<string> = Equ.String
  *
  * Use when you need the canonical empty string value from the `String` module.
  *
- * **Example** (Using the empty string)
+ * **Example** (Referencing the empty string)
  *
  * ```ts
  * import { String } from "effect"

package/src/Struct.ts

@@ -199,7 +199,7 @@ export const get: {
  *
  * Symbol keys are excluded; only string keys are returned.
  *
- * **Example** (Typed keys)
+ * **Example** (Reading typed keys)
  *
  * ```ts
  * import { Struct } from "effect"

package/src/Types.ts

@@ -31,7 +31,7 @@ type TupleOf_<T, N extends number, R extends Array<unknown>> = `${N}` extends `-
  * - If `N` is the general `number` type (non-literal), degrades to `Array<T>`.
  * - Negative numbers produce `never`.
  *
- * **Example** (Fixed-length tuple)
+ * **Example** (Checking fixed-length tuples)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -66,7 +66,7 @@ export type TupleOf<N extends number, T> = N extends N ? number extends N ? Arra
  *
  * Produces a tuple with `N` fixed positions followed by `...Array<T>`.
  *
- * **Example** (Minimum-length tuple)
+ * **Example** (Checking minimum-length tuples)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -201,7 +201,7 @@ export type ExtractTag<E, K extends string> = E extends { readonly _tag: infer T
  * - If the union members are incompatible (e.g. `string | number`), the
  *   result is `never`.
  *
- * **Example** (Union to intersection)
+ * **Example** (Converting a union to an intersection)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -264,7 +264,7 @@ export type Simplify<A> = {
  *   distinguishing between `any`, `unknown`, `never`, and other types.
  * - Resolves to `true` if `X` and `Y` are identical, `false` otherwise.
  *
- * **Example** (Type equality check)
+ * **Example** (Checking type equality)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -295,7 +295,7 @@ export type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
  *
  * Returns `Y` when `A` and `B` are equal, `N` otherwise.
  *
- * **Example** (Conditional type based on equality)
+ * **Example** (Choosing a conditional type based on equality)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -324,7 +324,7 @@ export type EqualsWith<A, B, Y, N> = (<T>() => T extends A ? 1 : 2) extends (<T>
  * Returns `true` if at least one key from `Key` exists in `A`, `false`
  * otherwise.
  *
- * **Example** (Key presence check)
+ * **Example** (Checking key presence)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -352,7 +352,7 @@ export type Has<A, Key extends string> = (Key extends infer K ? K extends keyof
  *
  * Implemented as `MergeRight<Target, Source>`.
  *
- * **Example** (Left-biased merge)
+ * **Example** (Merging with left bias)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -423,7 +423,7 @@ export type MergeRight<Target, Source> = Simplify<
  * - `"unbounded"` — run all effects concurrently with no limit.
  * - `"inherit"` — inherit the concurrency from the surrounding context.
  *
- * **Example** (Concurrency values)
+ * **Example** (Setting concurrency values)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -451,7 +451,7 @@ export type Concurrency = number | "unbounded" | "inherit"
  *
  * Only affects the top level; nested properties remain readonly.
  *
- * **Example** (Shallow mutable conversion)
+ * **Example** (Converting shallowly to mutable types)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -492,7 +492,7 @@ export type Mutable<T> = {
  * Recursion stops at primitives (`string`, `number`, `boolean`, `bigint`,
  * `symbol`) and functions.
  *
- * **Example** (Deep mutable conversion)
+ * **Example** (Converting deeply to mutable types)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -557,7 +557,7 @@ export type NoInfer<A> = [A][A extends any ? 0 : never]
  * A value of type `Invariant<A>` cannot be assigned to `Invariant<B>` unless
  * `A` and `B` are the same type.
  *
- * **Example** (Invariant phantom type)
+ * **Example** (Defining an invariant phantom type)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -625,7 +625,7 @@ export declare namespace Invariant {
  * `Covariant<A>` is assignable to `Covariant<B>` when `A extends B`, following
  * the subtype direction.
  *
- * **Example** (Covariant phantom type)
+ * **Example** (Defining a covariant phantom type)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -693,7 +693,7 @@ export declare namespace Covariant {
  * `Contravariant<A>` is assignable to `Contravariant<B>` when `B extends A`,
  * following the supertype direction.
  *
- * **Example** (Contravariant phantom type)
+ * **Example** (Defining a contravariant phantom type)
  *
  * ```ts
  * import type { Types } from "effect"

package/src/internal/effect.ts

@@ -933,6 +933,11 @@ export const succeedNone: Effect.Effect<Option.Option<never>> = succeed(
   Option.none()
 )
 
+/** @internal */
+export const transposeOption = <A = never, E = never, R = never>(
+  self: Option.Option<Effect.Effect<A, E, R>>
+): Effect.Effect<Option.Option<A>, E, R> => Option.isNone(self) ? succeedNone : map(self.value, Option.some)
+
 /** @internal */
 export const failCauseSync = <E>(
   evaluate: LazyArg<Cause.Cause<E>>
@@ -950,17 +955,24 @@ const void_: Effect.Effect<void> = succeed(void 0)
 export { void_ as void }
 
 /** @internal */
-const try_ = <A, E>(options: {
-  try: LazyArg<A>
-  catch: (error: unknown) => E
-}): Effect.Effect<A, E> =>
-  suspend(() => {
+const try_ = <A, E = Cause.UnknownError>(
+  options: {
+    readonly try: LazyArg<A>
+    readonly catch: (error: unknown) => E
+  } | LazyArg<A>
+): Effect.Effect<A, E> => {
+  const evaluate = typeof options === "function" ? options : options.try
+  const catcher = typeof options === "function"
+    ? ((cause: unknown) => new UnknownError(cause, "An error occurred in Effect.try"))
+    : options.catch
+  return suspend(() => {
     try {
-      return succeed(internalCall(options.try))
+      return succeed(internalCall(evaluate))
     } catch (err) {
-      return fail(internalCall(() => options.catch(err)))
+      return fail(internalCall(() => catcher(err)) as E)
     }
   })
+}
 /** @internal */
 export { try_ as try }
 
@@ -987,15 +999,22 @@ export const tryPromise = <A, E = Cause.UnknownError>(
     ? ((cause: unknown) => new UnknownError(cause, "An error occurred in Effect.tryPromise"))
     : options.catch
   return callbackOptions<A, E>(function(resume, signal) {
+    const failWithCatch = (cause: unknown) => {
+      try {
+        resume(fail(internalCall(() => catcher(cause)) as E))
+      } catch (err) {
+        resume(die(err))
+      }
+    }
     try {
       internalCall(() => f(signal!)).then(
         (a) => resume(succeed(a)),
-        (e) => resume(fail(internalCall(() => catcher(e)) as E))
+        failWithCatch
       )
     } catch (err) {
-      resume(fail(internalCall(() => catcher(err)) as E))
+      failWithCatch(err)
     }
-  }, eval.length !== 0)
+  }, f.length !== 0)
 }
 
 /** @internal */

package/src/internal/schema/cause.ts

@@ -0,0 +1,26 @@
+import * as Cause from "../../Cause.ts"
+import * as SchemaIssue from "../../SchemaIssue.ts"
+
+/** @internal */
+export function getSchemaIssue(cause: Cause.Cause<SchemaIssue.Issue>): SchemaIssue.Issue | undefined {
+  let issue: SchemaIssue.Issue | undefined
+  for (const reason of cause.reasons) {
+    if (!Cause.isFailReason(reason) || !SchemaIssue.isIssue(reason.error)) {
+      return undefined
+    }
+    issue ??= reason.error
+  }
+  return issue
+}
+
+/** @internal */
+export function getSchemaIssueOrThrow(
+  cause: Cause.Cause<SchemaIssue.Issue>,
+  message: string
+): SchemaIssue.Issue {
+  const issue = getSchemaIssue(cause)
+  if (issue === undefined) {
+    throw new Error(message, { cause })
+  }
+  return issue
+}

package/src/internal/schema/schema.ts

@@ -1,5 +1,7 @@
+import * as Cause from "../../Cause.ts"
+import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
-import { flow } from "../../Function.ts"
+import * as Exit from "../../Exit.ts"
 import * as Pipeable from "../../Pipeable.ts"
 import type * as Schema from "../../Schema.ts"
 import * as SchemaAST from "../../SchemaAST.ts"
@@ -33,7 +35,8 @@ export function make<S extends Schema.Top>(ast: S["ast"], options?: object): S {
   }
   self.ast = ast
   self.rebuild = (ast: SchemaAST.AST) => make(ast, options)
-  self.makeEffect = flow(SchemaParser.makeEffect(self), Effect.mapErrorEager((issue) => new SchemaError(issue)))
+  self.makeEffect = (input: S["~type.make.in"], options?: Schema.MakeOptions) =>
+    mapSchemaIssueEffect(SchemaParser.makeEffect(self)(input, options))
   self.make = SchemaParser.make(self)
   self.makeOption = SchemaParser.makeOption(self)
   return self
@@ -42,23 +45,46 @@ export function make<S extends Schema.Top>(ast: S["ast"], options?: object): S {
 /** @internal */
 export const SchemaErrorTypeId = "~effect/Schema/SchemaError"
 
-// not internal
-export class SchemaError {
-  readonly [SchemaErrorTypeId] = SchemaErrorTypeId
-  readonly _tag = "SchemaError"
-  readonly name: string = "SchemaError"
+// purposefully not internal
+export class SchemaError extends Data.TaggedError("SchemaError")<{
   readonly issue: Issue
+}> {
+  readonly [SchemaErrorTypeId]: typeof SchemaErrorTypeId = SchemaErrorTypeId
   constructor(issue: Issue) {
-    this.issue = issue
+    super({ issue })
   }
-  get message() {
+  override get message() {
     return this.issue.toString()
   }
-  toString() {
+  override toString() {
     return `SchemaError(${this.message})`
   }
 }
 
+/** @internal */
+export function mapSchemaIssueEffect<A, R>(
+  self: Effect.Effect<A, Issue, R>
+): Effect.Effect<A, SchemaError, R> {
+  return Effect.catchCause(
+    self,
+    (cause) => Effect.failCauseSync(() => Cause.map(cause, (issue) => new SchemaError(issue)))
+  )
+}
+
+/** @internal */
+export function mapSchemaErrorEffect<A, R>(
+  self: Effect.Effect<A, SchemaError, R>
+): Effect.Effect<A, Issue, R> {
+  return Effect.catchCause(self, (cause) => Effect.failCauseSync(() => Cause.map(cause, (error) => error.issue)))
+}
+
+/** @internal */
+export function mapSchemaIssueExit<A>(exit: Exit.Exit<A, Issue>): Exit.Exit<A, SchemaError> {
+  return Exit.isSuccess(exit)
+    ? Exit.succeed(exit.value)
+    : Exit.failCause(Cause.map(exit.cause, (issue) => new SchemaError(issue)))
+}
+
 /** @internal */
 export const jsonReorder = makeReorder(getJsonPriority)
 

package/src/testing/TestSchema.ts

@@ -154,7 +154,7 @@ export class Asserts<S extends Schema.Top> {
    *
    * FastCheck generates arbitrary values matching the schema's `Type`. The assertion fails if any generated value does not round-trip. Pass `options.params` to control FastCheck parameters such as `numRuns`.
    *
-   * **Example** (Round-trip verification)
+   * **Example** (Verifying round trips)
    *
    * ```ts
    * import { Schema } from "effect"
@@ -338,7 +338,7 @@ export class Decoding<S extends Schema.Top> {
    *
    * Use to verify successful decoding for one input case.
    *
-   * **Example** (Identity and transformed decoding)
+   * **Example** (Testing identity and transformed decoding)
    *
    * ```ts
    * import { Schema } from "effect"
@@ -478,7 +478,7 @@ export class Encoding<S extends Schema.Top> {
    *
    * Use to verify successful encoding for one input case.
    *
-   * **Example** (Identity and transformed encoding)
+   * **Example** (Testing identity and transformed encoding)
    *
    * ```ts
    * import { Schema } from "effect"

package/src/unstable/ai/AiError.ts

@@ -181,7 +181,7 @@ export class NetworkError extends Schema.ErrorClass<NetworkError>(
  * Provider-specific metadata is namespaced by provider name. Each provider
  * value can contain arbitrary mutable JSON metadata or `null`.
  *
- * **Example** (Metadata shape)
+ * **Example** (Inspecting metadata shape)
  *
  * ```ts
  * const metadata = {

package/src/unstable/ai/Chat.ts

@@ -46,7 +46,7 @@ import type * as Tool from "./Tool.ts"
  * enabling persistent conversational AI interactions with full context
  * management.
  *
- * **Example** (Using the Chat service)
+ * **Example** (Accessing the Chat service)
  *
  * ```ts
  * import { Effect } from "effect"

package/src/unstable/cli/Prompt.ts

@@ -1422,7 +1422,7 @@ const runLoop = Effect.fnUntraced(
       yield* Effect.orDie(terminal.display(msg))
       if (loop.events) {
         const takeInput = Queue.take(input).pipe(
-          Effect.map((event) => ({ _tag: "Input" as const, event }))
+          Effect.map((input) => ({ _tag: "Input" as const, input }))
         )
         const result = yield* Effect.raceFirst(
           takeInput,

package/src/unstable/httpapi/HttpApiScalar.ts

@@ -87,7 +87,7 @@ export type ScalarConfig = {
   /**
    * Path to a favicon image.
    *
-   * **Example** (Relative favicon)
+   * **Example** (Setting a relative favicon)
    *
    * ```ts
    * const favicon = "/favicon.svg"
@@ -107,7 +107,7 @@ export type ScalarConfig = {
    * Browsers can derive the origin from `window.location.origin`; server
    * rendering needs this value supplied explicitly.
    *
-   * **Example** (Local server URL)
+   * **Example** (Setting a local server URL)
    *
    * ```ts
    * const baseServerURL = "http://localhost:3000"

package/src/unstable/httpapi/HttpApiSchema.ts

@@ -34,13 +34,18 @@ declare module "../../Schema.ts" {
 }
 
 /**
- * @internal
+ * HTTP API body encoding metadata used by payloads and responses.
+ *
+ * @category models
+ * @since 4.0.0
  */
 export type Encoding = PayloadEncoding | ResponseEncoding
 
 /**
- * Encodings for payloads
- * @internal
+ * HTTP API request payload encoding metadata.
+ *
+ * @category models
+ * @since 4.0.0
  */
 export type PayloadEncoding =
   | {
@@ -55,8 +60,10 @@ export type PayloadEncoding =
   }
 
 /**
- * Encodings for responses
- * @internal
+ * HTTP API response body encoding metadata.
+ *
+ * @category models
+ * @since 4.0.0
  */
 export type ResponseEncoding = {
   readonly _tag: "Json" | "FormUrlEncoded" | "Uint8Array" | "Text"
@@ -360,7 +367,12 @@ export interface StreamUint8Array extends
   readonly contentType: string
 }
 
-/** @internal */
+/**
+ * Schema for a streaming HTTP API success response.
+ *
+ * @category models
+ * @since 4.0.0
+ */
 export type StreamSchema = StreamSse<Sse.EventCodec, Schema.Top, unknown> | StreamUint8Array
 
 /** @internal */

package/src/unstable/rpc/Rpc.ts

@@ -955,7 +955,7 @@ export const make = <
 /**
  * Creates a custom `Rpc` constructor that can transform the output schemas.
  *
- * **Example** (Paginated RPC constructor)
+ * **Example** (Defining a paginated RPC constructor)
  *
  * ```ts
  * import { Schema } from "effect"

package/src/unstable/rpc/RpcGroup.ts

@@ -303,14 +303,13 @@ const RpcGroupProto = {
       const services = yield* Effect.context<never>()
       const handlers = Effect.isEffect(build) ? yield* build : build
       const contextMap = new Map<string, unknown>()
-      for (const [tag, handler] of Object.entries(handlers)) {
-        const rpc = self.requests.get(tag)!
+      self.requests.forEach((rpc, tag) => {
         contextMap.set(rpc.key, {
           tag: rpc._tag,
-          handler,
+          handler: handlers[tag],
           context: services
         })
-      }
+      })
       return Context.makeUnsafe(contextMap)
     })
   },