effect 4.0.0-beta.30 → 4.0.0-beta.32

package/src/DateTime.ts

@@ -10,6 +10,7 @@ import type { Inspectable } from "./Inspectable.ts"
 import * as Internal from "./internal/dateTime.ts"
 import { provideService } from "./internal/effect.ts"
 import * as Layer from "./Layer.ts"
+import type * as Option from "./Option.ts"
 import type * as order from "./Order.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import * as ServiceMap from "./ServiceMap.ts"
@@ -21,70 +22,30 @@ const TimeZoneTypeId = Internal.TimeZoneTypeId
  * A `DateTime` represents a point in time. It can optionally have a time zone
  * associated with it.
  *
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * // Create a UTC DateTime
- * const utc: DateTime.DateTime = DateTime.nowUnsafe()
- *
- * // Create a zoned DateTime
- * const zoned: DateTime.DateTime = DateTime.makeZonedUnsafe(new Date(), {
- *   timeZone: "Europe/London"
- * })
- * ```
- *
  * @since 3.6.0
  * @category models
  */
 export type DateTime = Utc | Zoned
 
 /**
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * const utc = DateTime.nowUnsafe()
- *
- * if (DateTime.isUtc(utc)) {
- *   console.log(utc._tag) // "Utc"
- *   console.log(utc.epochMillis) // timestamp in milliseconds
- * }
- * ```
- *
  * @since 3.6.0
  * @category models
  */
 export interface Utc extends DateTime.Proto {
   readonly _tag: "Utc"
-  readonly epochMillis: number
+  readonly epochMilliseconds: number
   partsUtc: DateTime.PartsWithWeekday | undefined
 }
 
 /**
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * const zoned = DateTime.makeZonedUnsafe(new Date(), {
- *   timeZone: "Europe/London"
- * })
- *
- * if (DateTime.isZoned(zoned)) {
- *   console.log(zoned._tag) // "Zoned"
- *   console.log(zoned.epochMillis) // timestamp in milliseconds
- *   console.log(DateTime.zoneToString(zoned.zone)) // "Europe/London"
- * }
- * ```
- *
  * @since 3.6.0
  * @category models
  */
 export interface Zoned extends DateTime.Proto {
   readonly _tag: "Zoned"
-  readonly epochMillis: number
+  readonly epochMilliseconds: number
   readonly zone: TimeZone
-  adjustedEpochMillis: number | undefined
+  adjustedEpochMilliseconds: number | undefined
   partsAdjusted: DateTime.PartsWithWeekday | undefined
   partsUtc: DateTime.PartsWithWeekday | undefined
 }
@@ -95,29 +56,10 @@ export interface Zoned extends DateTime.Proto {
  */
 export declare namespace DateTime {
   /**
-   * @example
-   * ```ts
-   * import { DateTime } from "effect"
-   *
-   * // All valid inputs for DateTime constructors
-   * const date = new Date()
-   * const stringDate = "2024-01-01"
-   * const epochMillis = 1704067200000
-   * const partsObj = { year: 2024, month: 1, day: 1 }
-   * const existing = DateTime.nowUnsafe()
-   *
-   * // All these can be used as DateTime.Input
-   * const dt1 = DateTime.makeUnsafe(date)
-   * const dt2 = DateTime.makeUnsafe(stringDate)
-   * const dt3 = DateTime.makeUnsafe(epochMillis)
-   * const dt4 = DateTime.makeUnsafe(partsObj)
-   * const dt5 = DateTime.makeUnsafe(existing)
-   * ```
-   *
    * @since 3.6.0
    * @category models
    */
-  export type Input = DateTime | Partial<Parts> | Date | number | string
+  export type Input = DateTime | Partial<Parts> | Instant | InstantWithZone | Date | number | string
 
   /**
    * @since 3.6.0
@@ -136,7 +78,7 @@ export declare namespace DateTime {
    * @category models
    */
   export type UnitSingular =
-    | "milli"
+    | "millisecond"
     | "second"
     | "minute"
     | "hour"
@@ -150,7 +92,7 @@ export declare namespace DateTime {
    * @category models
    */
   export type UnitPlural =
-    | "millis"
+    | "milliseconds"
     | "seconds"
     | "minutes"
     | "hours"
@@ -164,10 +106,10 @@ export declare namespace DateTime {
    * @category models
    */
   export interface PartsWithWeekday {
-    readonly millis: number
-    readonly seconds: number
-    readonly minutes: number
-    readonly hours: number
+    readonly millisecond: number
+    readonly second: number
+    readonly minute: number
+    readonly hour: number
     readonly day: number
     readonly weekDay: number
     readonly month: number
@@ -179,10 +121,10 @@ export declare namespace DateTime {
    * @category models
    */
   export interface Parts {
-    readonly millis: number
-    readonly seconds: number
-    readonly minutes: number
-    readonly hours: number
+    readonly millisecond: number
+    readonly second: number
+    readonly minute: number
+    readonly hour: number
     readonly day: number
     readonly month: number
     readonly year: number
@@ -193,7 +135,7 @@ export declare namespace DateTime {
    * @category models
    */
   export interface PartsForMath {
-    readonly millis: number
+    readonly milliseconds: number
     readonly seconds: number
     readonly minutes: number
     readonly hours: number
@@ -203,6 +145,23 @@ export declare namespace DateTime {
     readonly years: number
   }
 
+  /**
+   * @since 4.0.0
+   * @category models
+   */
+  export interface Instant {
+    readonly epochMilliseconds: number
+  }
+
+  /**
+   * @since 4.0.0
+   * @category models
+   */
+  export interface InstantWithZone {
+    readonly timeZoneId: string
+    readonly epochMilliseconds: number
+  }
+
   /**
    * @since 3.6.0
    * @category models
@@ -599,7 +558,7 @@ export const makeZoned: (
     readonly adjustForTimeZone?: boolean | undefined
     readonly disambiguation?: Disambiguation | undefined
   }
-) => Zoned | undefined = Internal.makeZoned
+) => Option.Option<Zoned> = Internal.makeZoned
 
 /**
  * Create a `DateTime` from one of the following:
@@ -628,7 +587,7 @@ export const makeZoned: (
  * DateTime.make("2024-01-01")
  * ```
  */
-export const make: <A extends DateTime.Input>(input: A) => DateTime.PreserveZone<A> | undefined = Internal.make
+export const make: <A extends DateTime.Input>(input: A) => Option.Option<DateTime.PreserveZone<A>> = Internal.make
 
 /**
  * Create a `DateTime.Zoned` from a string.
@@ -642,19 +601,19 @@ export const make: <A extends DateTime.Input>(input: A) => DateTime.PreserveZone
  * const result1 = DateTime.makeZonedFromString(
  *   "2024-01-01T12:00:00+02:00[Europe/Berlin]"
  * )
- * console.log(result1 !== undefined) // true
+ * console.log(result1._tag === "Some") // true
  *
  * const result2 = DateTime.makeZonedFromString("2024-01-01T12:00:00Z")
- * console.log(result2 !== undefined) // true
+ * console.log(result2._tag === "Some") // true
  *
  * const invalid = DateTime.makeZonedFromString("invalid")
- * console.log(invalid === undefined) // true
+ * console.log(invalid._tag === "None") // true
  * ```
  *
  * @since 3.6.0
  * @category constructors
  */
-export const makeZonedFromString: (input: string) => Zoned | undefined = Internal.makeZonedFromString
+export const makeZonedFromString: (input: string) => Option.Option<Zoned> = Internal.makeZonedFromString
 
 /**
  * Get the current time using the `Clock` service and convert it to a `DateTime`.
@@ -934,16 +893,16 @@ export const zoneMakeOffset: (offset: number) => TimeZone.Offset = Internal.zone
  * import { DateTime } from "effect"
  *
  * const validZone = DateTime.zoneMakeNamed("Europe/London")
- * console.log(validZone !== undefined) // true
+ * console.log(validZone._tag === "Some") // true
  *
  * const invalidZone = DateTime.zoneMakeNamed("Invalid/Zone")
- * console.log(invalidZone === undefined) // true
+ * console.log(invalidZone._tag === "None") // true
  * ```
  *
  * @category time zones
  * @since 3.6.0
  */
-export const zoneMakeNamed: (zoneId: string) => TimeZone.Named | undefined = Internal.zoneMakeNamed
+export const zoneMakeNamed: (zoneId: string) => Option.Option<TimeZone.Named> = Internal.zoneMakeNamed
 
 /**
  * Create a named time zone from a IANA time zone identifier.
@@ -1002,15 +961,15 @@ export const zoneMakeLocal: () => TimeZone.Named = Internal.zoneMakeLocal
  * const offsetZone = DateTime.zoneFromString("+03:00")
  * const invalid = DateTime.zoneFromString("invalid")
  *
- * console.log(namedZone !== undefined) // true
- * console.log(offsetZone !== undefined) // true
- * console.log(invalid === undefined) // true
+ * console.log(namedZone._tag === "Some") // true
+ * console.log(offsetZone._tag === "Some") // true
+ * console.log(invalid._tag === "None") // true
  * ```
  *
  * @category time zones
  * @since 3.6.0
  */
-export const zoneFromString: (zone: string) => TimeZone | undefined = Internal.zoneFromString
+export const zoneFromString: (zone: string) => Option.Option<TimeZone> = Internal.zoneFromString
 
 /**
  * Format a `TimeZone` as a string.
@@ -1071,7 +1030,7 @@ export const setZoneNamed: {
      readonly adjustForTimeZone?: boolean | undefined
      readonly disambiguation?: Disambiguation | undefined
    }
-  ): (self: DateTime) => Zoned | undefined
+  ): (self: DateTime) => Option.Option<Zoned>
   /**
    * Set the time zone of a `DateTime` from an IANA time zone identifier. If the
    * time zone is invalid, `None` will be returned.
@@ -1096,7 +1055,7 @@ export const setZoneNamed: {
      readonly adjustForTimeZone?: boolean | undefined
      readonly disambiguation?: Disambiguation | undefined
    }
-  ): Zoned | undefined
+  ): Option.Option<Zoned>
 } = Internal.setZoneNamed
 
 /**
@@ -2138,7 +2097,7 @@ export const setParts: {
  * const dt = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
  * const updated = DateTime.setPartsUtc(dt, {
  *   year: 2025,
- *   hours: 18
+ *   hour: 18
  * })
  *
  * console.log(DateTime.formatIso(updated)) // "2025-01-01T18:00:00.000Z"
@@ -2160,7 +2119,7 @@ export const setPartsUtc: {
    * const dt = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
    * const updated = DateTime.setPartsUtc(dt, {
    *   year: 2025,
-   *   hours: 18
+   *   hour: 18
    * })
    *
    * console.log(DateTime.formatIso(updated)) // "2025-01-01T18:00:00.000Z"
@@ -2182,7 +2141,7 @@ export const setPartsUtc: {
    * const dt = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
    * const updated = DateTime.setPartsUtc(dt, {
    *   year: 2025,
-   *   hours: 18
+   *   hour: 18
    * })
    *
    * console.log(DateTime.formatIso(updated)) // "2025-01-01T18:00:00.000Z"

package/src/Deferred.ts

@@ -72,6 +72,7 @@ import type * as Exit from "./Exit.ts"
 import { dual, identity, type LazyArg } from "./Function.ts"
 import * as core from "./internal/core.ts"
 import * as internalEffect from "./internal/effect.ts"
+import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
 import type * as Types from "./Types.ts"
@@ -973,8 +974,9 @@ export const isDone = <A, E>(self: Deferred<A, E>): Effect<boolean> => internalE
 export const isDoneUnsafe = <A, E>(self: Deferred<A, E>): boolean => self.effect !== undefined
 
 /**
- * Returns a `Effect<A, E, R>` from the `Deferred` if this `Deferred` has
- * already been completed, `undefined` otherwise.
+ * Returns the current completion effect as an `Option`. This returns
+ * `Option.some(effect)` when the `Deferred` is completed, `Option.none()`
+ * otherwise.
  *
  * @example
  * ```ts
@@ -983,19 +985,19 @@ export const isDoneUnsafe = <A, E>(self: Deferred<A, E>): boolean => self.effect
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number>()
  *   const beforeCompletion = yield* Deferred.poll(deferred)
- *   console.log(beforeCompletion === undefined) // true
+ *   console.log(beforeCompletion._tag === "None") // true
  *
  *   yield* Deferred.succeed(deferred, 42)
  *   const afterCompletion = yield* Deferred.poll(deferred)
- *   console.log(afterCompletion !== undefined) // true
+ *   console.log(afterCompletion._tag === "Some") // true
  * })
  * ```
  *
  * @since 2.0.0
  * @category getters
  */
-export function poll<A, E>(self: Deferred<A, E>): Effect<Effect<A, E> | undefined> {
-  return internalEffect.sync(() => self.effect)
+export function poll<A, E>(self: Deferred<A, E>): Effect<Option.Option<Effect<A, E>>> {
+  return internalEffect.sync(() => Option.fromUndefinedOr(self.effect))
 }
 
 /**

package/src/Duration.ts

@@ -20,12 +20,12 @@ import { dual, identity } from "./Function.ts"
 import * as Hash from "./Hash.ts"
 import type * as Inspectable from "./Inspectable.ts"
 import { NodeInspectSymbol } from "./Inspectable.ts"
+import * as Option from "./Option.ts"
 import * as order from "./Order.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
-import { hasProperty, isBigInt, isNumber, isString } from "./Predicate.ts"
+import { hasProperty, isNumber } from "./Predicate.ts"
 import * as Reducer from "./Reducer.ts"
-import * as UndefinedOr from "./UndefinedOr.ts"
 
 const TypeId = "~effect/time/Duration"
 
@@ -96,6 +96,36 @@ export type Input =
   | bigint // nanos
   | readonly [seconds: number, nanos: number]
   | `${number} ${Unit}`
+  | DurationObject
+
+/**
+ * An object with optional duration components that can be combined to create
+ * a Duration. All fields are optional and additive.
+ *
+ * Compatible with Temporal.Duration-like objects.
+ *
+ * @example
+ * ```ts
+ * import { Duration } from "effect"
+ *
+ * Duration.fromInputUnsafe({ seconds: 30 })
+ * Duration.fromInputUnsafe({ days: 1 })
+ * Duration.fromInputUnsafe({ seconds: 1, nanoseconds: 500 })
+ * ```
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export interface DurationObject {
+  readonly weeks?: number | undefined
+  readonly days?: number | undefined
+  readonly hours?: number | undefined
+  readonly minutes?: number | undefined
+  readonly seconds?: number | undefined
+  readonly milliseconds?: number | undefined
+  readonly microseconds?: number | undefined
+  readonly nanoseconds?: number | undefined
+}
 
 const DURATION_REGEXP = /^(-?\d+(?:\.\d+)?)\s+(nanos?|micros?|millis?|seconds?|minutes?|hours?|days?|weeks?)$/
 
@@ -117,27 +147,14 @@ const DURATION_REGEXP = /^(-?\d+(?:\.\d+)?)\s+(nanos?|micros?|millis?|seconds?|m
  * @category constructors
  */
 export const fromInputUnsafe = (input: Input): Duration => {
-  if (isDuration(input)) return input
-  if (isNumber(input)) return millis(input)
-  if (isBigInt(input)) return nanos(input)
-  if (Array.isArray(input) && input.length === 2 && input.every(isNumber)) {
-    if (Number.isNaN(input[0]) || Number.isNaN(input[1])) {
-      return zero
-    }
-
-    if (input[0] === -Infinity || input[1] === -Infinity) {
-      return negativeInfinity
-    }
-
-    if (input[0] === Infinity || input[1] === Infinity) {
-      return infinity
-    }
-
-    return nanos(BigInt(Math.round(input[0] * 1_000_000_000)) + BigInt(Math.round(input[1])))
-  }
-  if (isString(input)) {
-    const match = DURATION_REGEXP.exec(input)
-    if (match) {
+  switch (typeof input) {
+    case "number":
+      return millis(input)
+    case "bigint":
+      return nanos(input)
+    case "string": {
+      const match = DURATION_REGEXP.exec(input)
+      if (!match) break
       const [_, valueStr, unit] = match
       const value = Number(valueStr)
       switch (unit) {
@@ -166,29 +183,67 @@ export const fromInputUnsafe = (input: Input): Duration => {
         case "weeks":
           return weeks(value)
       }
+      break
+    }
+    case "object": {
+      if (input === null) break
+      if (TypeId in input) return input as Duration
+      if (Array.isArray(input)) {
+        if (input.length !== 2 || !input.every(isNumber)) {
+          return invalid(input)
+        }
+        if (Number.isNaN(input[0]) || Number.isNaN(input[1])) {
+          return zero
+        }
+        if (input[0] === -Infinity || input[1] === -Infinity) {
+          return negativeInfinity
+        }
+        if (input[0] === Infinity || input[1] === Infinity) {
+          return infinity
+        }
+        return make(BigInt(Math.round(input[0] * 1_000_000_000)) + BigInt(Math.round(input[1])))
+      }
+      const obj = input as DurationObject
+      let millis = 0
+      // we can use truthy checks here, because 0 can be ignored
+      if (obj.weeks) millis += obj.weeks * 604_800_000
+      if (obj.days) millis += obj.days * 86_400_000
+      if (obj.hours) millis += obj.hours * 3_600_000
+      if (obj.minutes) millis += obj.minutes * 60_000
+      if (obj.seconds) millis += obj.seconds * 1_000
+      if (obj.milliseconds) millis += obj.milliseconds
+      if (!obj.microseconds && !obj.nanoseconds) return make(millis)
+      let nanos = BigInt(millis) * bigint1e6
+      if (obj.microseconds) nanos += BigInt(obj.microseconds) * bigint1e3
+      if (obj.nanoseconds) nanos += BigInt(obj.nanoseconds)
+      return make(nanos)
     }
   }
+  return invalid(input)
+}
+
+const invalid = (input: unknown): never => {
   throw new Error(`Invalid Input: ${input}`)
 }
 
 /**
  * Safely decodes a `Input` value into a `Duration`, returning
- * `undefined` if decoding fails.
+ * `Option.none()` if decoding fails.
  *
  * **Example**
  *
  * ```ts
- * import { Duration } from "effect"
+ * import { Duration, Option } from "effect"
  *
- * Duration.fromInput(1000)?.pipe(Duration.toSeconds) // 1
+ * Duration.fromInput(1000).pipe(Option.map(Duration.toSeconds)) // Some(1)
  *
- * Duration.fromInput("invalid" as any) // undefined
+ * Duration.fromInput("invalid" as any) // None
  * ```
  *
  * @category constructors
  * @since 4.0.0
  */
-export const fromInput: (u: Input) => Duration | undefined = UndefinedOr.liftThrowable(
+export const fromInput: (u: Input) => Option.Option<Duration> = Option.liftThrowable(
   fromInputUnsafe
 )
 
@@ -238,7 +293,7 @@ const DurationProto: Omit<Duration, "value"> = {
 
 const make = (input: number | bigint): Duration => {
   const duration = Object.create(DurationProto)
-  if (isNumber(input)) {
+  if (typeof input === "number") {
     if (isNaN(input) || input === 0 || Object.is(input, -0)) {
       duration.value = zeroDurationValue
     } else if (!Number.isFinite(input)) {
@@ -768,22 +823,23 @@ export const toNanosUnsafe = (self: Duration): bigint => {
 /**
  * Get the duration in nanoseconds as a bigint.
  *
- * If the duration is infinite, returns `undefined`.
+ * If the duration is infinite, returns `Option.none()`.
  *
  * **Example**
  *
  * ```ts
- * import { Duration } from "effect"
+ * import { Duration, Option } from "effect"
  *
- * Duration.toNanos(Duration.seconds(1)) // 1000000000n
+ * Duration.toNanos(Duration.seconds(1)) // Some(1000000000n)
  *
- * Duration.toNanos(Duration.infinity) // undefined
+ * Duration.toNanos(Duration.infinity) // None
+ * Option.getOrUndefined(Duration.toNanos(Duration.infinity)) // undefined
  * ```
  *
  * @category getters
  * @since 4.0.0
  */
-export const toNanos: (self: Duration) => bigint | undefined = UndefinedOr.liftThrowable(toNanosUnsafe)
+export const toNanos: (self: Duration) => Option.Option<bigint> = Option.liftThrowable(toNanosUnsafe)
 
 /**
  * Converts a Duration to high-resolution time format [seconds, nanoseconds].
@@ -1279,17 +1335,17 @@ export const clamp: {
 } = order.clamp(Order)
 
 /**
- * Divides a Duration by a number, returning `undefined` if division is invalid.
+ * Divides a Duration by a number, returning `Option.none()` if division is invalid.
  *
  * **Example**
  *
  * ```ts
- * import { Duration } from "effect"
+ * import { Duration, Option } from "effect"
  *
  * const d = Duration.divide(Duration.seconds(10), 2)
- * console.log(d?.pipe(Duration.toSeconds)) // 5
+ * console.log(Option.map(d, Duration.toSeconds)) // Some(5)
  *
- * Duration.divide(Duration.seconds(10), 0) // undefined
+ * Duration.divide(Duration.seconds(10), 0) // None
  * ```
  *
  * @since 4.0.0
@@ -1297,57 +1353,57 @@ export const clamp: {
  */
 export const divide: {
   /**
-   * Divides a Duration by a number, returning `undefined` if division is invalid.
+   * Divides a Duration by a number, returning `Option.none()` if division is invalid.
    *
    * **Example**
    *
    * ```ts
-   * import { Duration } from "effect"
+   * import { Duration, Option } from "effect"
    *
    * const d = Duration.divide(Duration.seconds(10), 2)
-   * console.log(d?.pipe(Duration.toSeconds)) // 5
+   * console.log(Option.map(d, Duration.toSeconds)) // Some(5)
    *
-   * Duration.divide(Duration.seconds(10), 0) // undefined
+   * Duration.divide(Duration.seconds(10), 0) // None
    * ```
    *
    * @since 4.0.0
    * @category math
    */
-  (by: number): (self: Duration) => Duration | undefined
+  (by: number): (self: Duration) => Option.Option<Duration>
   /**
-   * Divides a Duration by a number, returning `undefined` if division is invalid.
+   * Divides a Duration by a number, returning `Option.none()` if division is invalid.
    *
    * **Example**
    *
    * ```ts
-   * import { Duration } from "effect"
+   * import { Duration, Option } from "effect"
    *
    * const d = Duration.divide(Duration.seconds(10), 2)
-   * console.log(d?.pipe(Duration.toSeconds)) // 5
+   * console.log(Option.map(d, Duration.toSeconds)) // Some(5)
    *
-   * Duration.divide(Duration.seconds(10), 0) // undefined
+   * Duration.divide(Duration.seconds(10), 0) // None
    * ```
    *
    * @since 4.0.0
    * @category math
    */
-  (self: Duration, by: number): Duration | undefined
+  (self: Duration, by: number): Option.Option<Duration>
 } = dual(
   2,
-  (self: Duration, by: number): Duration | undefined => {
-    if (!Number.isFinite(by)) return undefined
-    if (by === 0 || Object.is(by, -0)) return undefined
+  (self: Duration, by: number): Option.Option<Duration> => {
+    if (!Number.isFinite(by)) return Option.none()
+    if (by === 0 || Object.is(by, -0)) return Option.none()
     return match(self, {
-      onMillis: (millis) => make(millis / by),
+      onMillis: (millis) => Option.some(make(millis / by)),
       onNanos: (nanos) => {
         try {
-          return make(nanos / BigInt(by))
+          return Option.some(make(nanos / BigInt(by)))
         } catch {
-          return undefined
+          return Option.none()
         }
       },
-      onInfinity: () => by > 0 ? infinity : negativeInfinity,
-      onNegativeInfinity: () => by > 0 ? negativeInfinity : infinity
+      onInfinity: () => Option.some(by > 0 ? infinity : negativeInfinity),
+      onNegativeInfinity: () => Option.some(by > 0 ? negativeInfinity : infinity)
     })
   }
 )

package/src/Effect.ts

@@ -22729,7 +22729,6 @@ export const transactionWith = <A, E, R>(
   withFiber((fiber) => {
     // Always create a new transaction state, never compose with parent
     const state: Transaction["Service"] = { journal: new Map(), retry: false }
-    const scheduler = fiber.currentScheduler
     let result: Exit.Exit<A, E> | undefined
     return uninterruptibleMask((restore) =>
       flatMap(
@@ -22750,7 +22749,7 @@ export const transactionWith = <A, E, R>(
               return clearTransaction(state)
             }
             if (Exit.isSuccess(exit)) {
-              commitTransaction(scheduler, state)
+              commitTransaction(fiber, state)
             } else {
               clearTransaction(state)
             }
@@ -22792,14 +22791,14 @@ const awaitPendingTransaction = (state: Transaction["Service"]) =>
     })
   })
 
-function commitTransaction(scheduler: Scheduler, state: Transaction["Service"]) {
+function commitTransaction(fiber: Fiber<unknown, unknown>, state: Transaction["Service"]) {
   for (const [ref, { value }] of state.journal) {
     if (value !== ref.value) {
       ref.version = ref.version + 1
       ref.value = value
     }
     for (const pending of ref.pending.values()) {
-      scheduler.scheduleTask(pending, 0)
+      fiber.currentDispatcher.scheduleTask(pending, 0)
     }
     ref.pending.clear()
   }