effect 4.0.0-beta.103 → 4.0.0-beta.105

package/src/Stream.ts

@@ -9657,6 +9657,13 @@ const retryWithoutReset = <A, E, R, X, E2, R2>(
  * `preventFallbackOnPartialStream` to fail instead of mixing partial output with
  * a later fallback.
  *
+ * Attempts can be observed from outside the stream by passing
+ * `options.onEvent`, which receives an `ExecutionPlan.Event` before each
+ * attempt and after it settles; see `Effect.withExecutionPlan` for the handler
+ * semantics. When a downstream consumer stops pulling early (for example
+ * `Stream.take` outside the plan), the truncated attempt reports
+ * `AttemptSuccess`: the consumer stopped, not the source.
+ *
  * **Example** (Applying an execution plan)
  *
  * ```ts import.meta.vitest
@@ -9700,6 +9707,13 @@ export const withExecutionPlan: {
    * `preventFallbackOnPartialStream` to fail instead of mixing partial output with
    * a later fallback.
    *
+   * Attempts can be observed from outside the stream by passing
+   * `options.onEvent`, which receives an `ExecutionPlan.Event` before each
+   * attempt and after it settles; see `Effect.withExecutionPlan` for the handler
+   * semantics. When a downstream consumer stops pulling early (for example
+   * `Stream.take` outside the plan), the truncated attempt reports
+   * `AttemptSuccess`: the consumer stopped, not the source.
+   *
    * **Example** (Applying an execution plan)
    *
    * ```ts import.meta.vitest
@@ -9732,10 +9746,13 @@ export const withExecutionPlan: {
    * @category error handling
    * @since 3.16.0
    */
-  <Input, R2, Provides, PolicyE>(
+  <Input, R2, Provides, PolicyE, RX = never>(
     policy: ExecutionPlan.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>>
+    options?: {
+      readonly preventFallbackOnPartialStream?: boolean | undefined
+      readonly onEvent?: ((event: ExecutionPlan.Event<Input | PolicyE>) => Effect.Effect<void, never, RX>) | undefined
+    }
+  ): <A, E extends Input, R>(self: Stream<A, E, R>) => Stream<A, E | PolicyE, R2 | Exclude<R, Provides> | RX>
   /**
    * Applies an `ExecutionPlan` to a stream, retrying with step-provided resources
    * until it succeeds or the plan is exhausted.
@@ -9746,6 +9763,13 @@ export const withExecutionPlan: {
    * `preventFallbackOnPartialStream` to fail instead of mixing partial output with
    * a later fallback.
    *
+   * Attempts can be observed from outside the stream by passing
+   * `options.onEvent`, which receives an `ExecutionPlan.Event` before each
+   * attempt and after it settles; see `Effect.withExecutionPlan` for the handler
+   * semantics. When a downstream consumer stops pulling early (for example
+   * `Stream.take` outside the plan), the truncated attempt reports
+   * `AttemptSuccess`: the consumer stopped, not the source.
+   *
    * **Example** (Applying an execution plan)
    *
    * ```ts import.meta.vitest
@@ -9778,12 +9802,15 @@ export const withExecutionPlan: {
    * @category error handling
    * @since 3.16.0
    */
-  <A, E extends Input, R, R2, Input, Provides, PolicyE>(
+  <A, E extends Input, R, R2, Input, Provides, PolicyE, RX = never>(
     self: Stream<A, E, R>,
     policy: ExecutionPlan.ExecutionPlan<{ provides: Provides; input: Input; error: PolicyE; requirements: R2 }>,
-    options?: { readonly preventFallbackOnPartialStream?: boolean | undefined }
-  ): Stream<A, E | PolicyE, R2 | Exclude<R, Provides>>
-} = dual((args) => isStream(args[0]), <A, E extends Input, R, R2, Input, Provides, PolicyE>(
+    options?: {
+      readonly preventFallbackOnPartialStream?: boolean | undefined
+      readonly onEvent?: ((event: ExecutionPlan.Event<E | PolicyE>) => Effect.Effect<void, never, RX>) | undefined
+    }
+  ): Stream<A, E | PolicyE, R2 | Exclude<R, Provides> | RX>
+} = dual((args) => isStream(args[0]), <A, E extends Input, R, R2, Input, Provides, PolicyE, RX>(
   self: Stream<A, E, R>,
   policy: ExecutionPlan.ExecutionPlan<{
     provides: Provides
@@ -9793,8 +9820,9 @@ export const withExecutionPlan: {
   }>,
   options?: {
     readonly preventFallbackOnPartialStream?: boolean | undefined
+    readonly onEvent?: ((event: ExecutionPlan.Event<E | PolicyE>) => Effect.Effect<void, never, RX>) | undefined
   }
-): Stream<A, E | PolicyE, R2 | Exclude<R, Provides>> =>
+): Stream<A, E | PolicyE, R2 | Exclude<R, Provides> | RX> =>
   suspend(() => {
     const preventFallbackOnPartialStream = options?.preventFallbackOnPartialStream ?? false
     let i = 0
@@ -9812,6 +9840,28 @@ export const withExecutionPlan: {
         return meta
       })
     )
+    const emitter = options?.onEvent === undefined
+      ? undefined
+      : internalExecutionPlan.makeEventEmitter(options.onEvent, () => meta)
+    let attemptState: internalExecutionPlan.AttemptState | undefined
+    const instrument: (attempt: Stream<A, E | PolicyE, any>) => Stream<A, E | PolicyE, any> = emitter === undefined
+      ? identity
+      : (attempt) =>
+        onExit(
+          onStart(
+            attempt,
+            Effect.map(emitter.begin, (state) => {
+              attemptState = state
+            })
+          ),
+          (exit) =>
+            Effect.suspend(() => {
+              if (attemptState === undefined) return Effect.void
+              const state = attemptState
+              attemptState = undefined
+              return emitter.end(state, exit)
+            })
+        )
     let lastError = Option.none</**
      * Applies an `ExecutionPlan` to a stream, retrying with step-provided resources
      * until it succeeds or the plan is exhausted.
@@ -9822,6 +9872,13 @@ export const withExecutionPlan: {
      * `preventFallbackOnPartialStream` to fail instead of mixing partial output with
      * a later fallback.
      *
+     * Attempts can be observed from outside the stream by passing
+     * `options.onEvent`, which receives an `ExecutionPlan.Event` before each
+     * attempt and after it settles; see `Effect.withExecutionPlan` for the handler
+     * semantics. When a downstream consumer stops pulling early (for example
+     * `Stream.take` outside the plan), the truncated attempt reports
+     * `AttemptSuccess`: the consumer stopped, not the source.
+     *
      * **Example** (Applying an execution plan)
      *
      * ```ts import.meta.vitest
@@ -9865,7 +9922,9 @@ export const withExecutionPlan: {
         return fail(Option.getOrThrow(lastError))
       }
 
-      let nextStream: Stream<A, E | PolicyE, R2 | Exclude<R, Provides>> = provideMeta(provide(self, step.provide))
+      let nextStream: Stream<A, E | PolicyE, R2 | Exclude<R, Provides>> = provideMeta(
+        instrument(provide(self, step.provide))
+      )
       let receivedElements = false
 
       if (Option.isSome(lastError)) {
@@ -11776,12 +11835,18 @@ export const slidingSize: {
          */
         A>()
         let emitted = false
+        let skip = 0
         const pull: Pull.Pull<
           Arr.NonEmptyReadonlyArray<Arr.NonEmptyReadonlyArray<A>>,
           E | Cause.Done
         > = Effect.matchCauseEffect(upstream, {
           onSuccess(arr) {
             MutableList.appendAllUnsafe(list, arr)
+            if (skip > 0) {
+              const length = list.length
+              MutableList.takeNVoid(list, skip)
+              skip = Math.max(0, skip - length)
+            }
             if (list.length < chunkSize) return pull
             emitted = true
             const chunks = [] as any as Arr.NonEmptyArray<Arr.NonEmptyReadonlyArray<A>>
@@ -11790,10 +11855,12 @@ export const slidingSize: {
                 chunks.push(MutableList.takeN(list, chunkSize) as any)
               } else {
                 chunks.push(MutableList.toArrayN(list, chunkSize) as any)
-                if (chunkSize === 1) {
+                if (chunkSize === 1 && stepSize <= 0) {
                   MutableList.take(list)
                 } else {
+                  const length = list.length
                   MutableList.takeNVoid(list, stepSize)
+                  skip = Math.max(0, stepSize - length)
                 }
               }
             }

package/src/SynchronizedRef.ts

@@ -358,7 +358,7 @@ export const getAndUpdateSome: {
 } = dual(
   2,
   <A>(self: SynchronizedRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A> =>
-    self.semaphore.withPermit(Ref.getAndUpdateSome(self, pf))
+    self.semaphore.withPermit(Ref.getAndUpdateSome(self.backing, pf))
 )
 
 /**

package/src/Terminal.ts

@@ -121,7 +121,7 @@ const QuitErrorTypeId = "effect/platform/Terminal/QuitError"
  * @category errors
  * @since 4.0.0
  */
-export class QuitError extends Schema.ErrorClass<QuitError>("QuitError")({
+export class QuitError extends Schema.Error<QuitError>("QuitError")({
   _tag: Schema.tag("QuitError")
 }) {
   /**

package/src/Tuple.ts

@@ -43,7 +43,8 @@ import type { Apply, Lambda } from "./Struct.ts"
  * @category constructors
  * @since 2.0.0
  */
-export const make = <Elements extends ReadonlyArray<unknown>>(...elements: Elements): Elements => elements
+export const make = <const Elements extends ReadonlyArray<unknown>>(...elements: [...Elements]): [...Elements] =>
+  elements
 
 type Indices<T extends ReadonlyArray<unknown>> = Exclude<Partial<T>["length"], T["length"]>
 
@@ -138,7 +139,9 @@ type _BuildTuple<
     [...I, unknown]
   >
 
-type PickTuple<T extends ReadonlyArray<unknown>, K> = _BuildTuple<T, K>
+type PickTuple<T extends ReadonlyArray<unknown>, I extends ReadonlyArray<Indices<T>>> = {
+  -readonly [K in keyof I]: T[I[K] & keyof T]
+}
 
 /**
  * Creates a new tuple containing only the elements at the specified indices.
@@ -189,7 +192,7 @@ export const pick: {
    * @category filtering
    * @since 4.0.0
    */
-  <const T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>>(indices: I): (self: T) => PickTuple<T, I[number]>
+  <const T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>>(indices: I): (self: T) => PickTuple<T, I>
   /**
    * Creates a new tuple containing only the elements at the specified indices.
    *
@@ -214,7 +217,7 @@ export const pick: {
    * @category filtering
    * @since 4.0.0
    */
-  <const T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>>(self: T, indices: I): PickTuple<T, I[number]>
+  <const T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>>(self: T, indices: I): PickTuple<T, I>
 } = dual(
   2,
   <const T extends ReadonlyArray<unknown>>(

package/src/TxReentrantLock.ts

@@ -266,24 +266,24 @@ export const acquireWrite = (self: TxReentrantLock): Effect.Effect<number> =>
  * @category mutations
  * @since 2.0.0
  */
-export const releaseRead = (self: TxReentrantLock): Effect.Effect<number> =>
-  Effect.withFiber((fiber) =>
-    Effect.gen(function*() {
-      const state = yield* TxRef.get(self.stateRef)
-      const fiberId = fiber.id
-      const currentCount = Option.getOrElse(HashMap.get(state.readers, fiberId), () => 0)
+const releaseReadFor = (self: TxReentrantLock, fiberId: number): Effect.Effect<number> =>
+  Effect.gen(function*() {
+    const state = yield* TxRef.get(self.stateRef)
+    const currentCount = Option.getOrElse(HashMap.get(state.readers, fiberId), () => 0)
 
-      if (currentCount <= 0) return 0
+    if (currentCount <= 0) return 0
 
-      const newCount = currentCount - 1
-      const newReaders = newCount === 0
-        ? HashMap.remove(state.readers, fiberId)
-        : HashMap.set(state.readers, fiberId, newCount)
+    const newCount = currentCount - 1
+    const newReaders = newCount === 0
+      ? HashMap.remove(state.readers, fiberId)
+      : HashMap.set(state.readers, fiberId, newCount)
 
-      yield* TxRef.set(self.stateRef, { ...state, readers: newReaders })
-      return newCount
-    }).pipe(Effect.tx)
-  )
+    yield* TxRef.set(self.stateRef, { ...state, readers: newReaders })
+    return newCount
+  }).pipe(Effect.tx)
+
+export const releaseRead = (self: TxReentrantLock): Effect.Effect<number> =>
+  Effect.withFiber((fiber) => releaseReadFor(self, fiber.id))
 
 /**
  * Releases one write lock held by the current fiber.
@@ -313,23 +313,23 @@ export const releaseRead = (self: TxReentrantLock): Effect.Effect<number> =>
  * @category mutations
  * @since 2.0.0
  */
-export const releaseWrite = (self: TxReentrantLock): Effect.Effect<number> =>
-  Effect.withFiber((fiber) =>
-    Effect.gen(function*() {
-      const state = yield* TxRef.get(self.stateRef)
-      const fiberId = fiber.id
+const releaseWriteFor = (self: TxReentrantLock, fiberId: number): Effect.Effect<number> =>
+  Effect.gen(function*() {
+    const state = yield* TxRef.get(self.stateRef)
 
-      if (Option.isNone(state.writer) || state.writer.value[0] !== fiberId) return 0
+    if (Option.isNone(state.writer) || state.writer.value[0] !== fiberId) return 0
 
-      const newCount = state.writer.value[1] - 1
-      const newWriter = newCount <= 0
-        ? Option.none<readonly [number, number]>()
-        : Option.some([fiberId, newCount] as const)
+    const newCount = state.writer.value[1] - 1
+    const newWriter = newCount <= 0
+      ? Option.none<readonly [number, number]>()
+      : Option.some([fiberId, newCount] as const)
 
-      yield* TxRef.set(self.stateRef, { ...state, writer: newWriter })
-      return newCount
-    }).pipe(Effect.tx)
-  )
+    yield* TxRef.set(self.stateRef, { ...state, writer: newWriter })
+    return newCount
+  }).pipe(Effect.tx)
+
+export const releaseWrite = (self: TxReentrantLock): Effect.Effect<number> =>
+  Effect.withFiber((fiber) => releaseWriteFor(self, fiber.id))
 
 /**
  * Acquires a read lock for the duration of the scope.
@@ -361,9 +361,11 @@ export const releaseWrite = (self: TxReentrantLock): Effect.Effect<number> =>
  * @since 2.0.0
  */
 export const readLock = (self: TxReentrantLock): Effect.Effect<number, never, Scope.Scope> =>
-  Effect.acquireRelease(
-    acquireRead(self),
-    () => releaseRead(self)
+  Effect.withFiber((fiber) =>
+    Effect.acquireRelease(
+      acquireRead(self),
+      () => releaseReadFor(self, fiber.id)
+    )
   )
 
 /**
@@ -396,9 +398,11 @@ export const readLock = (self: TxReentrantLock): Effect.Effect<number, never, Sc
  * @since 2.0.0
  */
 export const writeLock = (self: TxReentrantLock): Effect.Effect<number, never, Scope.Scope> =>
-  Effect.acquireRelease(
-    acquireWrite(self),
-    () => releaseWrite(self)
+  Effect.withFiber((fiber) =>
+    Effect.acquireRelease(
+      acquireWrite(self),
+      () => releaseWriteFor(self, fiber.id)
+    )
   )
 
 /**

package/src/internal/dateTime.ts

@@ -221,7 +221,7 @@ export const makeUnsafe = <A extends DateTime.DateTime.Input>(input: A): DateTim
     return fromDateUnsafe(input) as DateTime.DateTime.PreserveZone<A>
   } else if (typeof input === "object") {
     if ("epochMilliseconds" in input) {
-      return makeUtc(input.epochMilliseconds) as DateTime.DateTime.PreserveZone<A>
+      return fromDateUnsafe(new Date(input.epochMilliseconds)) as DateTime.DateTime.PreserveZone<A>
     }
     const date = new Date(0)
     setPartsDate(date, input)

package/src/internal/executionPlan.ts

@@ -1,47 +1,131 @@
+import * as Duration from "../Duration.ts"
 import type { Effect } from "../Effect.ts"
 import * as Api from "../ExecutionPlan.ts"
-import { dual } from "../Function.ts"
+import type * as Exit from "../Exit.ts"
+import { dual, identity } from "../Function.ts"
 import * as Result from "../Result.ts"
 import * as Schedule from "../Schedule.ts"
+import { isEffect } from "./core.ts"
 import * as effect from "./effect.ts"
 import * as internalLayer from "./layer.ts"
 import * as internalSchedule from "./schedule.ts"
 
+/** @internal */
+export interface AttemptState {
+  readonly attempt: number
+  readonly stepAttempt: number
+  readonly stepIndex: number
+  readonly startNanos: bigint
+}
+
+/** @internal */
+export interface EventEmitter {
+  readonly begin: Effect<AttemptState, never, any>
+  readonly end: (state: AttemptState, exit: Exit.Exit<any, any>) => Effect<void, never, any>
+}
+
+/** @internal */
+export const makeEventEmitter = (
+  onEvent: (event: Api.Event<any>) => Effect<void, never, any>,
+  currentMetadata: () => Api.Metadata
+): EventEmitter => {
+  let lastStepIndex = -1
+  let stepAttempt = 0
+  return {
+    begin: effect.clockWith((clock) =>
+      effect.suspend(() => {
+        const meta = currentMetadata()
+        if (meta.stepIndex !== lastStepIndex) {
+          lastStepIndex = meta.stepIndex
+          stepAttempt = 0
+        }
+        stepAttempt++
+        const state: AttemptState = {
+          attempt: meta.attempt,
+          stepAttempt,
+          stepIndex: meta.stepIndex,
+          startNanos: clock.monotonicTimeNanosUnsafe()
+        }
+        return effect.as(
+          onEvent({
+            _tag: "AttemptStart",
+            attempt: state.attempt,
+            stepAttempt: state.stepAttempt,
+            stepIndex: state.stepIndex
+          }),
+          state
+        )
+      })
+    ),
+    end: (state, exit) =>
+      effect.clockWith((clock) => {
+        const duration = Duration.nanos(clock.monotonicTimeNanosUnsafe() - state.startNanos)
+        return onEvent(
+          exit._tag === "Success"
+            ? {
+              _tag: "AttemptSuccess",
+              attempt: state.attempt,
+              stepAttempt: state.stepAttempt,
+              stepIndex: state.stepIndex,
+              duration
+            }
+            : {
+              _tag: "AttemptFailure",
+              attempt: state.attempt,
+              stepAttempt: state.stepAttempt,
+              stepIndex: state.stepIndex,
+              duration,
+              cause: exit.cause
+            }
+        )
+      })
+  }
+}
+
 /** @internal */
 export const withExecutionPlan: {
-  <Input, Provides, PlanE, PlanR>(
+  <Input, Provides, PlanE, PlanR, RX = never>(
     plan: Api.ExecutionPlan<{
       provides: Provides
       input: Input
       error: PlanE
       requirements: PlanR
-    }>
+    }>,
+    options?: {
+      readonly onEvent?: ((event: Api.Event<Input | PlanE>) => Effect<void, never, RX>) | undefined
+    }
   ): <A, E extends Input, R>(effect: Effect<A, E, R>) => Effect<
     A,
     E | PlanE,
-    Exclude<R, Provides> | PlanR
+    Exclude<R, Provides> | PlanR | RX
   >
-  <A, E extends Input, R, Provides, Input, PlanE, PlanR>(
+  <A, E extends Input, R, Provides, Input, PlanE, PlanR, RX = never>(
     effect: Effect<A, E, R>,
     plan: Api.ExecutionPlan<{
       provides: Provides
       input: Input
       error: PlanE
       requirements: PlanR
-    }>
+    }>,
+    options?: {
+      readonly onEvent?: ((event: Api.Event<E | PlanE>) => Effect<void, never, RX>) | undefined
+    }
   ): Effect<
     A,
     E | PlanE,
-    Exclude<R, Provides> | PlanR
+    Exclude<R, Provides> | PlanR | RX
   >
-} = dual(2, <A, E extends Input, R, Provides, Input, PlanE, PlanR>(
+} = dual((args) => isEffect(args[0]), <A, E extends Input, R, Provides, Input, PlanE, PlanR, RX>(
   self: Effect<A, E, R>,
   plan: Api.ExecutionPlan<{
     provides: Provides
     input: Input
     error: PlanE
     requirements: PlanR
-  }>
+  }>,
+  options?: {
+    readonly onEvent?: ((event: Api.Event<E | PlanE>) => Effect<void, never, RX>) | undefined
+  }
 ) =>
   effect.suspend(() => {
     let i = 0
@@ -59,13 +143,24 @@ export const withExecutionPlan: {
         return meta
       })
     )
+    const emitter = options?.onEvent === undefined
+      ? undefined
+      : makeEventEmitter(options.onEvent, () => meta)
+    const instrument: (attempt: Effect<A, any, any>) => Effect<A, any, any> = emitter === undefined
+      ? identity
+      : (attempt) =>
+        effect.uninterruptibleMask((restore) =>
+          effect.flatMap(emitter.begin, (state) => effect.onExit(restore(attempt), (exit) => emitter.end(state, exit)))
+        )
     let result: Result.Result<A, any> | undefined
     return effect.flatMap(
       effect.whileLoop({
         while: () => i < plan.steps.length && (result === undefined || Result.isFailure(result)),
         body() {
           const step = plan.steps[i]
-          let nextEffect: Effect<A, any, any> = provideMeta(internalLayer.provide(self, step.provide as any))
+          let nextEffect: Effect<A, any, any> = provideMeta(
+            instrument(internalLayer.provide(self, step.provide as any))
+          )
           if (result) {
             let attempted = false
             const wrapped = nextEffect

package/src/internal/hashMap.ts

@@ -977,13 +977,8 @@ export const hasBy = dual<
   return false
 })
 
-/** @internal */
-export const set = dual<
-  <K, V>(key: K, value: V) => (self: HashMap<K, V>) => HashMap<K, V>,
-  <K, V>(self: HashMap<K, V>, key: K, value: V) => HashMap<K, V>
->(3, <K, V>(self: HashMap<K, V>, key: K, value: V): HashMap<K, V> => {
+const setHash = <K, V>(self: HashMap<K, V>, key: K, hash: number, value: V): HashMap<K, V> => {
   const impl = self as HashMapImpl<K, V>
-  const hash = Hash.hash(key)
   const added = { value: false }
 
   // Pass edit context: use current edit if editable, otherwise NaN (never matches any edit)
@@ -1005,6 +1000,14 @@ export const set = dual<
   }
 
   return new HashMapImpl(false, impl._edit, newRoot, impl._size + (added.value ? 1 : 0))
+}
+
+/** @internal */
+export const set = dual<
+  <K, V>(key: K, value: V) => (self: HashMap<K, V>) => HashMap<K, V>,
+  <K, V>(self: HashMap<K, V>, key: K, value: V) => HashMap<K, V>
+>(3, <K, V>(self: HashMap<K, V>, key: K, value: V): HashMap<K, V> => {
+  return setHash(self, key, Hash.hash(key), value)
 })
 
 /** @internal */
@@ -1104,10 +1107,10 @@ export const modifyHash = dual<
   const updated = f(current)
 
   if (Option.isNone(updated)) {
-    return hasHash(self, key, hash) ? remove(self, key) : self
+    return hasHash(self, key, hash) ? removeHash(self, key, hash) : self
   }
 
-  return set(self, key, updated.value)
+  return setHash(self, key, hash, updated.value)
 })
 
 /** @internal */
@@ -1130,13 +1133,8 @@ export const union = dual<
   return result
 })
 
-/** @internal */
-export const remove = dual<
-  <K>(key: K) => <V>(self: HashMap<K, V>) => HashMap<K, V>,
-  <K, V>(self: HashMap<K, V>, key: K) => HashMap<K, V>
->(2, <K, V>(self: HashMap<K, V>, key: K): HashMap<K, V> => {
+const removeHash = <K, V>(self: HashMap<K, V>, key: K, hash: number): HashMap<K, V> => {
   const impl = self as HashMapImpl<K, V>
-  const hash = Hash.hash(key)
   const removed = { value: false }
 
   const edit = impl._editable ? impl._edit : NaN
@@ -1157,6 +1155,14 @@ export const remove = dual<
   }
 
   return new HashMapImpl(false, impl._edit, newRoot, impl._size - 1)
+}
+
+/** @internal */
+export const remove = dual<
+  <K>(key: K) => <V>(self: HashMap<K, V>) => HashMap<K, V>,
+  <K, V>(self: HashMap<K, V>, key: K) => HashMap<K, V>
+>(2, <K, V>(self: HashMap<K, V>, key: K): HashMap<K, V> => {
+  return removeHash(self, key, Hash.hash(key))
 })
 
 /** @internal */

package/src/internal/matcher.ts

@@ -124,8 +124,8 @@ const makePredicate = (pattern: unknown): Predicate.Predicate<unknown> => {
       return true
     }
   } else if (pattern !== null && typeof pattern === "object") {
-    const keysAndPredicates = Object.entries(pattern).map(
-      ([k, p]) => [k, makePredicate(p)] as const
+    const keysAndPredicates = Reflect.ownKeys(pattern).map(
+      (key) => [key, makePredicate((pattern as any)[key])] as const
     )
     const len = keysAndPredicates.length
 

package/src/internal/schedule.ts

@@ -184,17 +184,17 @@ export const scheduleFrom = dual<
     schedule: Schedule.Schedule<Output, Input, Error, Env>
   ) => <E, R>(
     self: Effect<Input, E, R>
-  ) => Effect<Output, E, R | Env>,
+  ) => Effect<Output, E | Error, R | Env>,
   <Input, E, R, Output, Error, Env>(
     self: Effect<Input, E, R>,
     initial: Input,
     schedule: Schedule.Schedule<Output, Input, Error, Env>
-  ) => Effect<Output, E, R | Env>
+  ) => Effect<Output, E | Error, R | Env>
 >(3, <Input, E, R, Output, Error, Env>(
   self: Effect<Input, E, R>,
   initial: Input,
   schedule: Schedule.Schedule<Output, Input, Error, Env>
-): Effect<Output, E, R | Env> =>
+): Effect<Output, E | Error, R | Env> =>
   effect.flatMap(Schedule.toStepWithMetadata(schedule), (step) => {
     let meta = Schedule.CurrentMetadata.defaultValue()
     const selfWithMeta = effect.suspend(() => effect.provideService(self, Schedule.CurrentMetadata, meta))
@@ -213,7 +213,7 @@ export const scheduleFrom = dual<
           }) as Effect<never, E, R | Env>
         }
       ),
-      (error) => core.isDone(error) ? effect.succeed(error.value as Output) : effect.fail(error as E)
+      (error) => core.isDone(error) ? effect.succeed(error.value as Output) : effect.fail(error as E | Error)
     )
   }))
 

package/src/internal/schema/annotations.ts

@@ -21,6 +21,9 @@ export const IDENTIFIER_FALLBACK_KEY = "~identifier"
 /** @internal */
 export const SENTINELS_ANNOTATION_KEY = "~sentinels"
 
+/** @internal */
+export const CONSTRUCTOR_ANNOTATION_KEY = "~constructor"
+
 /** @internal */
 export const jsonSchemaAnnotationKeys = [
   "title",