effect 2.0.0-next.51 → 2.0.0-next.53

package/src/Stream.ts

@@ -144,6 +144,23 @@ export declare namespace Stream {
  */
 export const DefaultChunkSize: number = internal.DefaultChunkSize
 
+/**
+ * Collects each underlying Chunk of the stream into a new chunk, and emits it
+ * on each pull.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const accumulate: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>> = internal.accumulate
+
+/**
+ * Re-chunks the elements of the stream by accumulating each underlying chunk.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const accumulateChunks: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A> = internal.accumulateChunks
+
 /**
  * Creates a stream from a single value that will get cleaned up after the
  * stream is consumed.

package/src/TestAnnotation.ts

@@ -10,6 +10,7 @@ import { pipe } from "./Function"
 import * as Hash from "./Hash"
 import * as HashSet from "./HashSet"
 import type * as MutableRef from "./MutableRef"
+import { hasProperty } from "./Predicate"
 import type * as SortedSet from "./SortedSet"
 
 /** @internal */
@@ -62,9 +63,7 @@ class TestAnnotationImpl<A> implements Equal.Equal {
 /**
  * @since 2.0.0
  */
-export const isTestAnnotation = (u: unknown): u is TestAnnotation<unknown> => {
-  return typeof u === "object" && u != null && TestAnnotationTypeId in u
-}
+export const isTestAnnotation = (u: unknown): u is TestAnnotation<unknown> => hasProperty(u, TestAnnotationTypeId)
 
 /**
  * @since 2.0.0

package/src/TestAnnotationMap.ts

@@ -2,6 +2,7 @@
  * @since 2.0.0
  */
 import { dual, pipe } from "./Function"
+import { hasProperty } from "./Predicate"
 import type * as TestAnnotation from "./TestAnnotation"
 
 /**
@@ -35,9 +36,7 @@ class TestAnnotationMapImpl implements TestAnnotationMap {
 /**
  * @since 2.0.0
  */
-export const isTestAnnotationMap = (u: unknown): u is TestAnnotationMap => {
-  return typeof u === "object" && u != null && TestAnnotationMapTypeId in u
-}
+export const isTestAnnotationMap = (u: unknown): u is TestAnnotationMap => hasProperty(u, TestAnnotationMapTypeId)
 
 /**
  * @since 2.0.0

package/src/TestAnnotations.ts

@@ -10,6 +10,7 @@ import * as core from "./internal/core"
 import * as effect from "./internal/core-effect"
 import * as fiber from "./internal/fiber"
 import * as MutableRef from "./MutableRef"
+import { hasProperty } from "./Predicate"
 import * as RA from "./ReadonlyArray"
 import * as Ref from "./Ref"
 import * as SortedSet from "./SortedSet"
@@ -101,9 +102,7 @@ export const TestAnnotations: Context.Tag<TestAnnotations, TestAnnotations> = Co
 /**
  * @since 2.0.0
  */
-export const isTestAnnotations = (u: unknown): u is TestAnnotations => {
-  return typeof u === "object" && u != null && TestAnnotationsTypeId in u
-}
+export const isTestAnnotations = (u: unknown): u is TestAnnotations => hasProperty(u, TestAnnotationsTypeId)
 
 /**
  * @since 2.0.0

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/Data.ts

@@ -39,7 +39,8 @@ export const StructProto: Equal.Equal = {
 
 /** @internal */
 export const Structural: new<A>(
-  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void : Omit<A, keyof Equal.Equal>
+  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
+    : { readonly [P in keyof A as P extends keyof Equal.Equal ? never : P]: A[P] }
 ) => Data.Case = (function() {
   function Structural(this: any, args: any) {
     if (args) {

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

@@ -4,6 +4,7 @@ import * as Duration from "../Duration"
 import type * as Effect from "../Effect"
 import * as Either from "../Either"
 import { constFalse } from "../Function"
+import { hasProperty, isFunction } from "../Predicate"
 import * as core from "./core"
 import * as timeout from "./timeout"
 
@@ -49,15 +50,14 @@ 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))
 })()
 const processOrPerformanceNow = (function() {
-  const processHrtime =
-    typeof process === "object" && "hrtime" in process && typeof process.hrtime.bigint === "function" ?
-      process.hrtime :
-      undefined
+  const processHrtime = hasProperty(process, "hrtime") && isFunction(process.hrtime.bigint) ?
+    process.hrtime :
+    undefined
   if (!processHrtime) {
     return performanceNowNanos
   }

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 => {