effect 4.0.0-beta.93 → 4.0.0-beta.97

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>
     ]
@@ -10405,6 +10451,8 @@ const DateString = String.annotate({ expected: "a string in ISO 8601 format that
  * ```
  *
  * @see {@link DateValid} for accepting only valid Date instances
+ * @see {@link DateFromString} for decoding strings into Date instances
+ * @see {@link DateFromMillis} for decoding epoch milliseconds into Date instances
  *
  * @category Date
  * @since 4.0.0
@@ -10464,6 +10512,8 @@ export interface DateFromString extends decodeTo<Date, String> {
  *
  * Invalid date strings can decode to invalid `Date` instances.
  *
+ * @see {@link DateFromMillis} for decoding epoch milliseconds into Date instances
+ * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values
  * @see {@link Date} for accepting Date instances directly
  * @see {@link DateValid} for rejecting invalid Date instances
  *
@@ -10472,6 +10522,47 @@ export interface DateFromString extends decodeTo<Date, String> {
  */
 export const DateFromString: DateFromString = DateString.pipe(decodeTo(Date, SchemaTransformation.dateFromString))
 
+/**
+ * Type-level representation of {@link DateFromMillis}.
+ *
+ * @category Date
+ * @since 4.0.0
+ */
+export interface DateFromMillis extends decodeTo<Date, Number> {
+  readonly "Rebuild": DateFromMillis
+}
+
+/**
+ * Schema that decodes epoch milliseconds into a JavaScript `Date`.
+ *
+ * **When to use**
+ *
+ * Use to model numeric millisecond timestamps that decode to JavaScript `Date`
+ * objects and encode back to numbers.
+ *
+ * **Details**
+ *
+ * Decoding:
+ * A number of milliseconds since the Unix epoch is decoded as a `Date`.
+ *
+ * Encoding:
+ * A `Date` is encoded as its millisecond timestamp.
+ *
+ * **Gotchas**
+ *
+ * This schema accepts any number, including `NaN`, `Infinity`, and `-Infinity`.
+ * Those values decode to invalid `Date` instances.
+ *
+ * @see {@link DateFromString} for decoding string-encoded dates
+ * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
+ *
+ * @category Date
+ * @since 4.0.0
+ */
+export const DateFromMillis: DateFromMillis = Number.pipe(
+  decodeTo(Date, SchemaTransformation.dateFromMillis)
+)
+
 /**
  * Type-level representation of {@link DateValid}.
  *
@@ -12018,6 +12109,10 @@ export interface DateTimeUtcFromString extends decodeTo<DateTimeUtc, String> {
  *
  * - A `DateTime.Utc` is encoded as a UTC ISO 8601 string.
  *
+ * @see {@link DateTimeUtcFromDate} for decoding JavaScript Date values into UTC values
+ * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
+ * @see {@link DateFromString} for decoding strings into JavaScript Date instances
+ *
  * @category DateTime
  * @since 4.0.0
  */
@@ -12051,6 +12146,10 @@ export interface DateTimeUtcFromMillis extends decodeTo<instanceOf<DateTime.Utc>
  * Encoding:
  * - A `DateTime.Utc` is encoded as a number of milliseconds since the Unix epoch.
  *
+ * @see {@link DateTimeUtcFromDate} for decoding JavaScript Date values into UTC values
+ * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values
+ * @see {@link DateFromMillis} for decoding epoch milliseconds into JavaScript Date instances
+ *
  * @category DateTime
  * @since 4.0.0
  */
@@ -12612,7 +12711,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))
@@ -14002,8 +14102,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)
@@ -14338,7 +14438,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"]>
@@ -14366,7 +14466,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/SchemaTransformation.ts

@@ -871,7 +871,7 @@ export const bigintFromString = new Transformation(
  * )
  * ```
  *
- * @see {@link numberFromString}
+ * @see {@link dateFromMillis}
  * @see {@link dateTimeUtcFromString}
  *
  * @category Coercions
@@ -882,6 +882,46 @@ export const dateFromString: Transformation<globalThis.Date, string> = new Trans
   SchemaGetter.transform(formatDate)
 )
 
+/**
+ * Decodes epoch milliseconds into a `Date` and encodes a `Date` back to epoch
+ * milliseconds.
+ *
+ * **When to use**
+ *
+ * Use when you need a schema transformation for numeric timestamps represented
+ * as milliseconds since the Unix epoch.
+ *
+ * **Details**
+ *
+ * Decoding creates a `Date` from the number like `new Date(ms)`. Encoding
+ * returns the `Date` timestamp like `date.getTime()`.
+ *
+ * **Gotchas**
+ *
+ * This transformation does not validate date validity. `NaN`, `Infinity`, and
+ * `-Infinity` decode to invalid `Date` instances.
+ *
+ * **Example** (Converting milliseconds to a Date)
+ *
+ * ```ts
+ * import { Schema, SchemaTransformation } from "effect"
+ *
+ * const schema = Schema.Number.pipe(
+ *   Schema.decodeTo(Schema.Date, SchemaTransformation.dateFromMillis)
+ * )
+ * ```
+ *
+ * @see {@link dateFromString}
+ * @see {@link SchemaGetter.dateTimeUtcFromInput}
+ *
+ * @category Coercions
+ * @since 4.0.0
+ */
+export const dateFromMillis: Transformation<globalThis.Date, number> = new Transformation(
+  SchemaGetter.Date(),
+  SchemaGetter.transform((date) => date.getTime())
+)
+
 /**
  * Decodes a `string` into a `Duration` and encodes a `Duration` back to a
  * parseable `string`.
@@ -1762,8 +1802,8 @@ export const timeZoneFromString: Transformation<DateTime.TimeZone, string> = tra
  * UTC, and fails with `InvalidValue` when parsing fails. Encode uses
  * `DateTime.formatIso`.
  *
- * @see {@link dateTimeZonedFromString} for ISO strings that should preserve zoned date-time information
  * @see {@link dateFromString} for decoding into JavaScript `Date`
+ * @see {@link dateTimeZonedFromString} for ISO strings that should preserve zoned date-time information
  *
  * @category transforming
  * @since 4.0.0

package/src/Stream.ts

@@ -1471,7 +1471,7 @@ export const fromAsyncIterable = <A, E>(
  *
  * const program = Effect.gen(function*() {
  *   const schedule = Schedule.spaced("50 millis").pipe(
- *     Schedule.both(Schedule.recurs(2))
+ *     Schedule.upTo({ times: 3 })
  *   )
  *   const stream = Stream.fromSchedule(schedule)
  *   const values = yield* Stream.runCollect(stream)

package/src/internal/effect.ts

@@ -2081,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>

package/src/unstable/ai/LanguageModel.ts

@@ -124,7 +124,7 @@ export interface Service {
    */
   readonly generateObject: <
     ObjectEncoded extends Record<string, any>,
-    StructuredOutputSchema extends Schema.Codec<unknown, ObjectEncoded, unknown, unknown>,
+    StructuredOutputSchema extends Schema.Encoder<ObjectEncoded, unknown>,
     Options extends NoExcessProperties<
       GenerateObjectOptions<any, StructuredOutputSchema>,
       Options
@@ -835,7 +835,7 @@ export const make: (params: {
 
   const generateObject = <
     ObjectEncoded extends Record<string, any>,
-    StructuredOutputSchema extends Schema.Codec<unknown, ObjectEncoded, unknown, unknown>,
+    StructuredOutputSchema extends Schema.Encoder<ObjectEncoded, unknown>,
     Options extends NoExcessProperties<
       GenerateObjectOptions<any, StructuredOutputSchema>,
       Options
@@ -1691,7 +1691,7 @@ export const generateText: {
  */
 export const generateObject = <
   ObjectEncoded extends Record<string, any>,
-  StructuredOutputSchema extends Schema.Codec<unknown, ObjectEncoded, unknown, unknown>,
+  StructuredOutputSchema extends Schema.Encoder<ObjectEncoded, unknown>,
   Options extends NoExcessProperties<
     GenerateObjectOptions<any, StructuredOutputSchema>,
     Options

package/src/unstable/cli/Argument.ts

@@ -401,8 +401,8 @@ export const withDefault: {
    * @since 4.0.0
    */
   <A, const B>(
-   self: Argument<A>,
-   defaultValue: B | Effect.Effect<B, CliError.CliError, Environment>
+    self: Argument<A>,
+    defaultValue: B | Effect.Effect<B, CliError.CliError, Environment>
   ): Argument<A | B>
 } = Param.withDefault
 
@@ -729,8 +729,8 @@ export const mapEffect: {
    * @since 4.0.0
    */
   <A, B>(
-   self: Argument<A>,
-   f: (a: A) => Effect.Effect<B, CliError.CliError, Environment>
+    self: Argument<A>,
+    f: (a: A) => Effect.Effect<B, CliError.CliError, Environment>
   ): Argument<B>
 } = dual(2, <A, B>(
   self: Argument<A>,
@@ -982,7 +982,7 @@ export const withSchema: {
    * @category combinators
    * @since 4.0.0
    */
-  <A, B>(schema: Schema.Codec<B, A, Environment, Environment>): (self: Argument<A>) => Argument<B>
+  <A, B>(schema: Schema.ConstraintCodec<B, A, Environment, unknown>): (self: Argument<A>) => Argument<B>
   /**
    * Validates parsed values against a Schema.
    *
@@ -1000,8 +1000,15 @@ export const withSchema: {
    * @category combinators
    * @since 4.0.0
    */
-  <A, B>(self: Argument<A>, schema: Schema.Codec<B, A, Environment, Environment>): Argument<B>
-} = dual(2, <A, B>(self: Argument<A>, schema: Schema.Codec<B, A>) => Param.withSchema(self, schema))
+  <A, B>(
+    self: Argument<A>,
+    schema: Schema.ConstraintCodec<B, A, Environment, unknown>
+  ): Argument<B>
+} = dual(
+  2,
+  <A, B>(self: Argument<A>, schema: Schema.ConstraintCodec<B, A, Environment, unknown>): Argument<B> =>
+    Param.withSchema(self, schema)
+)
 
 /**
  * Creates a positional choice argument with custom value mapping.

package/src/unstable/cli/Flag.ts

@@ -1782,7 +1782,7 @@ export const withSchema: {
    * @category schemas
    * @since 4.0.0
    */
-  <A, B>(schema: Schema.Codec<B, A, Environment, Environment>): (self: Flag<A>) => Flag<B>
+  <A, B>(schema: Schema.ConstraintCodec<B, A, Environment, unknown>): (self: Flag<A>) => Flag<B>
   /**
    * Validates and transforms a flag value using a Schema codec.
    *
@@ -1820,5 +1820,8 @@ export const withSchema: {
    * @category schemas
    * @since 4.0.0
    */
-  <A, B>(self: Flag<A>, schema: Schema.Codec<B, A, Environment, Environment>): Flag<B>
-} = dual(2, <A, B>(self: Flag<A>, schema: Schema.Codec<B, A>) => Param.withSchema(self, schema))
+  <A, B>(self: Flag<A>, schema: Schema.ConstraintCodec<B, A, Environment, unknown>): Flag<B>
+} = dual(
+  2,
+  <A, B>(self: Flag<A>, schema: Schema.ConstraintCodec<B, A, Environment, unknown>) => Param.withSchema(self, schema)
+)

package/src/unstable/cli/Param.ts

@@ -2430,7 +2430,7 @@ export const withSchema: {
    * @category combinators
    * @since 4.0.0
    */
-  <A, B>(schema: Schema.Codec<B, A, Environment, Environment>): <Kind extends ParamKind>(
+  <A, B>(schema: Schema.ConstraintCodec<B, A, Environment, unknown>): <Kind extends ParamKind>(
     self: Param<Kind, A>
   ) => Param<Kind, B>
   /**
@@ -2455,10 +2455,13 @@ export const withSchema: {
    * @category combinators
    * @since 4.0.0
    */
-  <Kind extends ParamKind, A, B>(self: Param<Kind, A>, schema: Schema.Codec<B, A, Environment, Environment>): Param<Kind, B>
+  <Kind extends ParamKind, A, B>(
+    self: Param<Kind, A>,
+    schema: Schema.ConstraintCodec<B, A, Environment, unknown>
+  ): Param<Kind, B>
 } = dual(2, <Kind extends ParamKind, A, B>(
   self: Param<Kind, A>,
-  schema: Schema.Codec<B, A>
+  schema: Schema.ConstraintCodec<B, A, Environment, unknown>
 ) => {
   const decodeParam = Schema.decodeUnknownEffect(schema)
   return mapEffect(self, (value) =>

package/src/unstable/cli/Primitive.ts

@@ -105,9 +105,9 @@ const makePrimitive = <A>(
     parse
   })
 
-const makeSchemaPrimitive = <T, E>(
+const makeSchemaPrimitive = <T>(
   tag: string,
-  schema: Schema.Codec<T, E, Environment, Environment>
+  schema: Schema.ConstraintDecoder<T, Environment>
 ): Primitive<T> => {
   const toCodecStringTree = Schema.toCodecStringTree(schema)
   const decode = Schema.decodeUnknownEffect(toCodecStringTree)

package/src/unstable/cluster/ClusterCron.ts

@@ -147,9 +147,10 @@ export const make = <E, R>(options: {
   return Layer.merge(InitialRun, EntityLayer)
 }
 
-const retryPolicy = Schedule.exponential(200, 1.5).pipe(
-  Schedule.either(Schedule.spaced("1 minute"))
-)
+const retryPolicy = Schedule.min([
+  Schedule.exponential(200, 1.5),
+  Schedule.spaced("1 minute")
+])
 
 class CronPayload extends Schema.Class<CronPayload>("effect/cluster/ClusterCron/CronPayload")({
   dateTime: Schema.DateTimeUtc

package/src/unstable/cluster/ClusterWorkflowEngine.ts

@@ -133,6 +133,7 @@ export const make = Effect.gen(function*() {
       if (!entity) {
         return yield* Effect.die(`Workflow ${workflowName} not registered`)
       }
+      yield* RcMap.invalidate(clientsPartial, workflowName)
       return yield* entity.client
     }),
     idleTimeToLive: "5 minutes"
@@ -625,9 +626,10 @@ export const make = Effect.gen(function*() {
   return engine
 })
 
-const retryPolicy = Schedule.exponential(200, 1.5).pipe(
-  Schedule.either(Schedule.spaced("1 minute"))
-)
+const retryPolicy = Schedule.min([
+  Schedule.exponential(200, 1.5),
+  Schedule.spaced("1 minute")
+])
 
 const ensureSuccess = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
   effect.pipe(

package/src/unstable/cluster/Entity.ts

@@ -618,11 +618,7 @@ export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE,
       Rpc.ServicesClient<Rpcs> | Rpc.ServicesServer<Rpcs> | Rpc.Middleware<Rpcs> | LR
     >
     readonly concurrency: number | "unbounded"
-    readonly build: Effect.Effect<
-      Context.Context<Rpc.ToHandler<Rpcs>>,
-      never,
-      Scope | CurrentAddress
-    >
+    readonly build: Effect.Effect<Context.Context<Rpc.ToHandler<Rpcs>>>
   }>()
   const sharding = shardingTag.of({
     ...({} as Sharding["Service"]),
@@ -631,13 +627,7 @@ export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE,
         entityMap.set(entity.type, {
           context: context as any,
           concurrency: options?.concurrency ?? 1,
-          build: entity.protocol.toHandlers(handlers as any).pipe(
-            Effect.provideContext(Context.mutate(context, (context) =>
-              context.pipe(
-                Context.add(CurrentRunnerAddress, runnerAddress),
-                Context.omit(Scope)
-              )))
-          ) as any
+          build: entity.protocol.toHandlers(handlers as any) as any
         })
         return Effect.void
       })
@@ -654,8 +644,15 @@ export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE,
       entityId: entityId as EntityId,
       shardId: makeShardId(entityId)
     })
+    const scope = yield* Effect.scope
+    const handlerContext = Context.mutate(entityEntry.context, (context) =>
+      context.pipe(
+        Context.add(CurrentRunnerAddress, runnerAddress),
+        Context.add(CurrentAddress, address),
+        Context.add(Scope, scope)
+      ))
     const handlers = yield* entityEntry.build.pipe(
-      Effect.provideService(CurrentAddress, address)
+      Effect.setContext(handlerContext as Context.Context<any>)
     )
 
     // oxlint-disable-next-line prefer-const
@@ -665,7 +662,9 @@ export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE,
       onFromServer(response) {
         return client.write(response)
       }
-    }).pipe(Effect.provide(handlers))
+    }).pipe(
+      Effect.setContext(Context.merge(handlerContext, handlers))
+    )
 
     client = yield* RpcClient.makeNoSerialization(entity.protocol, {
       supportsAck: true,