effect 2.0.0-next.54 → 2.0.0-next.55

package/src/Ref.ts

@@ -1,10 +1,10 @@
 /**
  * @since 2.0.0
  */
-import type * as Effect from "./Effect"
-import * as internal from "./internal/ref"
-import type * as Option from "./Option"
-import type { Pipeable } from "./Pipeable"
+import type * as Effect from "./Effect.js"
+import * as internal from "./internal/ref.js"
+import type * as Option from "./Option.js"
+import type { Pipeable } from "./Pipeable.js"
 
 /**
  * @since 2.0.0
@@ -23,7 +23,7 @@ export type RefTypeId = typeof RefTypeId
  * @category models
  */
 export interface Ref<A> extends Ref.Variance<A>, Pipeable {
-  modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B>
+  readonly modify: <B>(f: (a: A) => readonly [B, A]) => Effect.Effect<never, never, B>
 }
 
 /**
@@ -36,7 +36,7 @@ export declare namespace Ref {
    */
   export interface Variance<A> {
     readonly [RefTypeId]: {
-      readonly _A: (_: never) => A
+      readonly _A: (_: A) => A
     }
   }
 }

package/src/Reloadable.ts

@@ -1,12 +1,12 @@
 /**
  * @since 2.0.0
  */
-import type * as Context from "./Context"
-import type * as Effect from "./Effect"
-import * as internal from "./internal/reloadable"
-import type * as Layer from "./Layer"
-import type * as Schedule from "./Schedule"
-import type * as ScopedRef from "./ScopedRef"
+import type * as Context from "./Context.js"
+import type * as Effect from "./Effect.js"
+import * as internal from "./internal/reloadable.js"
+import type * as Layer from "./Layer.js"
+import type * as Schedule from "./Schedule.js"
+import type * as ScopedRef from "./ScopedRef.js"
 
 /**
  * @since 2.0.0
@@ -35,7 +35,7 @@ export interface Reloadable<A> extends Reloadable.Variance<A> {
   /**
    * @internal
    */
-  reload(): Effect.Effect<never, unknown, void>
+  readonly reload: Effect.Effect<never, unknown, void>
 }
 
 /**

package/src/Request.ts

@@ -1,19 +1,19 @@
 /**
  * @since 2.0.0
  */
-import type * as _Cache from "./Cache"
-import type * as Data from "./Data"
-import type { Deferred } from "./Deferred"
-import type { DurationInput } from "./Duration"
-import type * as Effect from "./Effect"
-import type * as Exit from "./Exit"
-import type { FiberId } from "./FiberId"
-import * as _RequestBlock from "./internal/blockedRequests"
-import * as cache from "./internal/cache"
-import * as core from "./internal/core"
-import * as fiberRuntime from "./internal/fiberRuntime"
-import * as internal from "./internal/request"
-import type * as Option from "./Option"
+import type * as _Cache from "./Cache.js"
+import type * as Data from "./Data.js"
+import type { Deferred } from "./Deferred.js"
+import type { DurationInput } from "./Duration.js"
+import type * as Effect from "./Effect.js"
+import type * as Exit from "./Exit.js"
+import type { FiberId } from "./FiberId.js"
+import * as _RequestBlock from "./internal/blockedRequests.js"
+import * as cache from "./internal/cache.js"
+import * as core from "./internal/core.js"
+import * as fiberRuntime from "./internal/fiberRuntime.js"
+import * as internal from "./internal/request.js"
+import type * as Option from "./Option.js"
 
 /**
  * @since 2.0.0
@@ -187,12 +187,12 @@ export const succeed: {
  * @since 2.0.0
  */
 export interface Listeners {
-  count: number
-  observers: Set<(count: number) => void>
-  addObserver(f: (count: number) => void): void
-  removeObserver(f: (count: number) => void): void
-  increment(): void
-  decrement(): void
+  readonly count: number
+  readonly observers: Set<(count: number) => void>
+  readonly addObserver: (f: (count: number) => void) => void
+  readonly removeObserver: (f: (count: number) => void) => void
+  readonly increment: () => void
+  readonly decrement: () => void
 }
 
 /**
@@ -252,7 +252,7 @@ export interface Entry<R> extends Entry.Variance<R> {
   readonly listeners: Listeners
   readonly ownerId: FiberId
   readonly state: {
-    completed: boolean
+    completed: boolean // TODO: mutable by design?
   }
 }
 

package/src/RequestBlock.ts

@@ -1,13 +1,13 @@
 /**
  * @since 2.0.0
  */
-import type * as Context from "./Context"
-import type { FiberRef } from "./FiberRef"
-import * as _RequestBlock from "./internal/blockedRequests"
-import * as core from "./internal/core"
-import * as _dataSource from "./internal/dataSource"
-import type * as Request from "./Request"
-import type * as RequestResolver from "./RequestResolver"
+import type * as Context from "./Context.js"
+import type { FiberRef } from "./FiberRef.js"
+import * as _RequestBlock from "./internal/blockedRequests.js"
+import * as core from "./internal/core.js"
+import * as _dataSource from "./internal/dataSource.js"
+import type * as Request from "./Request.js"
+import type * as RequestResolver from "./RequestResolver.js"
 
 /**
  * `RequestBlock` captures a collection of blocked requests as a data
@@ -143,7 +143,7 @@ const MapInputContextReducer = <R0, R>(
   singleCase: (dataSource, blockedRequest) =>
     single(
       _dataSource.mapInputContext(dataSource, f),
-      blockedRequest
+      blockedRequest as any
     )
 })
 

package/src/RequestResolver.ts

@@ -2,15 +2,15 @@
  * @since 2.0.0
  */
 
-import * as Context from "./Context"
-import * as Effect from "./Effect"
-import type * as Either from "./Either"
-import type * as Equal from "./Equal"
-import type { FiberRef } from "./FiberRef"
-import * as core from "./internal/core"
-import * as internal from "./internal/dataSource"
-import type { Pipeable } from "./Pipeable"
-import type * as Request from "./Request"
+import * as Context from "./Context.js"
+import * as Effect from "./Effect.js"
+import type * as Either from "./Either.js"
+import type * as Equal from "./Equal.js"
+import type { FiberRef } from "./FiberRef.js"
+import * as core from "./internal/core.js"
+import * as internal from "./internal/dataSource.js"
+import type { Pipeable } from "./Pipeable.js"
+import type * as Request from "./Request.js"
 
 /**
  * @since 2.0.0
@@ -54,12 +54,12 @@ export interface RequestResolver<A, R = never> extends Equal.Equal, Pipeable {
    * of requests that must be performed sequentially. The inner `Chunk`
    * represents a batch of requests that can be performed in parallel.
    */
-  runAll(requests: Array<Array<Request.Entry<A>>>): Effect.Effect<R, never, void>
+  readonly runAll: (requests: Array<Array<Request.Entry<A>>>) => Effect.Effect<R, never, void>
 
   /**
    * Identify the data source using the specific identifier
    */
-  identified(...identifiers: Array<unknown>): RequestResolver<A, R>
+  readonly identified: (...identifiers: Array<unknown>) => RequestResolver<A, R>
 }
 
 /**

package/src/Resource.ts

@@ -1,12 +1,12 @@
 /**
  * @since 2.0.0
  */
-import type * as Effect from "./Effect"
-import type * as Exit from "./Exit"
-import * as internal from "./internal/resource"
-import type * as Schedule from "./Schedule"
-import type * as Scope from "./Scope"
-import type * as ScopedRef from "./ScopedRef"
+import type * as Effect from "./Effect.js"
+import type * as Exit from "./Exit.js"
+import * as internal from "./internal/resource.js"
+import type * as Schedule from "./Schedule.js"
+import type * as Scope from "./Scope.js"
+import type * as ScopedRef from "./ScopedRef.js"
 
 /**
  * @since 2.0.0
@@ -31,7 +31,7 @@ export interface Resource<E, A> extends Resource.Variance<E, A> {
   /** @internal */
   readonly scopedRef: ScopedRef.ScopedRef<Exit.Exit<E, A>>
   /** @internal */
-  acquire(): Effect.Effect<Scope.Scope, E, A>
+  readonly acquire: Effect.Effect<Scope.Scope, E, A>
 }
 
 /**

package/src/Runtime.ts

@@ -1,18 +1,18 @@
 /**
  * @since 2.0.0
  */
-import type { Cause } from "./Cause"
-import type * as Context from "./Context"
-import type * as Effect from "./Effect"
-import type * as Exit from "./Exit"
-import type * as Fiber from "./Fiber"
-import type * as FiberId from "./FiberId"
-import type * as FiberRefs from "./FiberRefs"
-import type { Inspectable } from "./Inspectable"
-import * as internal from "./internal/runtime"
-import type { Pipeable } from "./Pipeable"
-import type * as RuntimeFlags from "./RuntimeFlags"
-import type { Scheduler } from "./Scheduler"
+import type { Cause } from "./Cause.js"
+import type * as Context from "./Context.js"
+import type * as Effect from "./Effect.js"
+import type * as Exit from "./Exit.js"
+import type * as Fiber from "./Fiber.js"
+import type * as FiberId from "./FiberId.js"
+import type * as FiberRefs from "./FiberRefs.js"
+import type { Inspectable } from "./Inspectable.js"
+import * as internal from "./internal/runtime.js"
+import type { Pipeable } from "./Pipeable.js"
+import type * as RuntimeFlags from "./RuntimeFlags.js"
+import type { Scheduler } from "./Scheduler.js"
 
 /**
  * @since 2.0.0
@@ -55,8 +55,8 @@ export interface Runtime<R> extends Pipeable {
  * @category models
  */
 export interface RunForkOptions {
-  scheduler?: Scheduler
-  updateRefs?: (refs: FiberRefs.FiberRefs, fiberId: FiberId.Runtime) => FiberRefs.FiberRefs
+  readonly scheduler?: Scheduler | undefined
+  readonly updateRefs?: ((refs: FiberRefs.FiberRefs, fiberId: FiberId.Runtime) => FiberRefs.FiberRefs) | undefined
 }
 
 /**
@@ -68,8 +68,7 @@ export interface RunForkOptions {
  */
 export const runFork: <R>(
   runtime: Runtime<R>
-) => <E, A>(self: Effect.Effect<R, E, A>, options?: RunForkOptions | undefined) => Fiber.RuntimeFiber<E, A> =
-  internal.unsafeFork
+) => <E, A>(self: Effect.Effect<R, E, A>, options?: RunForkOptions) => Fiber.RuntimeFiber<E, A> = internal.unsafeFork
 
 /**
  * Executes the effect synchronously returning the exit.

package/src/RuntimeFlags.ts

@@ -2,11 +2,11 @@
  * @since 2.0.0
  */
 
-import type * as Differ from "./Differ"
-import * as circular from "./internal/layer/circular"
-import * as internal from "./internal/runtimeFlags"
-import type * as Layer from "./Layer"
-import type * as RuntimeFlagsPatch from "./RuntimeFlagsPatch"
+import type * as Differ from "./Differ.js"
+import * as circular from "./internal/layer/circular.js"
+import * as internal from "./internal/runtimeFlags.js"
+import type * as Layer from "./Layer.js"
+import type * as RuntimeFlagsPatch from "./RuntimeFlagsPatch.js"
 
 /**
  * Represents a set of `RuntimeFlag`s. `RuntimeFlag`s affect the operation of

package/src/RuntimeFlagsPatch.ts

@@ -1,9 +1,9 @@
 /**
  * @since 2.0.0
  */
-import * as runtimeFlags from "./internal/runtimeFlags"
-import * as internal from "./internal/runtimeFlagsPatch"
-import type * as RuntimeFlags from "./RuntimeFlags"
+import * as runtimeFlags from "./internal/runtimeFlags.js"
+import * as internal from "./internal/runtimeFlagsPatch.js"
+import type * as RuntimeFlags from "./RuntimeFlags.js"
 
 /**
  * @since 2.0.0

package/src/STM.ts

@@ -1,20 +1,20 @@
 /**
  * @since 2.0.0
  */
-import * as Cause from "./Cause"
-import * as Chunk from "./Chunk"
-import type * as Context from "./Context"
-import type * as Effect from "./Effect"
-import type * as Either from "./Either"
-import type * as FiberId from "./FiberId"
-import type { LazyArg } from "./Function"
-import type { TypeLambda } from "./HKT"
-import * as core from "./internal/stm/core"
-import * as stm from "./internal/stm/stm"
-import type * as Option from "./Option"
-import type { Pipeable } from "./Pipeable"
-import type { Predicate, Refinement } from "./Predicate"
-import type * as Unify from "./Unify"
+import * as Cause from "./Cause.js"
+import * as Chunk from "./Chunk.js"
+import type * as Context from "./Context.js"
+import type * as Effect from "./Effect.js"
+import type * as Either from "./Either.js"
+import type * as FiberId from "./FiberId.js"
+import type { LazyArg } from "./Function.js"
+import type { TypeLambda } from "./HKT.js"
+import * as core from "./internal/stm/core.js"
+import * as stm from "./internal/stm/stm.js"
+import type * as Option from "./Option.js"
+import type { Pipeable } from "./Pipeable.js"
+import type { Predicate, Refinement } from "./Predicate.js"
+import type * as Unify from "./Unify.js"
 
 /**
  * @since 2.0.0
@@ -68,7 +68,7 @@ export type STMTypeId = typeof STMTypeId
 export interface STM<R, E, A> extends Effect.Effect<R, E, A>, STM.Variance<R, E, A>, Pipeable {
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: STMUnify<this>
-  [Unify.blacklistSymbol]?: STMUnifyBlacklist
+  [Unify.ignoreSymbol]?: STMUnifyIgnore
 }
 
 /**
@@ -83,7 +83,7 @@ export interface STMUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect
  * @category models
  * @since 2.0.0
  */
-export interface STMUnifyBlacklist extends Effect.EffectUnifyBlacklist {
+export interface STMUnifyIgnore extends Effect.EffectUnifyIgnore {
   Effect?: true
 }
 
@@ -99,7 +99,7 @@ export interface STMTypeLambda extends TypeLambda {
  * @since 2.0.0
  * @category models
  */
-declare module "./Context" {
+declare module "./Context.js" {
   interface Tag<Identifier, Service> extends STM<Identifier, never, Service> {}
 }
 
@@ -107,7 +107,7 @@ declare module "./Context" {
  * @since 2.0.0
  * @category models
  */
-declare module "./Either" {
+declare module "./Either.js" {
   interface Left<E, A> extends STM<never, E, A> {
     readonly _tag: "Left"
   }
@@ -120,7 +120,7 @@ declare module "./Either" {
  * @since 2.0.0
  * @category models
  */
-declare module "./Option" {
+declare module "./Option.js" {
   interface None<A> extends STM<never, Cause.NoSuchElementException, A> {
     readonly _tag: "None"
   }
@@ -155,7 +155,7 @@ export interface STMGen<R, E, A> {
   readonly _E: () => E
   readonly _A: () => A
   readonly value: STM<R, E, A>
-  [Symbol.iterator](): Generator<STMGen<R, E, A>, A>
+  readonly [Symbol.iterator]: () => Generator<STMGen<R, E, A>, A>
 }
 
 /**
@@ -226,7 +226,9 @@ export declare namespace All {
    * @since 2.0.0
    * @category utils
    */
-  export type Options = { readonly discard?: boolean }
+  export type Options = {
+    readonly discard?: boolean | undefined
+  }
   type IsDiscard<A> = [Extract<A, { readonly discard: true }>] extends [never] ? false : true
   type Narrow<A> = (A extends [] ? [] : never) | A
 
@@ -788,18 +790,26 @@ export const matchSTM: {
 export const forEach: {
   <A, R, E, A2>(
     f: (a: A) => STM<R, E, A2>,
-    options?: { readonly discard?: false }
+    options?: {
+      readonly discard?: false | undefined
+    }
   ): (elements: Iterable<A>) => STM<R, E, Array<A2>>
   <A, R, E, A2>(
     f: (a: A) => STM<R, E, A2>,
-    options: { readonly discard: true }
+    options: {
+      readonly discard: true
+    }
   ): (elements: Iterable<A>) => STM<R, E, void>
   <A, R, E, A2>(
     elements: Iterable<A>,
     f: (a: A) => STM<R, E, A2>,
-    options?: { readonly discard?: false }
+    options?: {
+      readonly discard?: false | undefined
+    }
   ): STM<R, E, Array<A2>>
-  <A, R, E, A2>(elements: Iterable<A>, f: (a: A) => STM<R, E, A2>, options: { readonly discard: true }): STM<R, E, void>
+  <A, R, E, A2>(elements: Iterable<A>, f: (a: A) => STM<R, E, A2>, options: {
+    readonly discard: true
+  }): STM<R, E, void>
 } = stm.forEach
 
 /**
@@ -1229,7 +1239,7 @@ export const loop: {
       readonly while: (z: Z) => boolean
       readonly step: (z: Z) => Z
       readonly body: (z: Z) => STM<R, E, A>
-      readonly discard?: false
+      readonly discard?: false | undefined
     }
   ): STM<R, E, Array<A>>
   <Z, R, E, A>(
@@ -1455,8 +1465,8 @@ export const orTry: {
  * @category traversing
  */
 export const partition: {
-  <R, E, A, A2>(f: (a: A) => STM<R, E, A2>): (elements: Iterable<A>) => STM<R, never, readonly [Array<E>, Array<A2>]>
-  <R, E, A, A2>(elements: Iterable<A>, f: (a: A) => STM<R, E, A2>): STM<R, never, readonly [Array<E>, Array<A2>]>
+  <R, E, A, A2>(f: (a: A) => STM<R, E, A2>): (elements: Iterable<A>) => STM<R, never, [Array<E>, Array<A2>]>
+  <R, E, A, A2>(elements: Iterable<A>, f: (a: A) => STM<R, E, A2>): STM<R, never, [Array<E>, Array<A2>]>
 } = stm.partition
 
 /**
@@ -1769,12 +1779,12 @@ export const summarized: {
     f: (before: A2, after: A2) => A3
   ): <R, E, A>(
     self: STM<R, E, A>
-  ) => STM<R2 | R, E2 | E, readonly [A3, A]>
+  ) => STM<R2 | R, E2 | E, [A3, A]>
   <R, E, A, R2, E2, A2, A3>(
     self: STM<R, E, A>,
     summary: STM<R2, E2, A2>,
     f: (before: A2, after: A2) => A3
-  ): STM<R | R2, E | E2, readonly [A3, A]>
+  ): STM<R | R2, E | E2, [A3, A]>
 } = stm.summarized
 
 /**
@@ -1944,8 +1954,8 @@ export const whenSTM: {
  * @category zipping
  */
 export const zip: {
-  <R1, E1, A1>(that: STM<R1, E1, A1>): <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, readonly [A, A1]>
-  <R, E, A, R1, E1, A1>(self: STM<R, E, A>, that: STM<R1, E1, A1>): STM<R | R1, E | E1, readonly [A, A1]>
+  <R1, E1, A1>(that: STM<R1, E1, A1>): <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, [A, A1]>
+  <R, E, A, R1, E1, A1>(self: STM<R, E, A>, that: STM<R1, E1, A1>): STM<R | R1, E | E1, [A, A1]>
 } = core.zip
 
 /**

package/src/Schedule.ts

@@ -1,19 +1,19 @@
 /**
  * @since 2.0.0
  */
-import type * as Cause from "./Cause"
-import type * as Chunk from "./Chunk"
-import type * as Context from "./Context"
-import type * as Duration from "./Duration"
-import type * as Effect from "./Effect"
-import type * as Either from "./Either"
-import type { LazyArg } from "./Function"
-import * as internal from "./internal/schedule"
-import type * as Option from "./Option"
-import type { Pipeable } from "./Pipeable"
-import type { Predicate } from "./Predicate"
-import type * as ScheduleDecision from "./ScheduleDecision"
-import type * as Intervals from "./ScheduleIntervals"
+import type * as Cause from "./Cause.js"
+import type * as Chunk from "./Chunk.js"
+import type * as Context from "./Context.js"
+import type * as Duration from "./Duration.js"
+import type * as Effect from "./Effect.js"
+import type * as Either from "./Either.js"
+import type { LazyArg } from "./Function.js"
+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 ScheduleDecision from "./ScheduleDecision.js"
+import type * as Intervals from "./ScheduleIntervals.js"
 
 /**
  * @since 2.0.0
@@ -115,10 +115,10 @@ export declare namespace Schedule {
  * @category models
  */
 export interface ScheduleDriver<Env, In, Out> extends Schedule.DriverVariance<Env, In, Out> {
-  state(): Effect.Effect<never, never, unknown>
-  last(): Effect.Effect<never, Cause.NoSuchElementException, Out>
-  reset(): Effect.Effect<never, never, void>
-  next(input: In): Effect.Effect<Env, Option.Option<never>, Out>
+  readonly state: Effect.Effect<never, never, unknown>
+  readonly last: Effect.Effect<never, Cause.NoSuchElementException, Out>
+  readonly reset: Effect.Effect<never, never, void>
+  readonly next: (input: In) => Effect.Effect<Env, Option.Option<never>, Out>
 }
 
 /**
@@ -228,11 +228,19 @@ export const asUnit: <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<En
 export const bothInOut: {
   <Env2, In2, Out2>(
     that: Schedule<Env2, In2, Out2>
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, readonly [In, In2], readonly [Out, Out2]>
+  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<
+    Env2 | Env,
+    readonly [In, In2], // readonly because contravariant
+    [Out, Out2]
+  >
   <Env, In, Out, Env2, In2, Out2>(
     self: Schedule<Env, In, Out>,
     that: Schedule<Env2, In2, Out2>
-  ): Schedule<Env | Env2, readonly [In, In2], readonly [Out, Out2]>
+  ): Schedule<
+    Env | Env2,
+    readonly [In, In2], // readonly because contravariant
+    [Out, Out2]
+  >
 } = internal.bothInOut
 
 /**
@@ -550,11 +558,11 @@ export const duration: (duration: Duration.DurationInput) => Schedule<never, unk
 export const either: {
   <Env2, In2, Out2>(
     that: Schedule<Env2, In2, Out2>
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, readonly [Out, Out2]>
+  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>
   <Env, In, Out, Env2, In2, Out2>(
     self: Schedule<Env, In, Out>,
     that: Schedule<Env2, In2, Out2>
-  ): Schedule<Env | Env2, In & In2, readonly [Out, Out2]>
+  ): Schedule<Env | Env2, In & In2, [Out, Out2]>
 } = internal.either
 
 /**
@@ -567,12 +575,12 @@ export const eitherWith: {
   <Env2, In2, Out2>(
     that: Schedule<Env2, In2, Out2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, readonly [Out, Out2]>
+  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>
   <Env, In, Out, Env2, In2, Out2>(
     self: Schedule<Env, In, Out>,
     that: Schedule<Env2, In2, Out2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ): Schedule<Env | Env2, In & In2, readonly [Out, Out2]>
+  ): Schedule<Env | Env2, In & In2, [Out, Out2]>
 } = internal.eitherWith
 
 /**
@@ -708,11 +716,11 @@ export const identity: <A>() => Schedule<never, A, A> = internal.identity
 export const intersect: {
   <Env2, In2, Out2>(
     that: Schedule<Env2, In2, Out2>
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, readonly [Out, Out2]>
+  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>
   <Env, In, Out, Env2, In2, Out2>(
     self: Schedule<Env, In, Out>,
     that: Schedule<Env2, In2, Out2>
-  ): Schedule<Env | Env2, In & In2, readonly [Out, Out2]>
+  ): Schedule<Env | Env2, In & In2, [Out, Out2]>
 } = internal.intersect
 
 /**
@@ -727,12 +735,12 @@ export const intersectWith: {
   <Env2, In2, Out2>(
     that: Schedule<Env2, In2, Out2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, readonly [Out, Out2]>
+  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>
   <Env, In, Out, Env2, In2, Out2>(
     self: Schedule<Env, In, Out>,
     that: Schedule<Env2, In2, Out2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ): Schedule<Env | Env2, In & In2, readonly [Out, Out2]>
+  ): Schedule<Env | Env2, In & In2, [Out, Out2]>
 } = internal.intersectWith
 
 /**
@@ -1173,11 +1181,11 @@ export const unfold: <A>(initial: A, f: (a: A) => A) => Schedule<never, unknown,
 export const union: {
   <Env2, In2, Out2>(
     that: Schedule<Env2, In2, Out2>
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, readonly [Out, Out2]>
+  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>
   <Env, In, Out, Env2, In2, Out2>(
     self: Schedule<Env, In, Out>,
     that: Schedule<Env2, In2, Out2>
-  ): Schedule<Env | Env2, In & In2, readonly [Out, Out2]>
+  ): Schedule<Env | Env2, In & In2, [Out, Out2]>
 } = internal.union
 
 /**
@@ -1192,12 +1200,12 @@ export const unionWith: {
   <Env2, In2, Out2>(
     that: Schedule<Env2, In2, Out2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, readonly [Out, Out2]>
+  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>
   <Env, In, Out, Env2, In2, Out2>(
     self: Schedule<Env, In, Out>,
     that: Schedule<Env2, In2, Out2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ): Schedule<Env | Env2, In & In2, readonly [Out, Out2]>
+  ): Schedule<Env | Env2, In & In2, [Out, Out2]>
 } = internal.unionWith
 
 /**

package/src/ScheduleDecision.ts

@@ -1,9 +1,9 @@
 /**
  * @since 2.0.0
  */
-import * as internal from "./internal/schedule/decision"
-import type * as Interval from "./ScheduleInterval"
-import type * as Intervals from "./ScheduleIntervals"
+import * as internal from "./internal/schedule/decision.js"
+import type * as Interval from "./ScheduleInterval.js"
+import type * as Intervals from "./ScheduleIntervals.js"
 
 /**
  * @since 2.0.0

package/src/ScheduleInterval.ts

@@ -1,9 +1,9 @@
 /**
  * @since 2.0.0
  */
-import type * as Duration from "./Duration"
-import * as internal from "./internal/schedule/interval"
-import type * as Option from "./Option"
+import type * as Duration from "./Duration.js"
+import * as internal from "./internal/schedule/interval.js"
+import type * as Option from "./Option.js"
 
 /**
  * @since 2.0.0