effect 2.0.0-next.52 → 2.0.0-next.54

package/src/internal/Context.ts

@@ -6,6 +6,7 @@ import * as Hash from "../Hash"
 import { NodeInspectSymbol, toJSON, toString } from "../Inspectable"
 import type * as O from "../Option"
 import { pipeArguments } from "../Pipeable"
+import { hasProperty } from "../Predicate"
 import type * as STM from "../STM"
 import { EffectPrototype, effectVariance } from "./Effectable"
 import * as option from "./Option"
@@ -147,10 +148,10 @@ const serviceNotFoundError = (tag: C.Tag<any, any>) => {
 }
 
 /** @internal */
-export const isContext = (u: unknown): u is C.Context<never> => typeof u === "object" && u !== null && TypeId in u
+export const isContext = (u: unknown): u is C.Context<never> => hasProperty(u, TypeId)
 
 /** @internal */
-export const isTag = (u: unknown): u is C.Tag<any, any> => typeof u === "object" && u !== null && TagTypeId in u
+export const isTag = (u: unknown): u is C.Tag<any, any> => hasProperty(u, TagTypeId)
 
 const _empty = makeContext(new Map())
 

package/src/internal/Effectable.ts

@@ -8,6 +8,7 @@ import type * as Sink from "../Sink"
 import type * as Stream from "../Stream"
 import * as Data from "./Data"
 import * as OpCodes from "./opCodes/effect"
+import { moduleVersion } from "./version"
 
 /** @internal */
 export const EffectTypeId: Effect.EffectTypeId = Symbol.for("effect/Effect") as Effect.EffectTypeId
@@ -25,7 +26,8 @@ export const ChannelTypeId: Channel.ChannelTypeId = Symbol.for("effect/Channel")
 export const effectVariance = {
   _R: (_: never) => _,
   _E: (_: never) => _,
-  _A: (_: never) => _
+  _A: (_: never) => _,
+  _V: moduleVersion
 }
 
 /** @internal */

package/src/internal/Either.ts

@@ -9,6 +9,7 @@ import * as Hash from "../Hash"
 import { NodeInspectSymbol, toJSON, toString } from "../Inspectable"
 import * as option from "../internal/Option"
 import type { Option } from "../Option"
+import { hasProperty } from "../Predicate"
 import { EffectPrototype } from "./Effectable"
 
 /**
@@ -66,8 +67,7 @@ const LeftProto = Object.assign(Object.create(CommonProto), {
 })
 
 /** @internal */
-export const isEither = (input: unknown): input is Either.Either<unknown, unknown> =>
-  typeof input === "object" && input != null && TypeId in input
+export const isEither = (input: unknown): input is Either.Either<unknown, unknown> => hasProperty(input, TypeId)
 
 /** @internal */
 export const isLeft = <E, A>(ma: Either.Either<E, A>): ma is Either.Left<E, A> => ma._tag === "Left"

package/src/internal/Encoding/Common.ts

@@ -1,4 +1,5 @@
 import type * as Encoding from "../../Encoding"
+import { hasProperty } from "../../Predicate"
 
 /** @internal */
 export const DecodeExceptionTypeId: Encoding.DecodeExceptionTypeId = Symbol.for(
@@ -14,8 +15,7 @@ export const DecodeException = (input: string, message?: string): Encoding.Decod
 })
 
 /** @internal */
-export const isDecodeException = (u: unknown): u is Encoding.DecodeException =>
-  typeof u === "object" && u != null && DecodeExceptionTypeId in u
+export const isDecodeException = (u: unknown): u is Encoding.DecodeException => hasProperty(u, DecodeExceptionTypeId)
 
 /** @interal */
 export const encoder = new TextEncoder()

package/src/internal/HashMap/node.ts

@@ -5,6 +5,7 @@ import { fromBitmap, hashFragment, toBitmap } from "../../internal/HashMap/bitwi
 import { MAX_INDEX_NODE, MIN_ARRAY_NODE, SIZE } from "../../internal/HashMap/config"
 import { Stack } from "../../internal/Stack"
 import * as O from "../../Option"
+import { isTagged } from "../../Predicate"
 
 /** @internal */
 export type Node<K, V> =
@@ -40,7 +41,7 @@ export class EmptyNode<K, V> {
 
 /** @internal */
 export function isEmptyNode(a: unknown): a is EmptyNode<unknown, unknown> {
-  return typeof a === "object" && a !== null && "_tag" in a && a._tag === "EmptyNode"
+  return isTagged(a, "EmptyNode")
 }
 
 /** @internal */

package/src/internal/HashMap.ts

@@ -9,7 +9,7 @@ import { SIZE } from "../internal/HashMap/config"
 import * as Node from "../internal/HashMap/node"
 import * as Option from "../Option"
 import { pipeArguments } from "../Pipeable"
-import { isObject } from "../Predicate"
+import { hasProperty } from "../Predicate"
 
 /** @internal */
 export const HashMapTypeId: HM.TypeId = Symbol.for("effect/HashMap") as HM.TypeId
@@ -199,7 +199,7 @@ export const fromIterable = <K, V>(entries: Iterable<readonly [K, V]>): HM.HashM
 export const isHashMap: {
   <K, V>(u: Iterable<readonly [K, V]>): u is HM.HashMap<K, V>
   (u: unknown): u is HM.HashMap<unknown, unknown>
-} = (u: unknown): u is HM.HashMap<unknown, unknown> => isObject(u) && HashMapTypeId in u
+} = (u: unknown): u is HM.HashMap<unknown, unknown> => hasProperty(u, HashMapTypeId)
 
 /** @internal */
 export const isEmpty = <K, V>(self: HM.HashMap<K, V>): boolean =>

package/src/internal/HashSet.ts

@@ -7,7 +7,7 @@ import { NodeInspectSymbol, toJSON, toString } from "../Inspectable"
 import * as HM from "../internal/HashMap"
 import { pipeArguments } from "../Pipeable"
 import type { Predicate, Refinement } from "../Predicate"
-import { isObject } from "../Predicate"
+import { hasProperty } from "../Predicate"
 
 /** @internal */
 export const HashSetTypeId: HS.TypeId = Symbol.for("effect/HashSet") as HS.TypeId
@@ -62,7 +62,7 @@ export const makeImpl = <A>(keyMap: HashMap<A, unknown>): HashSetImpl<A> => {
 export const isHashSet: {
   <A>(u: Iterable<A>): u is HS.HashSet<A>
   (u: unknown): u is HS.HashSet<unknown>
-} = (u: unknown): u is HS.HashSet<unknown> => isObject(u) && HashSetTypeId in u
+} = (u: unknown): u is HS.HashSet<unknown> => hasProperty(u, HashSetTypeId)
 
 const _empty = makeImpl<never>(HM.empty())
 

package/src/internal/Option.ts

@@ -6,6 +6,7 @@ import * as Equal from "../Equal"
 import * as Hash from "../Hash"
 import { NodeInspectSymbol, toJSON, toString } from "../Inspectable"
 import type * as Option from "../Option"
+import { hasProperty } from "../Predicate"
 import { EffectPrototype } from "./Effectable"
 
 const TypeId: Option.TypeId = Symbol.for("effect/Option") as Option.TypeId
@@ -59,8 +60,7 @@ const NoneProto = Object.assign(Object.create(CommonProto), {
 })
 
 /** @internal */
-export const isOption = (input: unknown): input is Option.Option<unknown> =>
-  typeof input === "object" && input != null && TypeId in input
+export const isOption = (input: unknown): input is Option.Option<unknown> => hasProperty(input, TypeId)
 
 /** @internal */
 export const isNone = <A>(fa: Option.Option<A>): fa is Option.None<A> => fa._tag === "None"

package/src/internal/RedBlackTree.ts

@@ -10,7 +10,7 @@ import * as Option from "../Option"
 import type * as Order from "../Order"
 import type * as Ordering from "../Ordering"
 import { pipeArguments } from "../Pipeable"
-import { isObject } from "../Predicate"
+import { hasProperty } from "../Predicate"
 import type * as RBT from "../RedBlackTree"
 
 const RedBlackTreeSymbolKey = "effect/RedBlackTree"
@@ -75,7 +75,7 @@ const makeImpl = <K, V>(ord: Order.Order<K>, root: Node.Node<K, V> | undefined):
 export const isRedBlackTree: {
   <K, V>(u: Iterable<readonly [K, V]>): u is RBT.RedBlackTree<K, V>
   (u: unknown): u is RBT.RedBlackTree<unknown, unknown>
-} = (u: unknown): u is RBT.RedBlackTree<unknown, unknown> => isObject(u) && RedBlackTreeTypeId in u
+} = (u: unknown): u is RBT.RedBlackTree<unknown, unknown> => hasProperty(u, RedBlackTreeTypeId)
 
 /** @internal */
 export const empty = <K, V = never>(ord: Order.Order<K>): RBT.RedBlackTree<K, V> => makeImpl<K, V>(ord, undefined)

package/src/internal/blockedRequests.ts

@@ -5,6 +5,7 @@ import type { FiberId } from "../FiberId"
 import * as HashMap from "../HashMap"
 import * as List from "../List"
 import * as Option from "../Option"
+import { hasProperty } from "../Predicate"
 import type * as Request from "../Request"
 import type * as RequestBlock from "../RequestBlock"
 import type * as RequestResolver from "../RequestResolver"
@@ -329,9 +330,7 @@ const blockedRequestVariance = {
 }
 
 /** @internal */
-export const isEntry = (u: unknown): u is Request.Entry<unknown> => {
-  return typeof u === "object" && u != null && EntryTypeId in u
-}
+export const isEntry = (u: unknown): u is Request.Entry<unknown> => hasProperty(u, EntryTypeId)
 
 /** @internal */
 export const makeEntry = <A extends Request.Request<any, any>>(

package/src/internal/cache.ts

@@ -14,6 +14,7 @@ import * as MutableHashMap from "../MutableHashMap"
 import * as MutableQueue from "../MutableQueue"
 import * as MutableRef from "../MutableRef"
 import * as Option from "../Option"
+import { hasProperty } from "../Predicate"
 import * as core from "./core"
 import * as effect from "./core-effect"
 import * as Data from "./Data"
@@ -140,7 +141,7 @@ class MapKeyImpl<K> implements MapKey<K> {
 export const makeMapKey = <K>(current: K): MapKey<K> => new MapKeyImpl(current)
 
 /** @internal */
-export const isMapKey = (u: unknown): u is MapKey<unknown> => typeof u === "object" && u != null && MapKeyTypeId in u
+export const isMapKey = (u: unknown): u is MapKey<unknown> => hasProperty(u, MapKeyTypeId)
 
 /**
  * A `KeySet` is a sorted set of keys in the cache ordered by last access.

package/src/internal/cause.ts

@@ -9,7 +9,7 @@ import * as HashSet from "../HashSet"
 import { NodeInspectSymbol, toJSON } from "../Inspectable"
 import * as Option from "../Option"
 import { pipeArguments } from "../Pipeable"
-import type { Predicate } from "../Predicate"
+import { hasProperty, isFunction, type Predicate } from "../Predicate"
 import * as ReadonlyArray from "../ReadonlyArray"
 import * as OpCodes from "./opCodes/cause"
 
@@ -128,7 +128,7 @@ export const sequential = <E, E2>(left: Cause.Cause<E>, right: Cause.Cause<E2>):
 // -----------------------------------------------------------------------------
 
 /** @internal */
-export const isCause = (u: unknown): u is Cause.Cause<never> => typeof u === "object" && u != null && CauseTypeId in u
+export const isCause = (u: unknown): u is Cause.Cause<never> => hasProperty(u, CauseTypeId)
 
 /** @internal */
 export const isEmptyType = <E>(self: Cause.Cause<E>): self is Cause.Empty => self._tag === OpCodes.OP_EMPTY
@@ -1015,9 +1015,7 @@ export const RuntimeException = makeException<Cause.RuntimeException>({
 }, "RuntimeException")
 
 /** @internal */
-export const isRuntimeException = (u: unknown): u is Cause.RuntimeException => {
-  return typeof u === "object" && u != null && RuntimeExceptionTypeId in u
-}
+export const isRuntimeException = (u: unknown): u is Cause.RuntimeException => hasProperty(u, RuntimeExceptionTypeId)
 
 /** @internal */
 export const InterruptedExceptionTypeId: Cause.InterruptedExceptionTypeId = Symbol.for(
@@ -1030,9 +1028,8 @@ export const InterruptedException = makeException<Cause.InterruptedException>({
 }, "InterruptedException")
 
 /** @internal */
-export const isInterruptedException = (u: unknown): u is Cause.InterruptedException => {
-  return typeof u === "object" && u != null && InterruptedExceptionTypeId in u
-}
+export const isInterruptedException = (u: unknown): u is Cause.InterruptedException =>
+  hasProperty(u, InterruptedExceptionTypeId)
 
 /** @internal */
 export const IllegalArgumentExceptionTypeId: Cause.IllegalArgumentExceptionTypeId = Symbol.for(
@@ -1045,9 +1042,8 @@ export const IllegalArgumentException = makeException<Cause.IllegalArgumentExcep
 }, "IllegalArgumentException")
 
 /** @internal */
-export const isIllegalArgumentException = (u: unknown): u is Cause.IllegalArgumentException => {
-  return typeof u === "object" && u != null && IllegalArgumentExceptionTypeId in u
-}
+export const isIllegalArgumentException = (u: unknown): u is Cause.IllegalArgumentException =>
+  hasProperty(u, IllegalArgumentExceptionTypeId)
 
 /** @internal */
 export const NoSuchElementExceptionTypeId: Cause.NoSuchElementExceptionTypeId = Symbol.for(
@@ -1060,9 +1056,8 @@ export const NoSuchElementException = makeException<Cause.NoSuchElementException
 }, "NoSuchElementException")
 
 /** @internal */
-export const isNoSuchElementException = (u: unknown): u is Cause.NoSuchElementException => {
-  return typeof u === "object" && u != null && NoSuchElementExceptionTypeId in u
-}
+export const isNoSuchElementException = (u: unknown): u is Cause.NoSuchElementException =>
+  hasProperty(u, NoSuchElementExceptionTypeId)
 
 /** @internal */
 export const InvalidPubSubCapacityExceptionTypeId: Cause.InvalidPubSubCapacityExceptionTypeId = Symbol.for(
@@ -1075,9 +1070,8 @@ export const InvalidPubSubCapacityException = makeException<Cause.InvalidPubSubC
 }, "InvalidPubSubCapacityException")
 
 /** @internal */
-export const isInvalidCapacityError = (u: unknown): u is Cause.InvalidPubSubCapacityException => {
-  return typeof u === "object" && u != null && InvalidPubSubCapacityExceptionTypeId in u
-}
+export const isInvalidCapacityError = (u: unknown): u is Cause.InvalidPubSubCapacityException =>
+  hasProperty(u, InvalidPubSubCapacityExceptionTypeId)
 
 // -----------------------------------------------------------------------------
 // Pretty Printing
@@ -1163,10 +1157,8 @@ export const prettyErrorMessage = (u: unknown): string => {
   }
   // 2)
   if (
-    typeof u === "object" &&
-    u != null &&
-    "toString" in u &&
-    typeof u["toString"] === "function" &&
+    hasProperty(u, "toString") &&
+    isFunction(u["toString"]) &&
     u["toString"] !== Object.prototype.toString
   ) {
     return u["toString"]()
@@ -1178,8 +1170,8 @@ export const prettyErrorMessage = (u: unknown): string => {
 const spanSymbol = Symbol.for("effect/SpanAnnotation")
 
 const defaultRenderError = (error: unknown): PrettyError => {
-  const span = typeof error === "object" && error !== null && spanSymbol in error && (error as any)[spanSymbol]
-  if (typeof error === "object" && error !== null && error instanceof Error) {
+  const span: any = hasProperty(error, spanSymbol) && error[spanSymbol]
+  if (error instanceof Error) {
     return new PrettyError(
       prettyErrorMessage(error),
       error.stack?.split("\n").filter((_) => _.match(/at (.*)/)).join("\n"),

package/src/internal/channel/channelState.ts

@@ -1,5 +1,6 @@
 import * as Effect from "../../Effect"
 import type * as Exit from "../../Exit"
+import { hasProperty } from "../../Predicate"
 import * as OpCodes from "../opCodes/channelState"
 import type { ErasedExecutor } from "./channelExecutor"
 
@@ -107,8 +108,7 @@ export const Read = <R>(
 }
 
 /** @internal */
-export const isChannelState = (u: unknown): u is ChannelState<unknown, unknown> =>
-  typeof u === "object" && u != null && ChannelStateTypeId in u
+export const isChannelState = (u: unknown): u is ChannelState<unknown, unknown> => hasProperty(u, ChannelStateTypeId)
 
 /** @internal */
 export const isDone = <R, E>(self: ChannelState<R, E>): self is Done => (self as Primitive)._tag === OpCodes.OP_DONE

package/src/internal/channel/childExecutorDecision.ts

@@ -1,5 +1,6 @@
 import type * as ChildExecutorDecision from "../../ChannelChildExecutorDecision"
 import { dual } from "../../Function"
+import { hasProperty } from "../../Predicate"
 import * as OpCodes from "../opCodes/channelChildExecutorDecision"
 
 /** @internal */
@@ -39,7 +40,7 @@ export const Yield = (_: void): ChildExecutorDecision.ChildExecutorDecision => {
 
 /** @internal */
 export const isChildExecutorDecision = (u: unknown): u is ChildExecutorDecision.ChildExecutorDecision =>
-  typeof u === "object" && u != null && ChildExecutorDecisionTypeId in u
+  hasProperty(u, ChildExecutorDecisionTypeId)
 
 /** @internal */
 export const isContinue = (

package/src/internal/channel/mergeDecision.ts

@@ -2,6 +2,7 @@ import type * as MergeDecision from "../../ChannelMergeDecision"
 import type * as Effect from "../../Effect"
 import type * as Exit from "../../Exit"
 import { dual } from "../../Function"
+import { hasProperty } from "../../Predicate"
 import * as OpCodes from "../opCodes/channelMergeDecision"
 
 /** @internal */
@@ -78,8 +79,7 @@ export const AwaitConst = <R, E, Z>(
 /** @internal */
 export const isMergeDecision = (
   u: unknown
-): u is MergeDecision.MergeDecision<unknown, unknown, unknown, unknown, unknown> =>
-  typeof u === "object" && u != null && MergeDecisionTypeId in u
+): u is MergeDecision.MergeDecision<unknown, unknown, unknown, unknown, unknown> => hasProperty(u, MergeDecisionTypeId)
 
 /** @internal */
 export const match = dual<

package/src/internal/channel/mergeState.ts

@@ -4,6 +4,7 @@ import type * as Either from "../../Either"
 import type * as Exit from "../../Exit"
 import type * as Fiber from "../../Fiber"
 import { dual } from "../../Function"
+import { hasProperty } from "../../Predicate"
 import * as OpCodes from "../opCodes/channelMergeState"
 
 /** @internal */
@@ -54,9 +55,8 @@ export const RightDone = <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
 /** @internal */
 export const isMergeState = (
   u: unknown
-): u is MergeState.MergeState<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> => {
-  return typeof u === "object" && u != null && MergeStateTypeId in u
-}
+): u is MergeState.MergeState<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> =>
+  hasProperty(u, MergeStateTypeId)
 
 /** @internal */
 export const isBothRunning = <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(

package/src/internal/channel/mergeStrategy.ts

@@ -1,5 +1,6 @@
 import type * as MergeStrategy from "../../ChannelMergeStrategy"
 import { dual } from "../../Function"
+import { hasProperty } from "../../Predicate"
 import * as OpCodes from "../opCodes/channelMergeStrategy"
 
 /** @internal */
@@ -30,8 +31,7 @@ export const BufferSliding = (_: void): MergeStrategy.MergeStrategy => {
 }
 
 /** @internal */
-export const isMergeStrategy = (u: unknown): u is MergeStrategy.MergeStrategy =>
-  typeof u === "object" && u != null && MergeStrategyTypeId in u
+export const isMergeStrategy = (u: unknown): u is MergeStrategy.MergeStrategy => hasProperty(u, MergeStrategyTypeId)
 
 /** @internal */
 export const isBackPressure = (self: MergeStrategy.MergeStrategy): self is MergeStrategy.BackPressure =>

package/src/internal/channel/upstreamPullRequest.ts

@@ -1,5 +1,6 @@
 import type * as UpstreamPullRequest from "../../ChannelUpstreamPullRequest"
 import { dual } from "../../Function"
+import { hasProperty } from "../../Predicate"
 import * as OpCodes from "../opCodes/channelUpstreamPullRequest"
 
 /** @internal */
@@ -38,7 +39,7 @@ export const NoUpstream = (activeDownstreamCount: number): UpstreamPullRequest.U
 
 /** @internal */
 export const isUpstreamPullRequest = (u: unknown): u is UpstreamPullRequest.UpstreamPullRequest<unknown> =>
-  typeof u === "object" && u != null && UpstreamPullRequestTypeId in u
+  hasProperty(u, UpstreamPullRequestTypeId)
 
 /** @internal */
 export const isPulled = <A>(

package/src/internal/channel/upstreamPullStrategy.ts

@@ -1,6 +1,7 @@
 import type * as UpstreamPullStrategy from "../../ChannelUpstreamPullStrategy"
 import { dual } from "../../Function"
 import type * as Option from "../../Option"
+import { hasProperty } from "../../Predicate"
 import * as OpCodes from "../opCodes/channelUpstreamPullStrategy"
 
 /** @internal */
@@ -41,7 +42,7 @@ export const PullAfterAllEnqueued = <A>(
 
 /** @internal */
 export const isUpstreamPullStrategy = (u: unknown): u is UpstreamPullStrategy.UpstreamPullStrategy<unknown> =>
-  typeof u === "object" && u != null && UpstreamPullStrategyTypeId in u
+  hasProperty(u, UpstreamPullStrategyTypeId)
 
 /** @internal */
 export const isPullAfterNext = <A>(

package/src/internal/channel.ts

@@ -16,7 +16,7 @@ import { constVoid, dual, identity, pipe } from "../Function"
 import type { LazyArg } from "../Function"
 import * as Layer from "../Layer"
 import * as Option from "../Option"
-import type { Predicate } from "../Predicate"
+import { hasProperty, type Predicate } from "../Predicate"
 import * as PubSub from "../PubSub"
 import * as Queue from "../Queue"
 import * as Ref from "../Ref"
@@ -2517,4 +2517,4 @@ export const ChannelException = <E>(error: E): Channel.ChannelException<E> => ({
 
 /** @internal */
 export const isChannelException = (u: unknown): u is Channel.ChannelException<unknown> =>
-  typeof u === "object" && u != null && ChannelExceptionTypeId in u
+  hasProperty(u, ChannelExceptionTypeId)

package/src/internal/clock.ts

@@ -49,7 +49,7 @@ const performanceNowNanos = (function() {
 
   const origin = "timeOrigin" in performance && typeof performance.timeOrigin === "number" ?
     BigInt(Math.round(performance.timeOrigin * 1_000_000)) :
-    BigInt(Date.now()) * bigint1e6
+    (BigInt(Date.now()) * bigint1e6) - BigInt(Math.round(performance.now() * 1_000_000))
 
   return () => origin + BigInt(Math.round(performance.now() * 1_000_000))
 })()

package/src/internal/config.ts

@@ -14,7 +14,7 @@ import * as OpCodes from "../internal/opCodes/config"
 import type * as LogLevel from "../LogLevel"
 import * as Option from "../Option"
 import { pipeArguments } from "../Pipeable"
-import type { Predicate, Refinement } from "../Predicate"
+import { hasProperty, type Predicate, type Refinement } from "../Predicate"
 
 /** @internal */
 const ConfigSymbolKey = "effect/Config"
@@ -483,8 +483,7 @@ export const hashMap = <A>(config: Config.Config<A>, name?: string): Config.Conf
 }
 
 /** @internal */
-export const isConfig = (u: unknown): u is Config.Config<unknown> =>
-  typeof u === "object" && u != null && ConfigTypeId in u
+export const isConfig = (u: unknown): u is Config.Config<unknown> => hasProperty(u, ConfigTypeId)
 
 /** @internal */
 const tuple = <T extends ArrayLike<Config.Config<any>>>(tuple: T): Config.Config<

package/src/internal/configError.ts

@@ -3,6 +3,7 @@ import type * as ConfigError from "../ConfigError"
 import * as Either from "../Either"
 import { constFalse, constTrue, dual, pipe } from "../Function"
 import * as OpCodes from "../internal/opCodes/configError"
+import { hasProperty } from "../Predicate"
 import * as RA from "../ReadonlyArray"
 
 /** @internal */
@@ -131,8 +132,7 @@ export const Unsupported = (
 }
 
 /** @internal */
-export const isConfigError = (u: unknown): u is ConfigError.ConfigError =>
-  typeof u === "object" && u != null && ConfigErrorTypeId in u
+export const isConfigError = (u: unknown): u is ConfigError.ConfigError => hasProperty(u, ConfigErrorTypeId)
 
 /** @internal */
 export const isAnd = (self: ConfigError.ConfigError): self is ConfigError.And => self._tag === OpCodes.OP_AND

package/src/internal/configSecret.ts

@@ -3,6 +3,7 @@ import type * as ConfigSecret from "../ConfigSecret"
 import * as Equal from "../Equal"
 import { pipe } from "../Function"
 import * as Hash from "../Hash"
+import { hasProperty } from "../Predicate"
 
 /** @internal */
 const ConfigSecretSymbolKey = "effect/ConfigSecret"
@@ -28,9 +29,7 @@ export const proto = {
 }
 
 /** @internal */
-export const isConfigSecret = (u: unknown): u is ConfigSecret.ConfigSecret => {
-  return typeof u === "object" && u != null && ConfigSecretTypeId in u
-}
+export const isConfigSecret = (u: unknown): u is ConfigSecret.ConfigSecret => hasProperty(u, ConfigSecretTypeId)
 
 /** @internal */
 export const make = (bytes: Array<number>): ConfigSecret.ConfigSecret => {

package/src/internal/core-effect.ts

@@ -143,7 +143,7 @@ export const _catch = dual<
   3,
   (self, tag, options) =>
     core.catchAll(self, (e) => {
-      if (typeof e === "object" && e != null && tag in e && e[tag] === options.failure) {
+      if (Predicate.hasProperty(e, tag) && e[tag] === options.failure) {
         return options.onFailure(e as any)
       }
       return core.fail(e as any)
@@ -303,9 +303,9 @@ export const catchTags: {
     self,
     (e): e is { readonly _tag: string } => {
       keys ??= Object.keys(cases)
-      return Predicate.isObject(e) && "_tag" in e && keys.includes(e["_tag"] as any)
+      return Predicate.hasProperty(e, "_tag") && Predicate.isString(e["_tag"]) && keys.includes(e["_tag"])
     },
-    (e) => cases[e["_tag"] as any](e as any)
+    (e) => cases[e["_tag"]](e)
   )
 })
 

package/src/internal/core-stream.ts

@@ -13,6 +13,7 @@ import { constVoid, dual, identity } from "../Function"
 import type { LazyArg } from "../Function"
 import * as Option from "../Option"
 import { pipeArguments } from "../Pipeable"
+import { hasProperty } from "../Predicate"
 import * as childExecutorDecision from "./channel/childExecutorDecision"
 import type { ErasedContinuationK } from "./channel/continuation"
 import { ContinuationKImpl } from "./channel/continuation"
@@ -195,7 +196,7 @@ export const isChannel = (u: unknown): u is Channel.Channel<
   unknown,
   unknown,
   unknown
-> => (typeof u === "object" && u != null && ChannelTypeId in u) || Effect.isEffect(u)
+> => hasProperty(u, ChannelTypeId) || Effect.isEffect(u)
 
 /** @internal */
 export const acquireReleaseOut = dual<

package/src/internal/core.ts

@@ -35,7 +35,7 @@ import type * as MetricLabel from "../MetricLabel"
 import * as MutableRef from "../MutableRef"
 import * as Option from "../Option"
 import { pipeArguments } from "../Pipeable"
-import type { Predicate, Refinement } from "../Predicate"
+import { hasProperty, isObject, type Predicate, type Refinement } from "../Predicate"
 import * as ReadonlyArray from "../ReadonlyArray"
 import type * as Request from "../Request"
 import type * as BlockedRequests from "../RequestBlock"
@@ -44,6 +44,7 @@ import type * as RuntimeFlags from "../RuntimeFlags"
 import * as RuntimeFlagsPatch from "../RuntimeFlagsPatch"
 import type * as Scope from "../Scope"
 import type * as Tracer from "../Tracer"
+import { effectVariance } from "./Effectable"
 
 // -----------------------------------------------------------------------------
 // Effect
@@ -66,8 +67,7 @@ export interface EffectError<E> {
 }
 
 /** @internal */
-export const isEffectError = (u: unknown): u is EffectError<unknown> =>
-  typeof u === "object" && u != null && EffectErrorTypeId in u
+export const isEffectError = (u: unknown): u is EffectError<unknown> => hasProperty(u, EffectErrorTypeId)
 
 /** @internal */
 export const makeEffectError = <E>(cause: Cause.Cause<E>): EffectError<E> => ({
@@ -253,13 +253,6 @@ class EffectPrimitiveSuccess {
   }
 }
 
-/** @internal */
-const effectVariance = {
-  _R: (_: never) => _,
-  _E: (_: never) => _,
-  _A: (_: never) => _
-}
-
 /** @internal */
 export type Op<Tag extends string, Body = {}> = Effect.Effect<never, never, never> & Body & {
   readonly _op: Tag
@@ -379,8 +372,7 @@ export interface WithRuntime extends
 export interface Yield extends Op<OpCodes.OP_YIELD> {}
 
 /** @internal */
-export const isEffect = (u: unknown): u is Effect.Effect<unknown, unknown, unknown> =>
-  typeof u === "object" && u != null && EffectTypeId in u
+export const isEffect = (u: unknown): u is Effect.Effect<unknown, unknown, unknown> => hasProperty(u, EffectTypeId)
 
 /* @internal */
 export const withFiberRuntime = <R, E, A>(
@@ -610,7 +602,7 @@ const originalSymbol = Symbol.for("effect/OriginalAnnotation")
 
 /* @internal */
 export const originalInstance = <E>(obj: E): E => {
-  if (typeof obj === "object" && obj !== null && originalSymbol in obj) {
+  if (hasProperty(obj, originalSymbol)) {
     // @ts-expect-error
     return obj[originalSymbol]
   }
@@ -641,7 +633,7 @@ const capture = <E>(obj: E & object, span: Option.Option<Tracer.Span>): E => {
 
 /* @internal */
 export const die = (defect: unknown): Effect.Effect<never, never, never> =>
-  typeof defect === "object" && defect !== null && !(spanSymbol in defect) ?
+  isObject(defect) && !(spanSymbol in defect) ?
     withFiberRuntime((fiber) => failCause(internalCause.die(capture(defect, currentSpanFromFiber(fiber)))))
     : failCause(internalCause.die(defect))
 
@@ -668,7 +660,7 @@ export const exit = <R, E, A>(self: Effect.Effect<R, E, A>): Effect.Effect<R, ne
 
 /* @internal */
 export const fail = <E>(error: E): Effect.Effect<never, E, never> =>
-  typeof error === "object" && error !== null && !(spanSymbol in error) ?
+  isObject(error) && !(spanSymbol in error) ?
     withFiberRuntime((fiber) => failCause(internalCause.fail(capture(error, currentSpanFromFiber(fiber)))))
     : failCause(internalCause.fail(error))
 
@@ -1634,7 +1626,7 @@ export class RequestResolverImpl<R, A> implements RequestResolver.RequestResolve
 
 /** @internal */
 export const isRequestResolver = (u: unknown): u is RequestResolver.RequestResolver<unknown, unknown> =>
-  typeof u === "object" && u != null && RequestResolverTypeId in u
+  hasProperty(u, RequestResolverTypeId)
 
 // end