effect 3.15.4 → 3.16.0

package/src/LayerMap.ts

@@ -5,9 +5,12 @@
 import * as Context from "./Context.js"
 import type * as Duration from "./Duration.js"
 import * as Effect from "./Effect.js"
+import * as FiberRefsPatch from "./FiberRefsPatch.js"
 import { identity } from "./Function.js"
+import * as core from "./internal/core.js"
 import * as Layer from "./Layer.js"
 import * as RcMap from "./RcMap.js"
+import * as Runtime from "./Runtime.js"
 import * as Scope from "./Scope.js"
 import type { Mutable } from "./Types.js"
 
@@ -28,24 +31,26 @@ export type TypeId = typeof TypeId
  * @category Models
  * @experimental
  */
-export interface LayerMap<in K, in out I, out S, out E = never> {
+export interface LayerMap<in K, in out I, out E = never> {
   readonly [TypeId]: TypeId
 
   /**
    * The internal RcMap that stores the resources.
    */
-  readonly rcMap: RcMap.RcMap<K, readonly [Context.Context<I>, S], E>
+  readonly rcMap: RcMap.RcMap<K, {
+    readonly layer: Layer.Layer<I, E>
+    readonly runtimeEffect: Effect.Effect<Runtime.Runtime<I>, E, Scope.Scope>
+  }, E>
 
   /**
-   * Retrieves an instance of the resource associated with the key.
+   * Retrieves a Layer for the resources associated with the key.
    */
-  get(key: K): Effect.Effect<S, E, Scope.Scope>
+  get(key: K): Layer.Layer<I, E>
 
   /**
-   * Provides an instance of the resource associated with the key
-   * to the given effect.
+   * Retrieves a Runtime for the resources associated with the key.
    */
-  provide(key: K): <A, EX, R>(effect: Effect.Effect<A, EX, R>) => Effect.Effect<A, EX | E, Exclude<R, I>>
+  runtime(key: K): Effect.Effect<Runtime.Runtime<I>, E, Scope.Scope>
 
   /**
    * Invalidates the resource associated with the key.
@@ -62,56 +67,54 @@ export interface LayerMap<in K, in out I, out S, out E = never> {
  * dynamically access resources based on a key.
  *
  * ```ts
- * import { Completions } from "@effect/ai"
- * import { OpenAiClient, OpenAiCompletions } from "@effect/ai-openai"
- * import { FetchHttpClient } from "@effect/platform"
  * import { NodeRuntime } from "@effect/platform-node"
- * import { Config, Effect, Layer, LayerMap } from "effect"
+ * import { Context, Effect, FiberRef, Layer, LayerMap } from "effect"
  *
- * // create the openai client layer
- * const OpenAiLayer = OpenAiClient.layerConfig({
- *   apiKey: Config.redacted("OPENAI_API_KEY")
- * }).pipe(Layer.provide(FetchHttpClient.layer))
+ * class Greeter extends Context.Tag("Greeter")<Greeter, {
+ *   greet: Effect.Effect<string>
+ * }>() {}
  *
  * // create a service that wraps a LayerMap
- * class AiClients extends LayerMap.Service<AiClients>()("AiClients", {
- *   // this LayerMap will provide the ai Completions service
- *   provides: Completions.Completions,
- *
+ * class GreeterMap extends LayerMap.Service<GreeterMap>()("GreeterMap", {
  *   // define the lookup function for the layer map
  *   //
- *   // The returned Layer will be used to provide the Completions service for the
- *   // given model.
- *   lookup: (model: OpenAiCompletions.Model) => OpenAiCompletions.layer({ model }),
+ *   // The returned Layer will be used to provide the Greeter service for the
+ *   // given name.
+ *   lookup: (name: string) =>
+ *     Layer.succeed(Greeter, {
+ *       greet: Effect.succeed(`Hello, ${name}!`)
+ *     }).pipe(
+ *       Layer.merge(Layer.locallyScoped(FiberRef.currentConcurrency, 123))
+ *     ),
  *
  *   // If a layer is not used for a certain amount of time, it can be removed
  *   idleTimeToLive: "5 seconds",
  *
  *   // Supply the dependencies for the layers in the LayerMap
- *   dependencies: [OpenAiLayer]
+ *   dependencies: []
  * }) {}
  *
  * // usage
- * Effect.gen(function*() {
- *   // access and use the generic Completions service
- *   const ai = yield* Completions.Completions
- *   const response = yield* ai.create("Hello, world!")
- *   console.log(response.text)
+ * const program: Effect.Effect<void, never, GreeterMap> = Effect.gen(function*() {
+ *   // access and use the Greeter service
+ *   const greeter = yield* Greeter
+ *   yield* Effect.log(yield* greeter.greet)
  * }).pipe(
- *   // use the AiClients service to provide a variant of the Completions service
- *   AiClients.provide("gpt-4o"),
- *   // provide the LayerMap service
- *   Effect.provide(AiClients.Default),
+ *   // use the GreeterMap service to provide a variant of the Greeter service
+ *   Effect.provide(GreeterMap.get("John"))
+ * )
+ *
+ * // run the program
+ * program.pipe(
+ *   Effect.provide(GreeterMap.Default),
  *   NodeRuntime.runMain
  * )
  * ```
  */
 export const make: <
-  Accessor extends Context.Tag<any, any> | Effect.Effect<any, any, any>,
   K,
-  L extends Layer.Layer<Exclude<Effect.Effect.Context<Accessor>, Scope.Scope>, any, any>
+  L extends Layer.Layer<any, any, any>
 >(
-  tagOrAccessor: Accessor,
   lookup: (key: K) => L,
   options?: {
     readonly idleTimeToLive?: Duration.DurationInput | undefined
@@ -119,15 +122,13 @@ export const make: <
 ) => Effect.Effect<
   LayerMap<
     K,
-    Exclude<Effect.Effect.Context<Accessor>, Scope.Scope>,
-    Effect.Effect.Success<Accessor>,
-    Effect.Effect.Error<Accessor> | (L extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never)
+    L extends Layer.Layer<infer _A, infer _E, infer _R> ? _A : never,
+    L extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never
   >,
   never,
   Scope.Scope | (L extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never)
-> = Effect.fnUntraced(function*<I, S, K, EL, RL, E = never>(
-  tagOrAccessor: Effect.Effect<S, E, I>,
-  lookup: (key: K) => Layer.Layer<Exclude<I, Scope.Scope>, EL, RL>,
+> = Effect.fnUntraced(function*<I, K, EL, RL>(
+  lookup: (key: K) => Layer.Layer<I, EL, RL>,
   options?: {
     readonly idleTimeToLive?: Duration.DurationInput | undefined
   } | undefined
@@ -141,28 +142,43 @@ export const make: <
     : yield* Layer.makeMemoMap
 
   const rcMap = yield* RcMap.make({
-    lookup: Effect.fnUntraced(function*(key: K) {
-      const scope = yield* Effect.scope
-      const context = yield* (Layer.buildWithMemoMap(lookup(key), memoMap, scope) as Effect.Effect<
-        Context.Context<Exclude<I, Scope.Scope>>
-      >)
-      const service = yield* (Effect.provide(tagOrAccessor, context) as Effect.Effect<S>)
-      return [context, service] as const
-    }),
+    lookup: (key: K) =>
+      Effect.scopeWith((scope) => Effect.diffFiberRefs(Layer.buildWithMemoMap(lookup(key), memoMap, scope))).pipe(
+        Effect.map(([patch, context]) => ({
+          layer: Layer.scopedContext(
+            core.withFiberRuntime<Context.Context<I>, any, Scope.Scope>((fiber) => {
+              const scope = Context.unsafeGet(fiber.currentContext, Scope.Scope)
+              const oldRefs = fiber.getFiberRefs()
+              const newRefs = FiberRefsPatch.patch(patch, fiber.id(), oldRefs)
+              const revert = FiberRefsPatch.diff(newRefs, oldRefs)
+              fiber.setFiberRefs(newRefs)
+              return Effect.as(
+                Scope.addFinalizerExit(scope, () => {
+                  fiber.setFiberRefs(FiberRefsPatch.patch(revert, fiber.id(), fiber.getFiberRefs()))
+                  return Effect.void
+                }),
+                context
+              )
+            })
+          ),
+          runtimeEffect: Effect.withFiberRuntime<Runtime.Runtime<I>, any, Scope.Scope>((fiber) => {
+            const fiberRefs = FiberRefsPatch.patch(patch, fiber.id(), fiber.getFiberRefs())
+            return Effect.succeed(Runtime.make({
+              context,
+              fiberRefs,
+              runtimeFlags: Runtime.defaultRuntime.runtimeFlags
+            }))
+          })
+        } as const))
+      ),
     idleTimeToLive: options?.idleTimeToLive
   })
 
-  return identity<LayerMap<K, Exclude<I, Scope.Scope>, S, any>>({
+  return identity<LayerMap<K, Exclude<I, Scope.Scope>, any>>({
     [TypeId]: TypeId,
     rcMap,
-    get: (key) => Effect.map(RcMap.get(rcMap, key), ([, service]) => service),
-    provide: (key) => (effect) =>
-      Effect.scopedWith((scope) =>
-        Effect.flatMap(
-          Scope.extend(RcMap.get(rcMap, key), scope),
-          ([context]) => Effect.provide(effect, context)
-        )
-      ),
+    get: (key) => Layer.unwrapScoped(Effect.map(RcMap.get(rcMap, key), ({ layer }) => layer)),
+    runtime: (key) => Effect.flatMap(RcMap.get(rcMap, key), ({ runtimeEffect }) => runtimeEffect),
     invalidate: (key) => RcMap.invalidate(rcMap, key)
   })
 })
@@ -173,10 +189,8 @@ export const make: <
  * @experimental
  */
 export const fromRecord = <
-  Accessor extends Context.Tag<any, any> | Effect.Effect<any, any, any>,
-  const Layers extends Record<string, Layer.Layer<Exclude<Effect.Effect.Context<Accessor>, Scope.Scope>, any, any>>
+  const Layers extends Record<string, Layer.Layer<any, any, any>>
 >(
-  tagOrAccessor: Accessor,
   layers: Layers,
   options?: {
     readonly idleTimeToLive?: Duration.DurationInput | undefined
@@ -184,14 +198,12 @@ export const fromRecord = <
 ): Effect.Effect<
   LayerMap<
     keyof Layers,
-    Exclude<Effect.Effect.Context<Accessor>, Scope.Scope>,
-    Effect.Effect.Success<Accessor>,
-    | Effect.Effect.Error<Accessor>
-    | (Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never)
+    Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _A : never,
+    Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never
   >,
   never,
   Scope.Scope | (Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never)
-> => make(tagOrAccessor, (key: keyof Layers) => layers[key], options)
+> => make((key: keyof Layers) => layers[key], options)
 
 /**
  * @since 3.14.0
@@ -202,11 +214,10 @@ export interface TagClass<
   in out Id extends string,
   in out K,
   in out I,
-  in out S,
   in out E,
   in out R,
   in out Deps extends Layer.Layer<any, any, any>
-> extends Context.TagClass<Self, Id, LayerMap<K, I, S, E>> {
+> extends Context.TagClass<Self, Id, LayerMap<K, I, E>> {
   /**
    * A default layer for the `LayerMap` service.
    */
@@ -223,17 +234,14 @@ export interface TagClass<
   readonly DefaultWithoutDependencies: Layer.Layer<Self, never, R>
 
   /**
-   * Retrieves an instance of the resource associated with the key.
+   * Retrieves a Layer for the resources associated with the key.
    */
-  readonly get: (key: K) => Effect.Effect<S, E, Scope.Scope | Self>
+  readonly get: (key: K) => Layer.Layer<I, E, Self>
 
   /**
-   * Provides an instance of the resource associated with the key to the given
-   * effect.
+   * Retrieves a Runtime for the resources associated with the key.
    */
-  readonly provide: (
-    key: K
-  ) => <A, EX, R>(effect: Effect.Effect<A, EX, R>) => Effect.Effect<A, EX | E, Exclude<R, I> | Self>
+  readonly runtime: (key: K) => Effect.Effect<Runtime.Runtime<I>, E, Scope.Scope | Self>
 
   /**
    * Invalidates the resource associated with the key.
@@ -250,46 +258,46 @@ export interface TagClass<
  * a key.
  *
  * ```ts
- * import { Completions } from "@effect/ai"
- * import { OpenAiClient, OpenAiCompletions } from "@effect/ai-openai"
- * import { FetchHttpClient } from "@effect/platform"
  * import { NodeRuntime } from "@effect/platform-node"
- * import { Config, Effect, Layer, LayerMap } from "effect"
+ * import { Context, Effect, FiberRef, Layer, LayerMap } from "effect"
  *
- * // create the openai client layer
- * const OpenAiLayer = OpenAiClient.layerConfig({
- *   apiKey: Config.redacted("OPENAI_API_KEY")
- * }).pipe(Layer.provide(FetchHttpClient.layer))
+ * class Greeter extends Context.Tag("Greeter")<Greeter, {
+ *   greet: Effect.Effect<string>
+ * }>() {}
  *
  * // create a service that wraps a LayerMap
- * class AiClients extends LayerMap.Service<AiClients>()("AiClients", {
- *   // this LayerMap will provide the ai Completions service
- *   provides: Completions.Completions,
- *
+ * class GreeterMap extends LayerMap.Service<GreeterMap>()("GreeterMap", {
  *   // define the lookup function for the layer map
  *   //
- *   // The returned Layer will be used to provide the Completions service for the
- *   // given model.
- *   lookup: (model: OpenAiCompletions.Model) => OpenAiCompletions.layer({ model }),
+ *   // The returned Layer will be used to provide the Greeter service for the
+ *   // given name.
+ *   lookup: (name: string) =>
+ *     Layer.succeed(Greeter, {
+ *       greet: Effect.succeed(`Hello, ${name}!`)
+ *     }).pipe(
+ *       Layer.merge(Layer.locallyScoped(FiberRef.currentConcurrency, 123))
+ *     ),
  *
  *   // If a layer is not used for a certain amount of time, it can be removed
  *   idleTimeToLive: "5 seconds",
  *
  *   // Supply the dependencies for the layers in the LayerMap
- *   dependencies: [OpenAiLayer]
+ *   dependencies: []
  * }) {}
  *
  * // usage
- * Effect.gen(function*() {
- *   // access and use the generic Completions service
- *   const ai = yield* Completions.Completions
- *   const response = yield* ai.create("Hello, world!")
- *   console.log(response.text)
+ * const program: Effect.Effect<void, never, GreeterMap> = Effect.gen(function*() {
+ *   // access and use the Greeter service
+ *   const greeter = yield* Greeter
+ *   yield* Effect.log(yield* greeter.greet)
  * }).pipe(
- *   // use the AiClients service to provide a variant of the Completions service
- *   AiClients.provide("gpt-4o"),
- *   // provide the LayerMap service
- *   Effect.provide(AiClients.Default),
+ *   // use the GreeterMap service to provide a variant of the Greeter service
+ *   Effect.provide(GreeterMap.get("John"))
+ * )
+ *
+ * // run the program
+ * program.pipe(
+ *   Effect.provide(GreeterMap.Default),
  *   NodeRuntime.runMain
  * )
  * ```
@@ -297,17 +305,15 @@ export interface TagClass<
 export const Service = <Self>() =>
 <
   const Id extends string,
-  Accessor extends Context.Tag<any, any> | Effect.Effect<any, any, any>,
   Lookup extends {
-    readonly lookup: (key: any) => Layer.Layer<Exclude<Effect.Effect.Context<Accessor>, Scope.Scope>, any, any>
+    readonly lookup: (key: any) => Layer.Layer<any, any, any>
   } | {
-    readonly layers: Record<string, Layer.Layer<Exclude<Effect.Effect.Context<Accessor>, Scope.Scope>, any, any>>
+    readonly layers: Record<string, Layer.Layer<any, any, any>>
   },
   const Deps extends ReadonlyArray<Layer.Layer<any, any, any>> = []
 >(
   id: Id,
   options: Lookup & {
-    readonly provides: Accessor
     readonly dependencies?: Deps | undefined
     readonly idleTimeToLive?: Duration.DurationInput | undefined
   }
@@ -317,9 +323,8 @@ export const Service = <Self>() =>
   Lookup extends { readonly lookup: (key: infer K) => any } ? K
     : Lookup extends { readonly layers: infer Layers } ? keyof Layers
     : never,
-  Exclude<Effect.Effect.Context<Accessor>, Scope.Scope>,
-  Effect.Effect.Success<Accessor>,
-  Effect.Effect.Error<Accessor> | Service.Error<Lookup>,
+  Service.Success<Lookup>,
+  Service.Error<Lookup>,
   Service.Context<Lookup>,
   Deps[number]
 > => {
@@ -330,7 +335,7 @@ export const Service = <Self>() =>
   Err.stackTraceLimit = limit
 
   function TagClass() {}
-  const TagClass_ = TagClass as any as Mutable<TagClass<Self, Id, string, any, any, any, any, any>>
+  const TagClass_ = TagClass as any as Mutable<TagClass<Self, Id, string, any, any, any, any>>
   Object.setPrototypeOf(TagClass, Object.getPrototypeOf(Context.GenericTag<Self, any>(id)))
   TagClass.key = id
   Object.defineProperty(TagClass, "stack", {
@@ -338,21 +343,21 @@ export const Service = <Self>() =>
       return creationError.stack
     }
   })
-  TagClass_.get = (key: string) => Effect.flatMap(TagClass_, (layerMap) => layerMap.get(key))
-  TagClass_.provide = (key: string) => (effect) =>
-    Effect.flatMap(TagClass_, (layerMap) => layerMap.provide(key)(effect))
-  TagClass_.invalidate = (key: string) => Effect.flatMap(TagClass_, (layerMap) => layerMap.invalidate(key))
 
   TagClass_.DefaultWithoutDependencies = Layer.scoped(
     TagClass_,
     "lookup" in options
-      ? make(options.provides, options.lookup, options)
-      : fromRecord(options.provides, options.layers as any, options)
+      ? make(options.lookup, options)
+      : fromRecord(options.layers as any, options)
   )
   TagClass_.Default = options.dependencies && options.dependencies.length > 0 ?
     Layer.provide(TagClass_.DefaultWithoutDependencies, options.dependencies as any) :
     TagClass_.DefaultWithoutDependencies
 
+  TagClass_.get = (key: string) => Layer.unwrapScoped(Effect.map(TagClass_, (layerMap) => layerMap.get(key)))
+  TagClass_.runtime = (key: string) => Effect.flatMap(TagClass_, (layerMap) => layerMap.runtime(key))
+  TagClass_.invalidate = (key: string) => Effect.flatMap(TagClass_, (layerMap) => layerMap.invalidate(key))
+
   return TagClass as any
 }
 
@@ -380,6 +385,13 @@ export declare namespace Service {
     : Options extends { readonly layers: infer Layers } ? Layers[keyof Layers]
     : never
 
+  /**
+   * @since 3.14.0
+   * @category Service
+   * @experimental
+   */
+  export type Success<Options> = Layers<Options> extends Layer.Layer<infer _A, infer _E, infer _R> ? _A : never
+
   /**
    * @since 3.14.0
    * @category Service

package/src/Schedule.ts

@@ -14,6 +14,7 @@ import * as internal from "./internal/schedule.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate } from "./Predicate.js"
+import type * as Ref from "./Ref.js"
 import type * as ScheduleDecision from "./ScheduleDecision.js"
 import type * as Intervals from "./ScheduleIntervals.js"
 import type * as Types from "./Types.js"
@@ -140,6 +141,7 @@ export declare namespace Schedule {
  */
 export interface ScheduleDriver<out Out, in In = unknown, out R = never> extends Schedule.DriverVariance<Out, In, R> {
   readonly state: Effect.Effect<unknown>
+  readonly iterationMeta: Ref.Ref<IterationMetadata>
   readonly last: Effect.Effect<Out, Cause.NoSuchElementException>
   readonly reset: Effect.Effect<void>
   next(input: In): Effect.Effect<Out, Option.Option<never>, R>
@@ -3705,3 +3707,33 @@ export const zipWith: {
     f: (out: Out, out2: Out2) => Out3
   ): Schedule<Out3, In & In2, R | R2>
 } = internal.zipWith
+
+/**
+ * @since 3.15.0
+ * @category models
+ */
+export interface CurrentIterationMetadata {
+  readonly _: unique symbol
+}
+
+/**
+ * @since 3.15.0
+ * @category models
+ */
+export interface IterationMetadata {
+  readonly input: unknown
+  readonly recurrence: number
+  readonly start: number
+  readonly now: number
+  readonly elapsed: Duration.Duration
+  readonly elapsedSincePrevious: Duration.Duration
+}
+
+/**
+ * @since 3.15.0
+ * @category models
+ */
+export const CurrentIterationMetadata: Context.Reference<
+  CurrentIterationMetadata,
+  IterationMetadata
+> = internal.CurrentIterationMetadata

package/src/Stream.ts

@@ -9,6 +9,7 @@ import type * as Deferred from "./Deferred.js"
 import type * as Duration from "./Duration.js"
 import type * as Effect from "./Effect.js"
 import type * as Either from "./Either.js"
+import type { ExecutionPlan } from "./ExecutionPlan.js"
 import type * as Exit from "./Exit.js"
 import type { LazyArg } from "./Function.js"
 import type * as GroupBy from "./GroupBy.js"
@@ -7351,7 +7352,7 @@ export const retry: {
    * @since 2.0.0
    * @category utils
    */
-  <E0 extends E, R2, E, X>(schedule: Schedule.Schedule<X, E0, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
+  <E, R2, X>(policy: Schedule.Schedule<X, NoInfer<E>, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
   /**
    * When the stream fails, retry it according to the given schedule
    *
@@ -7364,9 +7365,57 @@ export const retry: {
    * @since 2.0.0
    * @category utils
    */
-  <A, E, R, X, E0 extends E, R2>(self: Stream<A, E, R>, schedule: Schedule.Schedule<X, E0, R2>): Stream<A, E, R | R2>
+  <A, E, R, X, R2>(self: Stream<A, E, R>, policy: Schedule.Schedule<X, NoInfer<E>, R2>): Stream<A, E, R2 | R>
 } = internal.retry
 
+/**
+ * Apply an `ExecutionPlan` to the stream, which allows you to fallback to
+ * different resources in case of failure.
+ *
+ * If you have a stream that could fail with partial results, you can use
+ * the `preventFallbackOnPartialStream` option to prevent contamination of
+ * the final stream with partial results.
+ *
+ * @since 3.16.0
+ * @category Error handling
+ * @experimental
+ */
+export const withExecutionPlan: {
+  /**
+   * Apply an `ExecutionPlan` to the stream, which allows you to fallback to
+   * different resources in case of failure.
+   *
+   * If you have a stream that could fail with partial results, you can use
+   * the `preventFallbackOnPartialStream` option to prevent contamination of
+   * the final stream with partial results.
+   *
+   * @since 3.16.0
+   * @category Error handling
+   * @experimental
+   */
+  <Input, R2, Provides, PolicyE>(
+    policy: ExecutionPlan<{ provides: Provides; input: Input; error: PolicyE; requirements: R2 }>,
+    options?: { readonly preventFallbackOnPartialStream?: boolean | undefined }
+  ): <A, E extends Input, R>(self: Stream<A, E, R>) => Stream<A, E | PolicyE, R2 | Exclude<R, Provides>>
+  /**
+   * Apply an `ExecutionPlan` to the stream, which allows you to fallback to
+   * different resources in case of failure.
+   *
+   * If you have a stream that could fail with partial results, you can use
+   * the `preventFallbackOnPartialStream` option to prevent contamination of
+   * the final stream with partial results.
+   *
+   * @since 3.16.0
+   * @category Error handling
+   * @experimental
+   */
+  <A, E extends Input, R, R2, Input, Provides, PolicyE>(
+    self: Stream<A, E, R>,
+    policy: ExecutionPlan<{ provides: Provides; input: Input; error: PolicyE; requirements: R2 }>,
+    options?: { readonly preventFallbackOnPartialStream?: boolean | undefined }
+  ): Stream<A, E | PolicyE, R2 | Exclude<R, Provides>>
+} = internal.withExecutionPlan
+
 /**
  * Runs the sink on the stream to produce either the sink's result or an error.
  *

package/src/index.ts

@@ -263,6 +263,12 @@ export * as Equal from "./Equal.js"
  */
 export * as Equivalence from "./Equivalence.js"
 
+/**
+ * @since 3.16.0
+ * @experimental
+ */
+export * as ExecutionPlan from "./ExecutionPlan.js"
+
 /**
  * @since 2.0.0
  */

package/src/internal/config.ts

@@ -1,3 +1,4 @@
+import type * as Brand from "../Brand.js"
 import * as Chunk from "../Chunk.js"
 import type * as Config from "../Config.js"
 import * as ConfigError from "../ConfigError.js"
@@ -192,6 +193,33 @@ export const url = (name?: string): Config.Config<URL> => {
   return name === undefined ? config : nested(config, name)
 }
 
+/** @internal */
+export const port = (name?: string): Config.Config<number> => {
+  const config = primitive(
+    "a network port property",
+    (text) => {
+      const result = Number(text)
+
+      if (
+        Number.isNaN(result) ||
+        result.toString() !== text.toString() ||
+        !Number.isInteger(result) ||
+        result < 1 ||
+        result > 65535
+      ) {
+        return Either.left(
+          configError.InvalidData(
+            [],
+            `Expected a network port value but received ${text}`
+          )
+        )
+      }
+      return Either.right(result)
+    }
+  )
+  return name === undefined ? config : nested(config, name)
+}
+
 /** @internal */
 export const array = <A>(config: Config.Config<A>, name?: string): Config.Config<Array<A>> => {
   return pipe(chunk(config, name), map(Chunk.toArray))
@@ -444,6 +472,33 @@ export const redacted = <A>(
   return map(config, redacted_.make)
 }
 
+/** @internal */
+export const branded: {
+  <A, B extends Brand.Branded<A, any>>(
+    constructor: Brand.Brand.Constructor<B>
+  ): (config: Config.Config<A>) => Config.Config<B>
+  <B extends Brand.Branded<string, any>>(
+    name: string | undefined,
+    constructor: Brand.Brand.Constructor<B>
+  ): Config.Config<B>
+  <A, B extends Brand.Branded<A, any>>(
+    config: Config.Config<A>,
+    constructor: Brand.Brand.Constructor<B>
+  ): Config.Config<B>
+} = dual(2, <A, B extends Brand.Brand.Constructor<any>>(
+  nameOrConfig: Config.Config<NoInfer<A>> | string | undefined,
+  constructor: B
+) => {
+  const config: Config.Config<string | A> = isConfig(nameOrConfig) ? nameOrConfig : string(nameOrConfig)
+
+  return mapOrFail(config, (a) =>
+    constructor.either(a).pipe(
+      Either.mapLeft((brandErrors) =>
+        configError.InvalidData([], brandErrors.map((brandError) => brandError.message).join("\n"))
+      )
+    ))
+})
+
 /** @internal */
 export const hashSet = <A>(config: Config.Config<A>, name?: string): Config.Config<HashSet.HashSet<A>> => {
   const newConfig = map(chunk(config), HashSet.fromIterable)

package/src/internal/effect/circular.ts

@@ -18,7 +18,6 @@ import { pipeArguments } from "../../Pipeable.js"
 import * as Predicate from "../../Predicate.js"
 import * as Readable from "../../Readable.js"
 import type * as Ref from "../../Ref.js"
-import type * as Schedule from "../../Schedule.js"
 import { currentScheduler } from "../../Scheduler.js"
 import type * as Scope from "../../Scope.js"
 import type * as Supervisor from "../../Supervisor.js"
@@ -31,7 +30,6 @@ import * as internalFiber from "../fiber.js"
 import * as fiberRuntime from "../fiberRuntime.js"
 import { globalScope } from "../fiberScope.js"
 import * as internalRef from "../ref.js"
-import * as schedule_ from "../schedule.js"
 import * as supervisor from "../supervisor.js"
 
 /** @internal */
@@ -477,19 +475,6 @@ export const raceFirst = dual<
     (effect: Effect.Effect<Exit.Exit<A | A2, E | E2>, never, R | R2>) => core.flatten(effect)
   ))
 
-/** @internal */
-export const scheduleForked = dual<
-  <Out, R2>(
-    schedule: Schedule.Schedule<Out, unknown, R2>
-  ) => <A, E, R>(
-    self: Effect.Effect<A, E, R>
-  ) => Effect.Effect<Fiber.RuntimeFiber<Out, E>, never, R | R2 | Scope.Scope>,
-  <A, E, R, Out, R2>(
-    self: Effect.Effect<A, E, R>,
-    schedule: Schedule.Schedule<Out, unknown, R2>
-  ) => Effect.Effect<Fiber.RuntimeFiber<Out, E>, never, R | R2 | Scope.Scope>
->(2, (self, schedule) => pipe(self, schedule_.schedule_Effect(schedule), forkScoped))
-
 /** @internal */
 export const supervised = dual<
   <X>(supervisor: Supervisor.Supervisor<X>) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,