effect 4.0.0-beta.92 → 4.0.0-beta.94

package/src/LayerRef.ts

@@ -0,0 +1,379 @@
+/**
+ * Creates refreshable references to a single layer-built service context.
+ *
+ * A `LayerRef<I, E>` builds one `Layer` into a cached `Context<I>`, exposes it
+ * back as a layer or scoped effect, and supports invalidation so later users can
+ * acquire a fresh context.
+ *
+ * @since 4.0.0
+ */
+import * as Context from "./Context.ts"
+import type * as Duration from "./Duration.ts"
+import * as Effect from "./Effect.ts"
+import { identity } from "./Function.ts"
+import { getStackTraceLimit, setStackTraceLimit } from "./internal/stackTraceLimit.ts"
+import * as Layer from "./Layer.ts"
+import * as RcRef from "./RcRef.ts"
+import type * as Schedule from "./Schedule.ts"
+import * as Scope from "./Scope.ts"
+import type { Mutable } from "./Types.ts"
+
+const TypeId = "~effect/LayerRef"
+
+/**
+ * A refreshable reference to a single layer-built service context.
+ *
+ * **When to use**
+ *
+ * Use when you want to share one scoped layer resource across many users while
+ * retaining the ability to invalidate it and rebuild it later.
+ *
+ * **Details**
+ *
+ * A `LayerRef` is the unkeyed counterpart to a layer cache: it lazily builds the
+ * layer on first use, reuses the resulting context while it is borrowed or kept
+ * idle, and can invalidate the cached context so the next use rebuilds it.
+ *
+ * @see {@link make} for constructing a `LayerRef` from a layer
+ * @see {@link Service} for defining a `LayerRef` as a service class
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface LayerRef<in out I, in out E = never> {
+  readonly [TypeId]: typeof TypeId
+
+  /**
+   * The underlying reference-counted cache that stores the built context.
+   */
+  readonly rcRef: RcRef.RcRef<Context.Context<I>, E>
+
+  /**
+   * Layer that provides the currently cached context, acquiring it if needed.
+   */
+  readonly get: Layer.Layer<I, E>
+
+  /**
+   * Scoped effect that retrieves the currently cached context, acquiring it if needed.
+   */
+  readonly contextEffect: Effect.Effect<Context.Context<I>, E, Scope.Scope>
+
+  /**
+   * Invalidates the cached context so the next use rebuilds the layer.
+   */
+  readonly invalidate: Effect.Effect<void>
+
+  /**
+   * Invalidates the cached context so the next use rebuilds the layer, and
+   * reacquires it.
+   */
+  readonly refresh: Effect.Effect<void, E>
+}
+
+/**
+ * Creates a `LayerRef` from a `Layer`.
+ *
+ * **When to use**
+ *
+ * Use when you have one layer-built resource that should be shared, optionally
+ * kept alive while idle, and refreshed on demand.
+ *
+ * **Details**
+ *
+ * The layer is built lazily on first use unless `preload` is `true`.
+ * `idleTimeToLive` keeps the context cached after it stops being used, and
+ * `invalidationSchedule` can periodically invalidate it. When `preload` is
+ * `true`, scheduled invalidation also reacquires the context.
+ *
+ * **Gotchas**
+ *
+ * Invalidation does not revoke contexts already borrowed by active scopes; those
+ * contexts remain usable until their scopes close.
+ *
+ * **Example** (Sharing one layer-built service)
+ *
+ * ```ts
+ * import { Context, Effect, Layer } from "effect"
+ * import { make } from "effect/LayerRef"
+ *
+ * class Database extends Context.Service<Database, {
+ *   readonly query: Effect.Effect<string>
+ * }>()("Database") {}
+ *
+ * const databaseLayer = Layer.succeed(Database, {
+ *   query: Effect.succeed("result")
+ * })
+ *
+ * const query = Effect.gen(function*() {
+ *   const database = yield* Database
+ *   return yield* database.query
+ * })
+ *
+ * const program = Effect.scoped(
+ *   Effect.gen(function*() {
+ *     const ref = yield* make(databaseLayer, {
+ *       idleTimeToLive: "5 seconds"
+ *     })
+ *
+ *     const result = yield* Effect.provide(query, ref.get)
+ *
+ *     yield* ref.invalidate
+ *
+ *     return result
+ *   })
+ * )
+ * ```
+ *
+ * @see {@link Service} for defining a reusable service class around a `LayerRef`
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const make = Effect.fnUntraced(
+  function*<I, E, R, X, const Preload extends boolean = never, SE = never, SR = never>(
+    layer: Layer.Layer<I, E, R>,
+    options?: {
+      /**
+       * Duration to keep the resource alive after it is no longer used.
+       */
+      readonly idleTimeToLive?: Duration.Input | undefined
+      /**
+       * Whether to acquire the resource during creation.
+       */
+      readonly preload?: Preload | undefined
+      /**
+       * Schedule used to invalidate the cached resource. When `preload` is
+       * `true`, each scheduled invalidation also reacquires the resource.
+       */
+      readonly invalidationSchedule?: Schedule.Schedule<X, unknown, SE, SR> | undefined
+    } | undefined
+  ): Effect.fn.Return<
+    LayerRef<I, E>,
+    [Preload] extends [true] ? E : never,
+    Scope.Scope | R | SR
+  > {
+    const context = yield* Effect.context<never>()
+    const memoMap = Layer.CurrentMemoMap.forkOrCreate(context)
+
+    const rcRef = yield* RcRef.make({
+      acquire: Effect.contextWith((_: Context.Context<Scope.Scope>) =>
+        Layer.buildWithMemoMap(layer, memoMap, Context.get(_, Scope.Scope))
+      ),
+      idleTimeToLive: options?.idleTimeToLive
+    })
+
+    const refresh = RcRef.invalidate(rcRef).pipe(
+      Effect.andThen(Effect.scoped(RcRef.get(rcRef))),
+      Effect.asVoid
+    )
+
+    if (options?.preload) {
+      yield* refresh as Effect.Effect<void>
+    }
+
+    if (options?.invalidationSchedule) {
+      const onRefresh = options.preload ? refresh : RcRef.invalidate(rcRef)
+      yield* onRefresh.pipe(
+        Effect.ignoreCause,
+        Effect.schedule(options.invalidationSchedule),
+        Effect.forkScoped
+      )
+    }
+
+    return identity<LayerRef<I, any>>({
+      [TypeId]: TypeId,
+      rcRef,
+      get: Layer.effectContext(RcRef.get(rcRef)),
+      contextEffect: RcRef.get(rcRef),
+      invalidate: RcRef.invalidate(rcRef),
+      refresh
+    })
+  }
+)
+
+/**
+ * Service class shape produced by `LayerRef.Service`.
+ *
+ * **When to use**
+ *
+ * Use as the public type for classes returned by `LayerRef.Service` when an API
+ * needs to accept, return, or alias the generated service class and its static
+ * helpers.
+ *
+ * **Details**
+ *
+ * It combines a `Context.Service` tag for the `LayerRef` with default layers and
+ * helper accessors for retrieving, using, and invalidating the cached resource.
+ *
+ * @see {@link Service} for creating concrete `LayerRef` service classes
+ *
+ * @category services
+ * @since 4.0.0
+ */
+export interface TagClass<
+  in out Self,
+  in out Id extends string,
+  in out I,
+  in out E,
+  in out R,
+  in out LE,
+  in out Deps extends Layer.Layer<any, any, any>
+> extends Context.ServiceClass<Self, Id, LayerRef<I, E>> {
+  /**
+   * Default layer for the `LayerRef` service, with dependencies applied.
+   */
+  readonly layer: Layer.Layer<
+    Self,
+    (Deps extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never) | LE,
+    | Exclude<R, (Deps extends Layer.Layer<infer _A, infer _E, infer _R> ? _A : never)>
+    | (Deps extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never)
+  >
+
+  /**
+   * Default layer for the `LayerRef` service without provided dependencies.
+   */
+  readonly layerNoDeps: Layer.Layer<Self, LE, R>
+
+  /**
+   * Layer that provides the currently cached context, requiring this service.
+   */
+  readonly get: Layer.Layer<I, E, Self>
+
+  /**
+   * Scoped effect that retrieves the currently cached context through this service.
+   */
+  readonly contextEffect: Effect.Effect<Context.Context<I>, E, Scope.Scope | Self>
+
+  /**
+   * Invalidates the cached context through this service.
+   */
+  readonly invalidate: Effect.Effect<void, never, Self>
+
+  /**
+   * Invalidates the cached context through this service, and reacquires it.
+   */
+  readonly refresh: Effect.Effect<void, E, Self>
+}
+
+/**
+ * Creates a service class for a `LayerRef`.
+ *
+ * **When to use**
+ *
+ * Use when you want to name a shared layer reference as an application service
+ * and expose static helpers for providing, retrieving, and invalidating it.
+ *
+ * **Details**
+ *
+ * The returned class is a `Context.Service` whose value is a `LayerRef`. It also
+ * includes `.layer`, `.layerNoDeps`, `.get`, `.contextEffect`, and `.invalidate`
+ * helpers so callers do not need to access the `LayerRef` value directly.
+ *
+ * **Example** (Defining a refreshable service)
+ *
+ * ```ts
+ * import { Context, Effect, Layer } from "effect"
+ * import { Service } from "effect/LayerRef"
+ *
+ * class Database extends Context.Service<Database, {
+ *   readonly query: Effect.Effect<string>
+ * }>()("Database") {}
+ *
+ * const databaseLayer = Layer.succeed(Database, {
+ *   query: Effect.succeed("result")
+ * })
+ *
+ * class DatabaseRef extends Service<DatabaseRef>()("DatabaseRef", {
+ *   layer: databaseLayer,
+ *   preload: true
+ * }) {}
+ *
+ * const program = Effect.gen(function*() {
+ *   const database = yield* Database
+ *   return yield* database.query
+ * }).pipe(
+ *   Effect.provide(DatabaseRef.get),
+ *   Effect.provide(DatabaseRef.layer)
+ * )
+ * ```
+ *
+ * @see {@link make} for creating a `LayerRef` value without defining a service class
+ *
+ * @category services
+ * @since 4.0.0
+ */
+export const Service = <Self>() =>
+<
+  const Id extends string,
+  I,
+  E,
+  R,
+  X,
+  const Deps extends ReadonlyArray<Layer.Layer<any, any, any>> = [],
+  const Preload extends boolean = never,
+  SE = never,
+  SR = never
+>(
+  id: Id,
+  options: {
+    /**
+     * Layer used to build the cached context.
+     */
+    readonly layer: Layer.Layer<I, E, R>
+    /**
+     * Layers used to satisfy dependencies of the `LayerRef` service layer.
+     */
+    readonly dependencies?: Deps | undefined
+    /**
+     * Duration to keep the resource alive after it is no longer used.
+     */
+    readonly idleTimeToLive?: Duration.Input | undefined
+    /**
+     * Whether to acquire the resource during creation.
+     */
+    readonly preload?: Preload | undefined
+    /**
+     * Schedule used to invalidate the cached resource. When `preload` is
+     * `true`, each scheduled invalidation also reacquires the resource.
+     */
+    readonly invalidationSchedule?: Schedule.Schedule<X, unknown, SE, SR> | undefined
+  }
+): TagClass<
+  Self,
+  Id,
+  I,
+  E,
+  R | SR,
+  [Preload] extends [true] ? E : never,
+  Deps[number]
+> => {
+  const Err = globalThis.Error as any
+  const limit = getStackTraceLimit()
+  setStackTraceLimit(2)
+  const creationError = new Err()
+  setStackTraceLimit(limit)
+
+  function TagClass() {}
+  const TagClass_ = TagClass as any as Mutable<TagClass<Self, Id, any, any, any, any, any>>
+  Object.setPrototypeOf(TagClass, Object.getPrototypeOf(Context.Service<Self, any>(id)))
+  TagClass.key = id
+  Object.defineProperty(TagClass, "stack", {
+    get() {
+      return creationError.stack
+    }
+  })
+
+  TagClass_.layerNoDeps = Layer.effect(TagClass_)(
+    make(options.layer, options)
+  )
+  TagClass_.layer = options.dependencies && options.dependencies.length > 0 ?
+    Layer.provide(TagClass_.layerNoDeps, options.dependencies as any) :
+    TagClass_.layerNoDeps
+
+  TagClass_.get = Layer.unwrap(TagClass_.useSync((ref) => ref.get))
+  TagClass_.contextEffect = TagClass_.use((ref) => ref.contextEffect)
+  TagClass_.invalidate = TagClass_.use((ref) => ref.invalidate)
+  TagClass_.refresh = TagClass_.use((ref) => ref.refresh)
+
+  return TagClass as any
+}

package/src/Schema.ts

@@ -888,31 +888,6 @@ export declare namespace Codec {
   export type EncodingServices<S> = S extends { readonly "EncodingServices": infer R } ? R : never
 }
 
-/**
- * A schema that additionally supports optic (lens/prism) operations.
- *
- * **Details**
- *
- * `Optic<T, Iso>` extends {@link Schema}`<T>` with an `Iso` type that
- * describes the isomorphic counterpart used by the optic layer. Crucially,
- * decoding and encoding require *no* Effect services (`DecodingServices` and
- * `EncodingServices` are both `never`), which means the optic can operate
- * purely without an Effect runtime.
- *
- * Most primitive schemas (e.g. `Schema.String`, `Schema.Number`) implement
- * `Optic` automatically. You normally interact with this interface through
- * {@link Optic_} utilities rather than constructing it directly.
- *
- * @category models
- * @since 4.0.0
- */
-export interface Optic<out T, out Iso> extends Schema<T> {
-  readonly "Iso": Iso
-  readonly "DecodingServices": never
-  readonly "EncodingServices": never
-  readonly "Rebuild": Optic<T, Iso>
-}
-
 /**
  * A schema that tracks the decoded type `T`, the encoded type `E`, and the
  * Effect services required during decoding (`RD`) and encoding (`RE`).
@@ -924,8 +899,8 @@ export interface Optic<out T, out Iso> extends Schema<T> {
  * Most concrete schemas produced by this module implement `Codec`.
  *
  * For APIs that only need one direction, prefer the narrower views:
- * - {@link ConstraintDecoder}`<T, RD>` — decode-only
- * - {@link ConstraintEncoder}`<E, RE>` — encode-only
+ * - {@link Decoder}`<T, RD>` — decode-only
+ * - {@link Encoder}`<E, RE>` — encode-only
  * - {@link Schema}`<T>` — type-only (no encoded representation)
  *
  * **Example** (Accepting a codec that decodes to `number` from `string`)
@@ -953,6 +928,52 @@ export interface Codec<out T, out E = T, out RD = never, out RE = never> extends
   readonly "Rebuild": Codec<T, E, RD, RE>
 }
 
+/**
+ * A schema that tracks the decoded type `T` and the Effect services required
+ * during decoding (`RD`).
+ *
+ * **When to use**
+ *
+ * Use when you need to preserve a schema's decoded type and decoding service
+ * requirements, but do not need to constrain its encoded representation or
+ * encoding services.
+ *
+ * @see {@link Codec} for preserving both decoded and encoded type information.
+ * @see {@link Encoder} for the encode-only view.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface Decoder<out T, out RD = never> extends Schema<T> {
+  readonly "Encoded": unknown
+  readonly "DecodingServices": RD
+  readonly "EncodingServices": unknown
+  readonly "Rebuild": Decoder<T, RD>
+}
+
+/**
+ * A schema that tracks the encoded type `E` and the Effect services required
+ * during encoding (`RE`).
+ *
+ * **When to use**
+ *
+ * Use when you need to preserve a schema's encoded type and encoding service
+ * requirements, but do not need to constrain its decoded representation or
+ * decoding services.
+ *
+ * @see {@link Codec} for preserving both decoded and encoded type information.
+ * @see {@link Decoder} for the decode-only view.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface Encoder<out E, out RE = never> extends Schema<unknown> {
+  readonly "Encoded": E
+  readonly "DecodingServices": unknown
+  readonly "EncodingServices": RE
+  readonly "Rebuild": Encoder<E, RE>
+}
+
 /**
  * Returns a codec widened to the full {@link Codec} interface, prompting
  * TypeScript to infer all four type parameters (`T`, `E`, `RD`, `RE`).
@@ -982,6 +1003,31 @@ export function revealCodec<T, E, RD, RE>(codec: Codec<T, E, RD, RE>) {
   return codec
 }
 
+/**
+ * A schema that additionally supports optic (lens/prism) operations.
+ *
+ * **Details**
+ *
+ * `Optic<T, Iso>` extends {@link Schema}`<T>` with an `Iso` type that
+ * describes the isomorphic counterpart used by the optic layer. Crucially,
+ * decoding and encoding require *no* Effect services (`DecodingServices` and
+ * `EncodingServices` are both `never`), which means the optic can operate
+ * purely without an Effect runtime.
+ *
+ * Most primitive schemas (e.g. `Schema.String`, `Schema.Number`) implement
+ * `Optic` automatically. You normally interact with this interface through
+ * {@link Optic_} utilities rather than constructing it directly.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface Optic<out T, out Iso> extends Schema<T> {
+  readonly "Iso": Iso
+  readonly "DecodingServices": never
+  readonly "EncodingServices": never
+  readonly "Rebuild": Optic<T, Iso>
+}
+
 export {
   /**
    * Error thrown (or returned as the error channel value) when schema decoding
@@ -2757,7 +2803,7 @@ export declare namespace TemplateLiteralParser {
    */
   export type Type<Parts> = Parts extends readonly [infer Head, ...infer Tail] ? readonly [
       Head extends TemplateLiteral.LiteralPart ? Head :
-        Head extends Codec<infer T, unknown, unknown, unknown> ? T
+        Head extends ConstraintDecoder<infer T, unknown> ? T
         : never,
       ...Type<Tail>
     ]
@@ -10981,7 +11027,10 @@ export interface fromJsonString<S extends Constraint> extends decodeTo<S, String
  * @since 4.0.0
  */
 export function fromJsonString<S extends Constraint>(schema: S): fromJsonString<S> {
+  const identifier = SchemaAST.resolveIdentifier(schema.ast)
   return String.annotate({
+    // Give the transport wrapper its own name so the decoded payload keeps its identifier.
+    identifier: identifier === undefined ? undefined : `${identifier}JsonString`,
     expected: "a string that will be decoded as JSON",
     contentMediaType: "application/json",
     contentSchema: SchemaAST.toEncoded(schema.ast)
@@ -12609,7 +12658,8 @@ function getClassSchemaFactory<S extends Constraint>(
         {
           identifier,
           [SchemaAST.ClassTypeId]: ([from]: readonly [SchemaAST.AST]) => new SchemaAST.Link(from, transformation),
-          toCodec: ([from]: readonly [Codec<S["Encoded"]>]) => new SchemaAST.Link(from.ast, transformation),
+          toCodec: ([from]: readonly [ConstraintCodec<S["Encoded"], S["Encoded"]>]) =>
+            new SchemaAST.Link(from.ast, transformation),
           toArbitrary: ([from]: readonly [Annotations.ToArbitrary.TypeParameter<S["Type"]>]) => () => ({
             arbitrary: from.arbitrary.map((args: S["Type"]) => new self(args)),
             terminal: from.terminal?.map((args: S["Type"]) => new self(args))
@@ -13999,8 +14049,8 @@ type XmlEncoderOptions = {
  * @category Canonical Codecs
  * @since 4.0.0
  */
-export function toEncoderXml<T, E, RD, RE>(
-  codec: Codec<T, E, RD, RE>,
+export function toEncoderXml<T, RE>(
+  codec: ConstraintCodec<T, unknown, unknown, RE>,
   options?: XmlEncoderOptions
 ) {
   const rootName = InternalAnnotations.resolveIdentifier(codec.ast) ?? InternalAnnotations.resolveTitle(codec.ast)
@@ -14335,7 +14385,7 @@ export interface overrideToCodecIso<S extends Constraint, Iso> extends
  * @since 4.0.0
  */
 export function overrideToCodecIso<S extends Constraint, Iso>(
-  to: Codec<Iso>,
+  to: ConstraintCodec<Iso>,
   transformation: {
     readonly decode: SchemaGetter.Getter<S["Type"], Iso>
     readonly encode: SchemaGetter.Getter<Iso, S["Type"]>
@@ -14363,7 +14413,7 @@ export function overrideToCodecIso<S extends Constraint, Iso>(
  * @category converting
  * @since 4.0.0
  */
-export function toDifferJsonPatch<T, E>(schema: Codec<T, E>): Differ<T, JsonPatch.JsonPatch> {
+export function toDifferJsonPatch<T>(schema: ConstraintCodec<T, unknown>): Differ<T, JsonPatch.JsonPatch> {
   const serializer = toCodecJson(schema)
   const get = SchemaParser.encodeSync(serializer)
   const set = SchemaParser.decodeSync(serializer)

package/src/SchemaParser.ts

@@ -170,8 +170,8 @@ export function make<S extends Schema.Constraint>(schema: S) {
  * @category Asserting
  * @since 3.10.0
  */
-export function is<T>(schema: Schema.Schema<T>): <I>(input: I) => input is I & T {
-  return _is<T>(schema.ast)
+export function is<S extends Schema.Constraint>(schema: S): <I>(input: I) => input is I & S["Type"] {
+  return _is<S["Type"]>(schema.ast)
 }
 
 /** @internal */

package/src/internal/core.ts

@@ -87,7 +87,7 @@ export const StructuralProto = {
     const thatKeys = Object.keys(that)
     if (selfKeys.length !== thatKeys.length) return false
     for (let i = 0; i < selfKeys.length; i++) {
-      if (selfKeys[i] !== thatKeys[i] && !Equal.equals(this[selfKeys[i]], that[selfKeys[i]])) {
+      if (selfKeys[i] !== thatKeys[i] || !Equal.equals(this[selfKeys[i]], that[selfKeys[i]])) {
         return false
       }
     }

package/src/internal/effect.ts

@@ -310,7 +310,9 @@ export const causeSquash = <E>(self: Cause.Cause<E>): unknown => {
 }
 
 /** @internal */
-export const causePrettyErrors = <E>(self: Cause.Cause<E>): Array<Error> => {
+export const causePrettyErrors = <E>(self: Cause.Cause<E>, options?: {
+  readonly includeCauseInStack?: boolean | undefined
+}): Array<Error> => {
   const errors: Array<Error> = []
   const interrupts: Array<Cause.Interrupt> = []
   if (self.reasons.length === 0) return errors
@@ -326,7 +328,8 @@ export const causePrettyErrors = <E>(self: Cause.Cause<E>): Array<Error> => {
     errors.push(
       causePrettyError(
         failure._tag === "Die" ? failure.defect : failure.error as any,
-        failure.annotations
+        failure.annotations,
+        options
       )
     )
   }
@@ -337,7 +340,7 @@ export const causePrettyErrors = <E>(self: Cause.Cause<E>): Array<Error> => {
     const error = new globalThis.Error("All fibers interrupted without error", { cause })
     error.name = "InterruptError"
     error.stack = `${error.name}: ${error.message}`
-    errors.push(causePrettyError(error, interrupts[0].annotations))
+    errors.push(causePrettyError(error, interrupts[0].annotations, options))
   }
 
   setStackTraceLimit(prevStackLimit)
@@ -347,7 +350,10 @@ export const causePrettyErrors = <E>(self: Cause.Cause<E>): Array<Error> => {
 /** @internal */
 export const causePrettyError = (
   original: Record<string, unknown> | Error,
-  annotations?: ReadonlyMap<string, unknown>
+  annotations?: ReadonlyMap<string, unknown>,
+  options?: {
+    readonly includeCauseInStack?: boolean | undefined
+  }
 ): Error => {
   const kind = typeof original
   let error: Error
@@ -364,6 +370,9 @@ export const causePrettyError = (
       const stack = `${error.name}: ${error.message}`
       error.stack = annotations ? addStackAnnotations(stack, annotations) : stack
     }
+    if (options?.includeCauseInStack) {
+      error.stack = renderPrettyError(error)!
+    }
     for (const key of Object.keys(original)) {
       if (!(key in error)) {
         ;(error as any)[key] = (original as any)[key]
@@ -461,8 +470,7 @@ const currentStackTrace = (frame: StackFrame): string => {
 export const causePretty = <E>(cause: Cause.Cause<E>): string =>
   causePrettyErrors<E>(cause).map(renderPrettyError).join("\n")
 
-/** @internal */
-export const renderPrettyError = (e: Error): string | undefined =>
+const renderPrettyError = (e: Error): string | undefined =>
   e.cause ? `${e.stack} {\n${renderErrorCause(e.cause as Error, "  ")}\n}` : e.stack
 
 const renderErrorCause = (cause: Error, prefix: string) => {
@@ -2073,6 +2081,25 @@ export const contextWith = <R, A, E, R2>(
   f: (context: Context.Context<R>) => Effect.Effect<A, E, R2>
 ): Effect.Effect<A, E, R | R2> => withFiber((fiber) => f(fiber.context as Context.Context<R>))
 
+/** @internal */
+export const setContext: {
+  <R>(
+    context: Context.Context<R>
+  ): <A, E>(
+    self: Effect.Effect<A, E, R>
+  ) => Effect.Effect<A, E>
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
+    context: Context.Context<R>
+  ): Effect.Effect<A, E>
+} = dual(
+  2,
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
+    context: Context.Context<R>
+  ): Effect.Effect<A, E> => updateContext(self, constant(context))
+)
+
 /** @internal */
 export const provideContext: {
   <XR>(

package/src/testing/TestSchema.ts

@@ -167,7 +167,7 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * @see {@link arbitrary} for checking that generated values satisfy the schema
    */
-  verifyLosslessTransformation<S extends Schema.Codec<unknown, unknown>>(this: Asserts<S>, options?: {
+  verifyLosslessTransformation<S extends Schema.ConstraintCodec<unknown, unknown>>(this: Asserts<S>, options?: {
     readonly params?: FastCheck.Parameters<[S["Type"]]>
   }) {
     const decodeUnknownEffect = SchemaParser.decodeUnknownEffect(this.schema)
@@ -272,7 +272,7 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * @see {@link verifyLosslessTransformation} for property-based round-trip checks
    */
-  arbitrary<S extends Schema.Codec<unknown, unknown, never, unknown>>(this: Asserts<S>) {
+  arbitrary<S extends Schema.ConstraintCodec<unknown, unknown>>(this: Asserts<S>) {
     const schema = this.schema
     return {
       verifyGeneration(options?: {

package/src/unstable/ai/Chat.ts

@@ -336,7 +336,7 @@ export interface Service {
    */
   readonly generateObject: <
     ObjectEncoded extends Record<string, any>,
-    ObjectSchema extends Schema.Codec<unknown, ObjectEncoded, unknown, unknown>,
+    ObjectSchema extends Schema.Encoder<ObjectEncoded, unknown>,
     Options extends NoExcessProperties<LanguageModel.GenerateObjectOptions<any, ObjectSchema>, Options>
   >(
     options: Options & LanguageModel.GenerateObjectOptions<LanguageModel.ExtractTools<Options>, ObjectSchema>