effect 3.12.3 → 3.12.5

package/src/internal/dateTime.ts

@@ -129,7 +129,21 @@ export const makeZonedProto = (
   const self = Object.create(ProtoZoned)
   self.epochMillis = epochMillis
   self.zone = zone
-  self.partsUtc = partsUtc
+  Object.defineProperty(self, "partsUtc", {
+    value: partsUtc,
+    enumerable: false,
+    writable: true
+  })
+  Object.defineProperty(self, "adjustedEpochMillis", {
+    value: undefined,
+    enumerable: false,
+    writable: true
+  })
+  Object.defineProperty(self, "partsAdjusted", {
+    value: undefined,
+    enumerable: false,
+    writable: true
+  })
   return self
 }
 
@@ -173,8 +187,13 @@ export const Order: order.Order<DateTime.DateTime> = order.make((self, that) =>
 
 /** @internal */
 export const clamp: {
-  (options: { minimum: DateTime.DateTime; maximum: DateTime.DateTime }): (self: DateTime.DateTime) => DateTime.DateTime
-  (self: DateTime.DateTime, options: { minimum: DateTime.DateTime; maximum: DateTime.DateTime }): DateTime.DateTime
+  <Min extends DateTime.DateTime, Max extends DateTime.DateTime>(
+    options: { readonly minimum: Min; readonly maximum: Max }
+  ): <A extends DateTime.DateTime>(self: A) => A | Min | Max
+  <A extends DateTime.DateTime, Min extends DateTime.DateTime, Max extends DateTime.DateTime>(
+    self: A,
+    options: { readonly minimum: Min; readonly maximum: Max }
+  ): A | Min | Max
 } = order.clamp(Order)
 
 // =============================================================================
@@ -184,6 +203,11 @@ export const clamp: {
 const makeUtc = (epochMillis: number): DateTime.Utc => {
   const self = Object.create(ProtoUtc)
   self.epochMillis = epochMillis
+  Object.defineProperty(self, "partsUtc", {
+    value: undefined,
+    enumerable: false,
+    writable: true
+  })
   return self
 }
 
@@ -210,6 +234,9 @@ export const unsafeMake = <A extends DateTime.DateTime.Input>(input: A): DateTim
   return unsafeFromDate(new Date(input)) as DateTime.DateTime.PreserveZone<A>
 }
 
+const minEpochMillis = -8640000000000000 + (12 * 60 * 60 * 1000)
+const maxEpochMillis = 8640000000000000 - (14 * 60 * 60 * 1000)
+
 /** @internal */
 export const unsafeMakeZoned = (input: DateTime.DateTime.Input, options?: {
   readonly timeZone?: number | string | DateTime.TimeZone | undefined
@@ -219,6 +246,9 @@ export const unsafeMakeZoned = (input: DateTime.DateTime.Input, options?: {
     return input
   }
   const self = unsafeMake(input)
+  if (self.epochMillis < minEpochMillis || self.epochMillis > maxEpochMillis) {
+    throw new IllegalArgumentException(`Epoch millis out of range: ${self.epochMillis}`)
+  }
   let zone: DateTime.TimeZone
   if (options?.timeZone === undefined) {
     const offset = new Date(self.epochMillis).getTimezoneOffset() * -60 * 1000
@@ -451,14 +481,14 @@ export const distanceDuration: {
 
 /** @internal */
 export const min: {
-  (that: DateTime.DateTime): (self: DateTime.DateTime) => DateTime.DateTime
-  (self: DateTime.DateTime, that: DateTime.DateTime): DateTime.DateTime
+  <That extends DateTime.DateTime>(that: That): <Self extends DateTime.DateTime>(self: Self) => Self | That
+  <Self extends DateTime.DateTime, That extends DateTime.DateTime>(self: Self, that: That): Self | That
 } = order.min(Order)
 
 /** @internal */
 export const max: {
-  (that: DateTime.DateTime): (self: DateTime.DateTime) => DateTime.DateTime
-  (self: DateTime.DateTime, that: DateTime.DateTime): DateTime.DateTime
+  <That extends DateTime.DateTime>(that: That): <Self extends DateTime.DateTime>(self: Self) => Self | That
+  <Self extends DateTime.DateTime, That extends DateTime.DateTime>(self: Self, that: That): Self | That
 } = order.max(Order)
 
 /** @internal */
@@ -544,8 +574,12 @@ export const zonedOffset = (self: DateTime.Zoned): number => {
 
 const offsetToString = (offset: number): string => {
   const abs = Math.abs(offset)
-  const hours = Math.floor(abs / (60 * 60 * 1000))
-  const minutes = Math.round((abs % (60 * 60 * 1000)) / (60 * 1000))
+  let hours = Math.floor(abs / (60 * 60 * 1000))
+  let minutes = Math.round((abs % (60 * 60 * 1000)) / (60 * 1000))
+  if (minutes === 60) {
+    hours += 1
+    minutes = 0
+  }
   return `${offset < 0 ? "-" : "+"}${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`
 }
 
@@ -641,11 +675,11 @@ const setPartsDate = (date: Date, parts: Partial<DateTime.DateTime.PartsWithWeek
 export const setParts: {
   (
     parts: Partial<DateTime.DateTime.PartsWithWeekday>
-  ): <A extends DateTime.DateTime>(self: A) => DateTime.DateTime.PreserveZone<A>
+  ): <A extends DateTime.DateTime>(self: A) => A
   <A extends DateTime.DateTime>(
     self: A,
     parts: Partial<DateTime.DateTime.PartsWithWeekday>
-  ): DateTime.DateTime.PreserveZone<A>
+  ): A
 } = dual(
   2,
   (self: DateTime.DateTime, parts: Partial<DateTime.DateTime.PartsWithWeekday>): DateTime.DateTime =>
@@ -656,11 +690,11 @@ export const setParts: {
 export const setPartsUtc: {
   (
     parts: Partial<DateTime.DateTime.PartsWithWeekday>
-  ): <A extends DateTime.DateTime>(self: A) => DateTime.DateTime.PreserveZone<A>
+  ): <A extends DateTime.DateTime>(self: A) => A
   <A extends DateTime.DateTime>(
     self: A,
     parts: Partial<DateTime.DateTime.PartsWithWeekday>
-  ): DateTime.DateTime.PreserveZone<A>
+  ): A
 } = dual(
   2,
   (self: DateTime.DateTime, parts: Partial<DateTime.DateTime.PartsWithWeekday>): DateTime.DateTime =>
@@ -701,8 +735,8 @@ const calculateNamedOffset = (adjustedMillis: number, zone: DateTime.TimeZone.Na
 
 /** @internal */
 export const mutate: {
-  (f: (date: Date) => void): <A extends DateTime.DateTime>(self: A) => DateTime.DateTime.PreserveZone<A>
-  <A extends DateTime.DateTime>(self: A, f: (date: Date) => void): DateTime.DateTime.PreserveZone<A>
+  (f: (date: Date) => void): <A extends DateTime.DateTime>(self: A) => A
+  <A extends DateTime.DateTime>(self: A, f: (date: Date) => void): A
 } = dual(2, (self: DateTime.DateTime, f: (date: Date) => void): DateTime.DateTime => {
   if (self._tag === "Utc") {
     const date = toDateUtc(self)
@@ -717,8 +751,8 @@ export const mutate: {
 
 /** @internal */
 export const mutateUtc: {
-  (f: (date: Date) => void): <A extends DateTime.DateTime>(self: A) => DateTime.DateTime.PreserveZone<A>
-  <A extends DateTime.DateTime>(self: A, f: (date: Date) => void): DateTime.DateTime.PreserveZone<A>
+  (f: (date: Date) => void): <A extends DateTime.DateTime>(self: A) => A
+  <A extends DateTime.DateTime>(self: A, f: (date: Date) => void): A
 } = dual(2, (self: DateTime.DateTime, f: (date: Date) => void): DateTime.DateTime =>
   mapEpochMillis(self, (millis) => {
     const date = new Date(millis)
@@ -728,8 +762,8 @@ export const mutateUtc: {
 
 /** @internal */
 export const mapEpochMillis: {
-  (f: (millis: number) => number): <A extends DateTime.DateTime>(self: A) => DateTime.DateTime.PreserveZone<A>
-  <A extends DateTime.DateTime>(self: A, f: (millis: number) => number): DateTime.DateTime.PreserveZone<A>
+  (f: (millis: number) => number): <A extends DateTime.DateTime>(self: A) => A
+  <A extends DateTime.DateTime>(self: A, f: (millis: number) => number): A
 } = dual(2, (self: DateTime.DateTime, f: (millis: number) => number): DateTime.DateTime => {
   const millis = f(toEpochMillis(self))
   return self._tag === "Utc" ? makeUtc(millis) : makeZonedProto(millis, self.zone)
@@ -768,8 +802,8 @@ export const match: {
 
 /** @internal */
 export const addDuration: {
-  (duration: Duration.DurationInput): <A extends DateTime.DateTime>(self: A) => DateTime.DateTime.PreserveZone<A>
-  <A extends DateTime.DateTime>(self: A, duration: Duration.DurationInput): DateTime.DateTime.PreserveZone<A>
+  (duration: Duration.DurationInput): <A extends DateTime.DateTime>(self: A) => A
+  <A extends DateTime.DateTime>(self: A, duration: Duration.DurationInput): A
 } = dual(
   2,
   (self: DateTime.DateTime, duration: Duration.DurationInput): DateTime.DateTime =>
@@ -778,8 +812,8 @@ export const addDuration: {
 
 /** @internal */
 export const subtractDuration: {
-  (duration: Duration.DurationInput): <A extends DateTime.DateTime>(self: A) => DateTime.DateTime.PreserveZone<A>
-  <A extends DateTime.DateTime>(self: A, duration: Duration.DurationInput): DateTime.DateTime.PreserveZone<A>
+  (duration: Duration.DurationInput): <A extends DateTime.DateTime>(self: A) => A
+  <A extends DateTime.DateTime>(self: A, duration: Duration.DurationInput): A
 } = dual(
   2,
   (self: DateTime.DateTime, duration: Duration.DurationInput): DateTime.DateTime =>
@@ -794,11 +828,11 @@ const addMillis = (date: Date, amount: number): void => {
 export const add: {
   (
     parts: Partial<DateTime.DateTime.PartsForMath>
-  ): <A extends DateTime.DateTime>(self: A) => DateTime.DateTime.PreserveZone<A>
+  ): <A extends DateTime.DateTime>(self: A) => A
   <A extends DateTime.DateTime>(
     self: A,
     parts: Partial<DateTime.DateTime.PartsForMath>
-  ): DateTime.DateTime.PreserveZone<A>
+  ): A
 } = dual(
   2,
   (self: DateTime.DateTime, parts: Partial<DateTime.DateTime.PartsForMath>): DateTime.DateTime =>
@@ -847,11 +881,11 @@ export const add: {
 export const subtract: {
   (
     parts: Partial<DateTime.DateTime.PartsForMath>
-  ): <A extends DateTime.DateTime>(self: A) => DateTime.DateTime.PreserveZone<A>
+  ): <A extends DateTime.DateTime>(self: A) => A
   <A extends DateTime.DateTime>(
     self: A,
     parts: Partial<DateTime.DateTime.PartsForMath>
-  ): DateTime.DateTime.PreserveZone<A>
+  ): A
 } = dual(2, (self: DateTime.DateTime, parts: Partial<DateTime.DateTime.PartsForMath>): DateTime.DateTime => {
   const newParts = {} as Partial<Mutable<DateTime.DateTime.PartsForMath>>
   for (const key in parts) {
@@ -905,10 +939,10 @@ const startOfDate = (date: Date, part: DateTime.DateTime.UnitSingular, options?:
 export const startOf: {
   (part: DateTime.DateTime.UnitSingular, options?: {
     readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-  }): <A extends DateTime.DateTime>(self: A) => DateTime.DateTime.PreserveZone<A>
+  }): <A extends DateTime.DateTime>(self: A) => A
   <A extends DateTime.DateTime>(self: A, part: DateTime.DateTime.UnitSingular, options?: {
     readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-  }): DateTime.DateTime.PreserveZone<A>
+  }): A
 } = dual(isDateTimeArgs, (self: DateTime.DateTime, part: DateTime.DateTime.UnitSingular, options?: {
   readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
 }): DateTime.DateTime => mutate(self, (date) => startOfDate(date, part, options)))
@@ -958,10 +992,10 @@ const endOfDate = (date: Date, part: DateTime.DateTime.UnitSingular, options?: {
 export const endOf: {
   (part: DateTime.DateTime.UnitSingular, options?: {
     readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-  }): <A extends DateTime.DateTime>(self: A) => DateTime.DateTime.PreserveZone<A>
+  }): <A extends DateTime.DateTime>(self: A) => A
   <A extends DateTime.DateTime>(self: A, part: DateTime.DateTime.UnitSingular, options?: {
     readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-  }): DateTime.DateTime.PreserveZone<A>
+  }): A
 } = dual(isDateTimeArgs, (self: DateTime.DateTime, part: DateTime.DateTime.UnitSingular, options?: {
   readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
 }): DateTime.DateTime => mutate(self, (date) => endOfDate(date, part, options)))
@@ -970,10 +1004,10 @@ export const endOf: {
 export const nearest: {
   (part: DateTime.DateTime.UnitSingular, options?: {
     readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-  }): <A extends DateTime.DateTime>(self: A) => DateTime.DateTime.PreserveZone<A>
+  }): <A extends DateTime.DateTime>(self: A) => A
   <A extends DateTime.DateTime>(self: A, part: DateTime.DateTime.UnitSingular, options?: {
     readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-  }): DateTime.DateTime.PreserveZone<A>
+  }): A
 } = dual(isDateTimeArgs, (self: DateTime.DateTime, part: DateTime.DateTime.UnitSingular, options?: {
   readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
 }): DateTime.DateTime =>

package/src/internal/effect/circular.ts

@@ -27,7 +27,6 @@ import type * as Types from "../../Types.js"
 import * as internalCause from "../cause.js"
 import * as effect from "../core-effect.js"
 import * as core from "../core.js"
-import * as executionStrategy from "../executionStrategy.js"
 import * as internalFiber from "../fiber.js"
 import * as fiberRuntime from "../fiberRuntime.js"
 import { globalScope } from "../fiberScope.js"
@@ -362,23 +361,26 @@ export const forkIn = dual<
 >(
   2,
   (self, scope) =>
-    core.uninterruptibleMask((restore) =>
-      core.flatMap(scope.fork(executionStrategy.sequential), (child) =>
-        pipe(
-          restore(self),
-          core.onExit((exit) => child.close(exit)),
-          fiberRuntime.forkDaemon,
-          core.tap((fiber) =>
-            child.addFinalizer(() =>
-              core.fiberIdWith((fiberId) =>
-                Equal.equals(fiberId, fiber.id()) ?
-                  core.void :
-                  core.asVoid(core.interruptFiber(fiber))
-              )
-            )
+    core.withFiberRuntime((parent, parentStatus) => {
+      const scopeImpl = scope as fiberRuntime.ScopeImpl
+      const fiber = fiberRuntime.unsafeFork(self, parent, parentStatus.runtimeFlags, globalScope)
+      if (scopeImpl.state._tag === "Open") {
+        const finalizer = () =>
+          core.fiberIdWith((fiberId) =>
+            Equal.equals(fiberId, fiber.id()) ?
+              core.void :
+              core.asVoid(core.interruptFiber(fiber))
           )
-        ))
-    )
+        scopeImpl.state.finalizers.add(finalizer)
+        fiber.addObserver(() => {
+          if (scopeImpl.state._tag === "Closed") return
+          scopeImpl.state.finalizers.delete(finalizer)
+        })
+      } else {
+        fiber.unsafeInterruptAsFork(parent.id())
+      }
+      return core.succeed(fiber)
+    })
 )
 
 /** @internal */

package/src/internal/fiberRuntime.ts

@@ -3207,7 +3207,8 @@ export const scopeTag = Context.GenericTag<Scope.Scope>("effect/Scope")
 /* @internal */
 export const scope: Effect.Effect<Scope.Scope, never, Scope.Scope> = scopeTag
 
-interface ScopeImpl extends Scope.CloseableScope {
+/** @internal */
+export interface ScopeImpl extends Scope.CloseableScope {
   state: {
     readonly _tag: "Open"
     readonly finalizers: Set<Scope.Scope.Finalizer>

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.12.3"
+let moduleVersion = "3.12.5"
 
 export const getCurrentVersion = () => moduleVersion