effect 3.12.7 → 3.12.8

package/src/ParseResult.ts

@@ -2,11 +2,12 @@
  * @since 3.10.0
  */
 
-import * as array_ from "./Array.js"
-import type * as cause_ from "./Cause.js"
+import * as Arr from "./Array.js"
+import * as Cause from "./Cause.js"
 import { TaggedError } from "./Data.js"
 import * as Effect from "./Effect.js"
 import * as Either from "./Either.js"
+import * as Exit from "./Exit.js"
 import type { LazyArg } from "./Function.js"
 import { dual } from "./Function.js"
 import { globalValue } from "./GlobalValue.js"
@@ -14,6 +15,7 @@ import * as Inspectable from "./Inspectable.js"
 import * as util_ from "./internal/schema/util.js"
 import * as Option from "./Option.js"
 import * as Predicate from "./Predicate.js"
+import * as Scheduler from "./Scheduler.js"
 import type * as Schema from "./Schema.js"
 import * as AST from "./SchemaAST.js"
 import type { Concurrency } from "./Types.js"
@@ -40,7 +42,7 @@ export type ParseIssue =
  * @category model
  * @since 3.10.0
  */
-export type SingleOrNonEmpty<A> = A | array_.NonEmptyReadonlyArray<A>
+export type SingleOrNonEmpty<A> = A | Arr.NonEmptyReadonlyArray<A>
 
 /**
  * @category model
@@ -959,7 +961,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
       const concurrency = getConcurrency(ast)
       const batching = getBatching(ast)
       return (input: unknown, options) => {
-        if (!array_.isArray(input)) {
+        if (!Arr.isArray(input)) {
           return Either.left(new Type(ast, input))
         }
         const allErrors = options?.errors === "all"
@@ -1057,7 +1059,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
         // ---------------------------------------------
         // handle rest element
         // ---------------------------------------------
-        if (array_.isNonEmptyReadonlyArray(rest)) {
+        if (Arr.isNonEmptyReadonlyArray(rest)) {
           const [head, ...tail] = rest
           for (; i < len - tail.length; i++) {
             const te = head(input[i], options)
@@ -1153,15 +1155,15 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
         // compute result
         // ---------------------------------------------
         const computeResult = ({ es, output }: State) =>
-          array_.isNonEmptyArray(es) ?
+          Arr.isNonEmptyArray(es) ?
             Either.left(new Composite(ast, input, sortByIndex(es), sortByIndex(output))) :
             Either.right(sortByIndex(output))
         if (queue && queue.length > 0) {
           const cqueue = queue
           return Effect.suspend(() => {
             const state: State = {
-              es: array_.copy(es),
-              output: array_.copy(output)
+              es: Arr.copy(es),
+              output: Arr.copy(output)
             }
             return Effect.flatMap(
               Effect.forEach(cqueue, (f) => f(state), { concurrency, batching, discard: true }),
@@ -1379,7 +1381,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
         // compute result
         // ---------------------------------------------
         const computeResult = ({ es, output }: State) => {
-          if (array_.isNonEmptyArray(es)) {
+          if (Arr.isNonEmptyArray(es)) {
             return Either.left(new Composite(ast, input, sortByIndex(es), output))
           }
           if (options?.propertyOrder === "original") {
@@ -1404,7 +1406,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
           const cqueue = queue
           return Effect.suspend(() => {
             const state: State = {
-              es: array_.copy(es),
+              es: Arr.copy(es),
               output: Object.assign({}, output)
             }
             return Effect.flatMap(
@@ -1528,7 +1530,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
         // compute result
         // ---------------------------------------------
         const computeResult = (es: State["es"]) =>
-          array_.isNonEmptyArray(es) ?
+          Arr.isNonEmptyArray(es) ?
             es.length === 1 && es[0][1]._tag === "Type" ?
               Either.left(es[0][1]) :
               Either.left(new Composite(ast, input, sortByIndex(es))) :
@@ -1538,7 +1540,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
         if (queue && queue.length > 0) {
           const cqueue = queue
           return Effect.suspend(() => {
-            const state: State = { es: array_.copy(es) }
+            const state: State = { es: Arr.copy(es) }
             return Effect.flatMap(
               Effect.forEach(cqueue, (f) => f(state), { concurrency, batching, discard: true }),
               () => {
@@ -1687,31 +1689,53 @@ const handleForbidden = <A, R>(
   actual: unknown,
   options: InternalOptions | undefined
 ): Effect.Effect<A, ParseIssue, R> => {
+  // If effects are allowed, return the original effect
+  if (options?.isEffectAllowed === true) {
+    return effect
+  }
+
+  // Convert the effect to an Either, if possible
   const eu = eitherOrUndefined(effect)
+  // If the effect is already an Either, return it directly
   if (eu) {
     return eu
   }
-  if (options?.isEffectAllowed === true) {
-    return effect
+
+  // Otherwise, attempt to execute the effect synchronously
+  const scheduler = new Scheduler.SyncScheduler()
+  const fiber = Effect.runFork(effect as Effect.Effect<A, ParseIssue>, { scheduler })
+  scheduler.flush()
+  const exit = fiber.unsafePoll()
+
+  if (exit) {
+    if (Exit.isSuccess(exit)) {
+      // If the effect successfully resolves, wrap the value in a Right
+      return Either.right(exit.value)
+    }
+    const cause = exit.cause
+    if (Cause.isFailType(cause)) {
+      // The effect executed synchronously but failed due to a ParseIssue
+      return Either.left(cause.error)
+    }
+    // The effect executed synchronously but failed due to a defect (e.g., a missing dependency)
+    return Either.left(new Forbidden(ast, actual, Cause.pretty(cause)))
   }
-  try {
-    return Effect.runSync(Effect.either(effect as Effect.Effect<A, ParseIssue>))
-  } catch (e) {
-    return Either.left(
-      new Forbidden(
-        ast,
-        actual,
-        "cannot be be resolved synchronously, this is caused by using runSync on an effect that performs async work"
-      )
+
+  // The effect could not be resolved synchronously, meaning it performs async work
+  return Either.left(
+    new Forbidden(
+      ast,
+      actual,
+      "cannot be be resolved synchronously, this is caused by using runSync on an effect that performs async work"
     )
-  }
+  )
 }
 
 const compare = ([a]: [number, ...Array<unknown>], [b]: [number, ...Array<unknown>]) => a > b ? 1 : a < b ? -1 : 0
 
 function sortByIndex<T>(
-  es: array_.NonEmptyArray<[number, T]>
-): array_.NonEmptyArray<T>
+  es: Arr.NonEmptyArray<[number, T]>
+): Arr.NonEmptyArray<T>
 function sortByIndex<T>(es: Array<[number, T]>): Array<T>
 function sortByIndex(es: Array<[number, any]>) {
   return es.sort(compare).map((t) => t[1])
@@ -1850,7 +1874,7 @@ interface CurrentMessage {
 
 const getCurrentMessage = (
   issue: ParseIssue
-): Effect.Effect<CurrentMessage, cause_.NoSuchElementException> =>
+): Effect.Effect<CurrentMessage, Cause.NoSuchElementException> =>
   getAnnotated(issue).pipe(
     Option.flatMap(AST.getMessageAnnotation),
     Effect.flatMap((annotation) => {
@@ -1882,7 +1906,7 @@ const isTransformation = createParseIssueGuard("Transformation")
 
 const getMessage: (
   issue: ParseIssue
-) => Effect.Effect<string, cause_.NoSuchElementException> = (issue: ParseIssue) =>
+) => Effect.Effect<string, Cause.NoSuchElementException> = (issue: ParseIssue) =>
   getCurrentMessage(issue).pipe(
     Effect.flatMap((currentMessage) => {
       const useInnerMessage = !currentMessage.override && (
@@ -2058,7 +2082,7 @@ const formatArray = (
     case "Composite":
       return getArray(e, path, () =>
         util_.isNonEmpty(e.issues)
-          ? Effect.map(Effect.forEach(e.issues, (issue) => formatArray(issue, path)), array_.flatten)
+          ? Effect.map(Effect.forEach(e.issues, (issue) => formatArray(issue, path)), Arr.flatten)
           : formatArray(e.issues, path))
     case "Refinement":
     case "Transformation":

package/src/Schedule.ts

@@ -140,6 +140,14 @@ export const makeWithState: <S, In, Out, R = never>(
   ) => Effect.Effect<readonly [S, Out, ScheduleDecision.ScheduleDecision], never, R>
 ) => Schedule<Out, In, R> = internal.makeWithState
 
+/**
+ * Returns `true` if the specified value is a `Schedule`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category guards
+ */
+export const isSchedule: (u: unknown) => u is Schedule<unknown, never, unknown> = internal.isSchedule
+
 /**
  * Returns a new schedule with the given delay added to every interval defined
  * by this schedule.

package/src/Schema.ts

@@ -2,6 +2,7 @@
  * @since 3.10.0
  */
 
+import * as internalCause_ from "effect/internal/cause"
 import type { ArbitraryAnnotation, ArbitraryGenerationContext, LazyArbitrary } from "./Arbitrary.js"
 import * as array_ from "./Array.js"
 import * as bigDecimal_ from "./BigDecimal.js"
@@ -6202,6 +6203,37 @@ export class DurationFromMillis extends transform(
   }
 ).annotations({ identifier: "DurationFromMillis" }) {}
 
+const DurationValueMillis = TaggedStruct("Millis", { millis: NonNegativeInt })
+const DurationValueNanos = TaggedStruct("Nanos", { nanos: BigInt$ })
+const DurationValueInfinity = TaggedStruct("Infinity", {})
+const durationValueInfinity = DurationValueInfinity.make({})
+
+/**
+ * @category Duration utils
+ * @since 3.12.8
+ */
+export type DurationEncoded =
+  | {
+    readonly _tag: "Millis"
+    readonly millis: number
+  }
+  | {
+    readonly _tag: "Nanos"
+    readonly nanos: string
+  }
+  | {
+    readonly _tag: "Infinity"
+  }
+
+const DurationValue: Schema<duration_.DurationValue, DurationEncoded> = Union(
+  DurationValueMillis,
+  DurationValueNanos,
+  DurationValueInfinity
+).annotations({
+  identifier: "DurationValue",
+  description: "an JSON-compatible tagged union to be decoded into a Duration"
+})
+
 const FiniteHRTime = Tuple(
   element(NonNegativeInt).annotations({ title: "seconds" }),
   element(NonNegativeInt).annotations({ title: "nanos" })
@@ -6214,22 +6246,45 @@ const HRTime: Schema<readonly [seconds: number, nanos: number]> = Union(FiniteHR
   description: "a tuple of seconds and nanos to be decoded into a Duration"
 })
 
+const isDurationValue = (u: duration_.DurationValue | typeof HRTime.Type): u is duration_.DurationValue =>
+  typeof u === "object"
+
+// TODO(4.0): remove HRTime union member
 /**
- * A schema that transforms a `[number, number]` tuple into a `Duration`.
- *
- * Infinite durations are encoded as `[-1, 0]`.
+ * A schema that converts a JSON-compatible tagged union into a `Duration`.
  *
  * @category Duration transformations
  * @since 3.10.0
  */
 export class Duration extends transform(
-  HRTime,
+  Union(DurationValue, HRTime),
   DurationFromSelf,
   {
     strict: true,
-    decode: ([seconds, nanos]) =>
-      seconds === -1 ? duration_.infinity : duration_.nanos(BigInt(seconds) * BigInt(1e9) + BigInt(nanos)),
-    encode: (duration) => duration.value._tag === "Infinity" ? [-1, 0] as const : duration_.toHrTime(duration)
+    decode: (input) => {
+      if (isDurationValue(input)) {
+        switch (input._tag) {
+          case "Millis":
+            return duration_.millis(input.millis)
+          case "Nanos":
+            return duration_.nanos(input.nanos)
+          case "Infinity":
+            return duration_.infinity
+        }
+      }
+      const [seconds, nanos] = input
+      return seconds === -1 ? duration_.infinity : duration_.nanos(BigInt(seconds) * BigInt(1e9) + BigInt(nanos))
+    },
+    encode: (duration) => {
+      switch (duration.value._tag) {
+        case "Millis":
+          return DurationValueMillis.make({ millis: duration.value.millis })
+        case "Nanos":
+          return DurationValueNanos.make({ nanos: duration.value.nanos })
+        case "Infinity":
+          return durationValueInfinity
+      }
+    }
   }
 ).annotations({ identifier: "Duration" }) {}
 
@@ -6678,9 +6733,9 @@ export const itemsCount = <A extends ReadonlyArray<any>>(
 ) =>
 <I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> => {
   const itemsCount = Math.floor(n)
-  if (itemsCount < 1) {
+  if (itemsCount < 0) {
     throw new Error(
-      errors_.getInvalidArgumentErrorMessage(`Expected an integer greater than or equal to 1, actual ${n}`)
+      errors_.getInvalidArgumentErrorMessage(`Expected an integer greater than or equal to 0, actual ${n}`)
     )
   }
   return self.pipe(
@@ -9012,8 +9067,9 @@ type MakeOptions = boolean | {
   readonly disableValidation?: boolean
 }
 
-const getDisableValidationMakeOption = (options: MakeOptions | undefined): boolean =>
-  Predicate.isBoolean(options) ? options : options?.disableValidation ?? false
+function getDisableValidationMakeOption(options: MakeOptions | undefined): boolean {
+  return Predicate.isBoolean(options) ? options : options?.disableValidation ?? false
+}
 
 const astCache = globalValue("effect/Schema/astCache", () => new WeakMap<any, AST.AST>())
 
@@ -9643,7 +9699,7 @@ export const Defect: Defect = transform(
           // no stack because of security reasons
         }
       }
-      return String(defect)
+      return internalCause_.prettyErrorMessage(defect)
     }
   }
 ).annotations({ identifier: "Defect" })

package/src/internal/cause.ts

@@ -259,34 +259,12 @@ export const dieOption = <E>(self: Cause.Cause<E>): Option.Option<unknown> =>
 /** @internal */
 export const flipCauseOption = <E>(self: Cause.Cause<Option.Option<E>>): Option.Option<Cause.Cause<E>> =>
   match(self, {
-    onEmpty: Option.some(empty),
-    onFail: (failureOption) => pipe(failureOption, Option.map(fail)),
+    onEmpty: Option.some<Cause.Cause<E>>(empty),
+    onFail: Option.map(fail),
     onDie: (defect) => Option.some(die(defect)),
     onInterrupt: (fiberId) => Option.some(interrupt(fiberId)),
-    onSequential: (left, right) => {
-      if (Option.isSome(left) && Option.isSome(right)) {
-        return Option.some(sequential(left.value, right.value))
-      }
-      if (Option.isNone(left) && Option.isSome(right)) {
-        return Option.some(right.value)
-      }
-      if (Option.isSome(left) && Option.isNone(right)) {
-        return Option.some(left.value)
-      }
-      return Option.none()
-    },
-    onParallel: (left, right) => {
-      if (Option.isSome(left) && Option.isSome(right)) {
-        return Option.some(parallel(left.value, right.value))
-      }
-      if (Option.isNone(left) && Option.isSome(right)) {
-        return Option.some(right.value)
-      }
-      if (Option.isSome(left) && Option.isNone(right)) {
-        return Option.some(left.value)
-      }
-      return Option.none()
-    }
+    onSequential: Option.mergeWith(sequential),
+    onParallel: Option.mergeWith(parallel)
   })
 
 /** @internal */
@@ -298,68 +276,24 @@ export const interruptOption = <E>(self: Cause.Cause<E>): Option.Option<FiberId.
 
 /** @internal */
 export const keepDefects = <E>(self: Cause.Cause<E>): Option.Option<Cause.Cause<never>> =>
-  match<Option.Option<Cause.Cause<never>>, E>(self, {
+  match(self, {
     onEmpty: Option.none(),
     onFail: () => Option.none(),
     onDie: (defect) => Option.some(die(defect)),
     onInterrupt: () => Option.none(),
-    onSequential: (left, right) => {
-      if (Option.isSome(left) && Option.isSome(right)) {
-        return Option.some(sequential(left.value, right.value))
-      }
-      if (Option.isSome(left) && Option.isNone(right)) {
-        return Option.some(left.value)
-      }
-      if (Option.isNone(left) && Option.isSome(right)) {
-        return Option.some(right.value)
-      }
-      return Option.none()
-    },
-    onParallel: (left, right) => {
-      if (Option.isSome(left) && Option.isSome(right)) {
-        return Option.some(parallel(left.value, right.value))
-      }
-      if (Option.isSome(left) && Option.isNone(right)) {
-        return Option.some(left.value)
-      }
-      if (Option.isNone(left) && Option.isSome(right)) {
-        return Option.some(right.value)
-      }
-      return Option.none()
-    }
+    onSequential: Option.mergeWith(sequential),
+    onParallel: Option.mergeWith(parallel)
   })
 
 /** @internal */
 export const keepDefectsAndElectFailures = <E>(self: Cause.Cause<E>): Option.Option<Cause.Cause<never>> =>
-  match<Option.Option<Cause.Cause<never>>, E>(self, {
+  match(self, {
     onEmpty: Option.none(),
     onFail: (failure) => Option.some(die(failure)),
     onDie: (defect) => Option.some(die(defect)),
     onInterrupt: () => Option.none(),
-    onSequential: (left, right) => {
-      if (Option.isSome(left) && Option.isSome(right)) {
-        return Option.some(sequential(left.value, right.value))
-      }
-      if (Option.isSome(left) && Option.isNone(right)) {
-        return Option.some(left.value)
-      }
-      if (Option.isNone(left) && Option.isSome(right)) {
-        return Option.some(right.value)
-      }
-      return Option.none()
-    },
-    onParallel: (left, right) => {
-      if (Option.isSome(left) && Option.isSome(right)) {
-        return Option.some(parallel(left.value, right.value))
-      }
-      if (Option.isSome(left) && Option.isNone(right)) {
-        return Option.some(left.value)
-      }
-      if (Option.isNone(left) && Option.isSome(right)) {
-        return Option.some(right.value)
-      }
-      return Option.none()
-    }
+    onSequential: Option.mergeWith(sequential),
+    onParallel: Option.mergeWith(parallel)
   })
 
 /** @internal */
@@ -370,25 +304,9 @@ export const linearize = <E>(self: Cause.Cause<E>): HashSet.HashSet<Cause.Cause<
     onDie: (defect) => HashSet.make(die(defect)),
     onInterrupt: (fiberId) => HashSet.make(interrupt(fiberId)),
     onSequential: (leftSet, rightSet) =>
-      pipe(
-        leftSet,
-        HashSet.flatMap((leftCause) =>
-          pipe(
-            rightSet,
-            HashSet.map((rightCause) => sequential(leftCause, rightCause))
-          )
-        )
-      ),
+      HashSet.flatMap(leftSet, (leftCause) => HashSet.map(rightSet, (rightCause) => sequential(leftCause, rightCause))),
     onParallel: (leftSet, rightSet) =>
-      pipe(
-        leftSet,
-        HashSet.flatMap((leftCause) =>
-          pipe(
-            rightSet,
-            HashSet.map((rightCause) => parallel(leftCause, rightCause))
-          )
-        )
-      )
+      HashSet.flatMap(leftSet, (leftCause) => HashSet.map(rightSet, (rightCause) => parallel(leftCause, rightCause)))
   })
 
 /** @internal */
@@ -396,8 +314,8 @@ export const stripFailures = <E>(self: Cause.Cause<E>): Cause.Cause<never> =>
   match(self, {
     onEmpty: empty,
     onFail: () => empty,
-    onDie: (defect) => die(defect),
-    onInterrupt: (fiberId) => interrupt(fiberId),
+    onDie: die,
+    onInterrupt: interrupt,
     onSequential: sequential,
     onParallel: parallel
   })
@@ -406,51 +324,32 @@ export const stripFailures = <E>(self: Cause.Cause<E>): Cause.Cause<never> =>
 export const electFailures = <E>(self: Cause.Cause<E>): Cause.Cause<never> =>
   match(self, {
     onEmpty: empty,
-    onFail: (failure) => die(failure),
-    onDie: (defect) => die(defect),
-    onInterrupt: (fiberId) => interrupt(fiberId),
-    onSequential: (left, right) => sequential(left, right),
-    onParallel: (left, right) => parallel(left, right)
+    onFail: die,
+    onDie: die,
+    onInterrupt: interrupt,
+    onSequential: sequential,
+    onParallel: parallel
   })
 
 /** @internal */
 export const stripSomeDefects = dual<
   (pf: (defect: unknown) => Option.Option<unknown>) => <E>(self: Cause.Cause<E>) => Option.Option<Cause.Cause<E>>,
   <E>(self: Cause.Cause<E>, pf: (defect: unknown) => Option.Option<unknown>) => Option.Option<Cause.Cause<E>>
->(2, <E>(self: Cause.Cause<E>, pf: (defect: unknown) => Option.Option<unknown>) =>
-  match(self, {
-    onEmpty: Option.some(empty),
-    onFail: (error) => Option.some(fail(error)),
-    onDie: (defect) => {
-      const option = pf(defect)
-      return Option.isSome(option) ? Option.none() : Option.some(die(defect))
-    },
-    onInterrupt: (fiberId) => Option.some(interrupt(fiberId)),
-    onSequential: (left, right) => {
-      if (Option.isSome(left) && Option.isSome(right)) {
-        return Option.some(sequential(left.value, right.value))
-      }
-      if (Option.isSome(left) && Option.isNone(right)) {
-        return Option.some(left.value)
-      }
-      if (Option.isNone(left) && Option.isSome(right)) {
-        return Option.some(right.value)
-      }
-      return Option.none()
-    },
-    onParallel: (left, right) => {
-      if (Option.isSome(left) && Option.isSome(right)) {
-        return Option.some(parallel(left.value, right.value))
-      }
-      if (Option.isSome(left) && Option.isNone(right)) {
-        return Option.some(left.value)
-      }
-      if (Option.isNone(left) && Option.isSome(right)) {
-        return Option.some(right.value)
-      }
-      return Option.none()
-    }
-  }))
+>(
+  2,
+  <E>(self: Cause.Cause<E>, pf: (defect: unknown) => Option.Option<unknown>): Option.Option<Cause.Cause<E>> =>
+    match(self, {
+      onEmpty: Option.some<Cause.Cause<E>>(empty),
+      onFail: (error) => Option.some(fail(error)),
+      onDie: (defect) => {
+        const option = pf(defect)
+        return Option.isSome(option) ? Option.none() : Option.some(die(defect))
+      },
+      onInterrupt: (fiberId) => Option.some(interrupt(fiberId)),
+      onSequential: Option.mergeWith(sequential),
+      onParallel: Option.mergeWith(parallel)
+    })
+)
 
 // -----------------------------------------------------------------------------
 // Mapping
@@ -996,7 +895,8 @@ const renderErrorCause = (cause: PrettyError, prefix: string) => {
   return stack
 }
 
-class PrettyError extends globalThis.Error implements Cause.PrettyError {
+/** @internal */
+export class PrettyError extends globalThis.Error implements Cause.PrettyError {
   span: undefined | Span = undefined
   constructor(originalError: unknown) {
     const originalErrorIsObject = typeof originalError === "object" && originalError !== null
@@ -1128,7 +1028,8 @@ const prettyErrorStack = (message: string, stack: string, span?: Span | undefine
   return out.join("\n")
 }
 
-const spanSymbol = Symbol.for("effect/SpanAnnotation")
+/** @internal */
+export const spanSymbol = Symbol.for("effect/SpanAnnotation")
 
 /** @internal */
 export const prettyErrors = <E>(cause: Cause.Cause<E>): Array<PrettyError> =>

package/src/internal/core.ts

@@ -653,7 +653,6 @@ export const checkInterruptible = <A, E, R>(
   f: (isInterruptible: boolean) => Effect.Effect<A, E, R>
 ): Effect.Effect<A, E, R> => withFiberRuntime((_, status) => f(runtimeFlags_.interruption(status.runtimeFlags)))
 
-const spanSymbol = Symbol.for("effect/SpanAnnotation")
 const originalSymbol = Symbol.for("effect/OriginalAnnotation")
 
 /* @internal */
@@ -670,10 +669,10 @@ export const capture = <E>(obj: E & object, span: Option.Option<Tracer.Span>): E
   if (Option.isSome(span)) {
     return new Proxy(obj, {
       has(target, p) {
-        return p === spanSymbol || p === originalSymbol || p in target
+        return p === internalCause.spanSymbol || p === originalSymbol || p in target
       },
       get(target, p) {
-        if (p === spanSymbol) {
+        if (p === internalCause.spanSymbol) {
           return span.value
         }
         if (p === originalSymbol) {
@@ -689,7 +688,7 @@ export const capture = <E>(obj: E & object, span: Option.Option<Tracer.Span>): E
 
 /* @internal */
 export const die = (defect: unknown): Effect.Effect<never> =>
-  isObject(defect) && !(spanSymbol in defect) ?
+  isObject(defect) && !(internalCause.spanSymbol in defect) ?
     withFiberRuntime((fiber) => failCause(internalCause.die(capture(defect, currentSpanFromFiber(fiber)))))
     : failCause(internalCause.die(defect))
 
@@ -716,7 +715,7 @@ export const exit = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<Exit.
 
 /* @internal */
 export const fail = <E>(error: E): Effect.Effect<never, E> =>
-  isObject(error) && !(spanSymbol in error) ?
+  isObject(error) && !(internalCause.spanSymbol in error) ?
     withFiberRuntime((fiber) => failCause(internalCause.fail(capture(error, currentSpanFromFiber(fiber)))))
     : failCause(internalCause.fail(error))
 

package/src/internal/layer.ts

@@ -874,7 +874,7 @@ export const scopedContext = <A, E, R>(
 }
 
 /** @internal */
-export const scope: Layer.Layer<Scope.Scope.Closeable> = scopedContext(
+export const scope: Layer.Layer<Scope.Scope> = scopedContext(
   core.map(
     fiberRuntime.acquireRelease(
       fiberRuntime.scopeMake(),

package/src/internal/schedule.ts

@@ -34,7 +34,8 @@ export const ScheduleTypeId: Schedule.ScheduleTypeId = Symbol.for(
 ) as Schedule.ScheduleTypeId
 
 /** @internal */
-export const isSchedule = (u: unknown): u is Schedule.Schedule<any, any, any> => hasProperty(u, ScheduleTypeId)
+export const isSchedule = (u: unknown): u is Schedule.Schedule<unknown, never, unknown> =>
+  hasProperty(u, ScheduleTypeId)
 
 /** @internal */
 const ScheduleDriverSymbolKey = "effect/ScheduleDriver"
@@ -1989,16 +1990,16 @@ const retryOrElse_EffectLoop = <A, E, R, R1, A1, A2, E2, R2>(
 
 /** @internal */
 export const schedule_Effect = dual<
-  <R2, Out>(
-    schedule: Schedule.Schedule<Out, unknown, R2>
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Out, E, R | R2>,
+  <A, R2, Out>(
+    schedule: Schedule.Schedule<Out, NoInfer<A> | undefined, R2>
+  ) => <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Out, E, R | R2>,
   <A, E, R, R2, Out>(
     self: Effect.Effect<A, E, R>,
-    schedule: Schedule.Schedule<Out, unknown, R2>
+    schedule: Schedule.Schedule<Out, A | undefined, R2>
   ) => Effect.Effect<Out, E, R | R2>
 >(2, <A, E, R, R2, Out>(
   self: Effect.Effect<A, E, R>,
-  schedule: Schedule.Schedule<Out, unknown, R2>
+  schedule: Schedule.Schedule<Out, A | undefined, R2>
 ) => scheduleFrom_Effect(self, void 0, schedule))
 
 /** @internal */