effect 2.0.0-next.52 → 2.0.0-next.53

package/internal/stm/core.esm.js

@@ -18,8 +18,10 @@ import { isSuccess, succeed as succeed$2, interrupt as interrupt$2, retry as ret
 import { suspend, done } from './stm/tryCommit.esm.js';
 import { make } from './stm/txnId.esm.js';
 import { pipeArguments } from '../../Pipeable/dist/effect-Pipeable.esm.js';
+import { hasProperty } from '../../Predicate/dist/effect-Predicate.esm.js';
 import { StreamTypeId } from '../../Stream/dist/effect-Stream.esm.js';
 import { ChannelTypeId } from '../core-stream.esm.js';
+import { effectVariance } from '../Effectable.esm.js';
 import { SinkTypeId } from '../sink.esm.js';
 
 /** @internal */
@@ -72,7 +74,7 @@ class STMPrimitive {
   }
   constructor(i0) {
     this.i0 = i0;
-    this[EffectTypeId] = stmVariance;
+    this[EffectTypeId] = effectVariance;
     this[StreamTypeId] = stmVariance;
     this[SinkTypeId] = stmVariance;
     this[ChannelTypeId] = stmVariance;
@@ -92,7 +94,7 @@ class STMPrimitive {
 }
 
 /** @internal */
-const isSTM = u => typeof u === "object" && u != null && STMTypeId in u;
+const isSTM = u => hasProperty(u, STMTypeId);
 
 /** @internal */
 const commit = self => unsafeAtomically(self, constVoid, constVoid);

package/internal/stm/stm/stmState.esm.js

@@ -4,6 +4,7 @@ import { pipe } from '../../../Function/dist/effect-Function.esm.js';
 import { symbol, combine, hash } from '../../../Hash/dist/effect-Hash.esm.js';
 import { OP_DONE, OP_RUNNING, OP_INTERRUPTED } from '../opCodes/stmState.esm.js';
 import { OP_RETRY, OP_SUCCEED, OP_INTERRUPT, OP_DIE, OP_FAIL } from '../opCodes/tExit.esm.js';
+import { hasProperty } from '../../../Predicate/dist/effect-Predicate.esm.js';
 
 /** @internal */
 const STMStateSymbolKey = "effect/STM/State";
@@ -22,9 +23,7 @@ const STMStateTypeId = /*#__PURE__*/Symbol.for(STMStateSymbolKey);
 /** @internal */
 
 /** @internal */
-const isSTMState = u => {
-  return typeof u === "object" && u != null && STMStateTypeId in u;
-};
+const isSTMState = u => hasProperty(u, STMStateTypeId);
 
 /** @internal */
 const isRunning = self => {

package/internal/stm/stm/tExit.esm.js

@@ -2,6 +2,7 @@ import { symbol as symbol$1, equals } from '../../../Equal/dist/effect-Equal.esm
 import { pipe } from '../../../Function/dist/effect-Function.esm.js';
 import { symbol, combine, hash } from '../../../Hash/dist/effect-Hash.esm.js';
 import { OP_SUCCEED, OP_FAIL, OP_DIE, OP_INTERRUPT, OP_RETRY } from '../opCodes/tExit.esm.js';
+import { hasProperty } from '../../../Predicate/dist/effect-Predicate.esm.js';
 
 /** @internal */
 const TExitSymbolKey = "effect/TExit";
@@ -32,9 +33,7 @@ const variance = {
 /** @internal */
 
 /** @internal */
-const isExit = u => {
-  return typeof u === "object" && u != null && TExitTypeId in u;
-};
+const isExit = u => hasProperty(u, TExitTypeId);
 
 /** @internal */
 const isSuccess = self => {

package/internal/stm/tQueue.esm.js

@@ -5,6 +5,7 @@ import { OP_SLIDING_STRATEGY, OP_DROPPING_STRATEGY, OP_BACKPRESSURE_STRATEGY } f
 import { suspend, unit } from './stm.esm.js';
 import { make, unsafeGet, unsafeSet } from './tRef.esm.js';
 import { fromNullable } from '../../Option/dist/effect-Option.esm.js';
+import { hasProperty } from '../../Predicate/dist/effect-Predicate.esm.js';
 import { head } from '../../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
 import { interruptAs } from '../../STM/dist/effect-STM.esm.js';
 
@@ -218,14 +219,10 @@ const isTQueue = u => {
 };
 
 /** @internal */
-const isTEnqueue = u => {
-  return typeof u === "object" && u != null && TEnqueueTypeId in u;
-};
+const isTEnqueue = u => hasProperty(u, TEnqueueTypeId);
 
 /** @internal */
-const isTDequeue = u => {
-  return typeof u === "object" && u != null && TDequeueTypeId in u;
-};
+const isTDequeue = u => hasProperty(u, TDequeueTypeId);
 
 /** @internal */
 const awaitShutdown = self => self.awaitShutdown;

package/internal/stream.esm.js

@@ -14,6 +14,7 @@ import { dual, pipe, identity, constTrue } from '../Function/dist/effect-Functio
 import { build, context as context$1, merge as merge$1 } from '../Layer/dist/effect-Layer.esm.js';
 import { none, some as some$1, match as match$2, getOrElse, map as map$4, isSome, isNone } from '../Option/dist/effect-Option.esm.js';
 import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { isTagged, hasProperty } from '../Predicate/dist/effect-Predicate.esm.js';
 import { bounded as bounded$1, subscribe, shutdown as shutdown$1 } from '../PubSub/dist/effect-PubSub.esm.js';
 import { take as take$2, shutdown, bounded, dropping, sliding as sliding$1, isShutdown, takeBetween, offerAll, offer as offer$1, unbounded } from '../Queue/dist/effect-Queue.esm.js';
 import { make as make$2, getAndSet, set, get, update, modify } from '../Ref/dist/effect-Ref.esm.js';
@@ -25,7 +26,7 @@ import { unwrap as unwrap$1, zipRight as zipRight$2, pipeToOrFail, unwrapScoped
 import { run as run$1, runScoped as runScoped$1 } from './channel/channelExecutor.esm.js';
 import { BufferSliding } from './channel/mergeStrategy.esm.js';
 import { make as make$5 } from './channel/singleProducerAsyncInput.esm.js';
-import { readWithCause, flatMap as flatMap$1, fromEffect as fromEffect$1, write, failCause as failCause$1, unit as unit$1, pipeTo, collectElements, fail as fail$1, catchAllCause as catchAllCause$1, readWith, suspend as suspend$2, succeedNow, ensuringWith as ensuringWith$1, succeed as succeed$3, provideContext as provideContext$1, foldCauseChannel, sync as sync$2, embedInput } from './core-stream.esm.js';
+import { pipeTo, readWithCause, flatMap as flatMap$1, fromEffect as fromEffect$1, write, failCause as failCause$1, unit as unit$1, collectElements, fail as fail$1, catchAllCause as catchAllCause$1, readWith, suspend as suspend$2, succeedNow, ensuringWith as ensuringWith$1, succeed as succeed$3, provideContext as provideContext$1, foldCauseChannel, sync as sync$2, embedInput } from './core-stream.esm.js';
 import { RingBuffer } from './ringBuffer.esm.js';
 import { toChannel as toChannel$1, collectAllN, mkString as mkString$1, foldSink, collectLeftover, zipRight as zipRight$3, fromEffect as fromEffect$2, fail as fail$5, fromChannel as fromChannel$1, collectAll, count, drain as drain$2, fold, foldEffect, forEach as forEach$1, forEachChunk, forEachWhile, head, last, sum } from './sink.esm.js';
 import { OP_CURRENT, OP_PREVIOUS, current, OP_NOT_STARTED, notStarted, previous } from './stream/debounceState.esm.js';
@@ -64,11 +65,27 @@ class StreamImpl {
 }
 
 /** @internal */
-const isStream = u => typeof u === "object" && u != null && StreamTypeId in u || isEffect(u);
+const isStream = u => hasProperty(u, StreamTypeId) || isEffect(u);
 
 /** @internal */
 const DefaultChunkSize = 4096;
 
+/** @internal */
+const accumulate = self => chunks(accumulateChunks(self));
+
+/** @internal */
+const accumulateChunks = self => {
+  const accumulator = s => readWith({
+    onInput: input => {
+      const next = appendAll(s, input);
+      return flatMap$1(write(next), () => accumulator(next));
+    },
+    onFailure: fail$1,
+    onDone: () => unit$1
+  });
+  return new StreamImpl(pipeTo(toChannel(self), accumulator(empty$1())));
+};
+
 /** @internal */
 const acquireRelease = (acquire, release) => scoped(acquireRelease$1(acquire, release));
 
@@ -1076,7 +1093,7 @@ const fromReadableStream = (evaluate, onError) => unwrapScoped(map$1(acquireRele
 /** @internal */
 const fromReadableStreamByob = (evaluate, onError, allocSize = 4096) => unwrapScoped(map$1(acquireRelease$1(sync$1(() => evaluate().getReader({
   mode: "byob"
-})), reader => promise(() => reader.cancel())), reader => catchAll(forever(readChunkStreamByobReader(reader, onError, allocSize)), error => typeof error === "object" && error !== null && "_tag" in error && error._tag === "EOF" ? empty : fail(error))));
+})), reader => promise(() => reader.cancel())), reader => catchAll(forever(readChunkStreamByobReader(reader, onError, allocSize)), error => isTagged(error, "EOF") ? empty : fail(error))));
 const readChunkStreamByobReader = (reader, onError, size) => {
   const buffer = new ArrayBuffer(size);
   return paginateEffect(0, offset => flatMap$2(tryPromise({
@@ -2987,4 +3004,4 @@ const encodeText = self => suspend(() => {
   return map(self, s => encoder.encode(s));
 });
 
-export { DefaultChunkSize, Do, StreamImpl, StreamTypeId, _async, acquireRelease, aggregate, aggregateWithin, aggregateWithinEither, as, asyncEffect, asyncInterrupt, asyncOption, asyncScoped, bind, bindTo, branchAfter, broadcast, broadcastDynamic, broadcastedQueues, broadcastedQueuesDynamic, buffer, bufferChunks, catchAll, catchAllCause, catchSome, catchSomeCause, catchTag, catchTags, changes, changesWith, changesWithEffect, channelToStream, chunks, chunksWith, combine, combineChunks, concat, concatAll, context, contextWith, contextWithEffect, contextWithStream, cross, crossLeft, crossRight, crossWith, debounce, decodeText, die, dieMessage, dieSync, distributedWith, distributedWithDynamic, distributedWithDynamicCallback, drain, drainFork, drop, dropRight, dropUntil, dropUntilEffect, dropWhile, dropWhileEffect, either, empty, encodeText, ensuring, ensuringWith, execute, fail, failCause, failCauseSync, failSync, filter, filterEffect, filterMap, filterMapEffect, filterMapWhile, filterMapWhileEffect, finalizer, find, findEffect, flatMap, flatten, flattenChunks, flattenEffect, flattenExitOption, flattenIterables, flattenTake, forever, fromAsyncIterable, fromChannel, fromChunk, fromChunkPubSub, fromChunkQueue, fromChunks, fromEffect, fromEffectOption, fromIterable, fromIterableEffect, fromIteratorSucceed, fromPubSub, fromPull, fromQueue, fromReadableStream, fromReadableStreamByob, fromSchedule, groupAdjacentBy, grouped, groupedWithin, haltAfter, haltWhen, haltWhenDeferred, identityStream, interleave, interleaveWith, interruptAfter, interruptWhen, interruptWhenDeferred, intersperse, intersperseAffixes, isStream, iterate, let_, make, map, mapAccum, mapAccumEffect, mapBoth, mapChunks, mapChunksEffect, mapConcat, mapConcatChunk, mapConcatChunkEffect, mapConcatEffect, mapEffectPar, mapEffectSequential, mapError, mapErrorCause, mapInputContext, matchConcurrency, merge, mergeAll, mergeEither, mergeLeft, mergeRight, mergeWith, mkString, never, onDone, onError, orDie, orDieWith, orElse, orElseEither, orElseFail, orElseIfEmpty, orElseIfEmptyChunk, orElseIfEmptyStream, orElseSucceed, paginate, paginateChunk, paginateChunkEffect, paginateEffect, partition, partitionEither, peel, pipeThrough, pipeThroughChannel, pipeThroughChannelOrFail, prepend, provideContext, provideLayer, provideService, provideServiceEffect, provideServiceStream, provideSomeLayer, range, rechunk, refineOrDie, refineOrDieWith, repeat, repeatEffect, repeatEffectChunk, repeatEffectChunkOption, repeatEffectOption, repeatEffectWithSchedule, repeatEither, repeatElements, repeatElementsWith, repeatValue, repeatWith, repeatWithSchedule, retry, run, runCollect, runCount, runDrain, runFold, runFoldEffect, runFoldScoped, runFoldScopedEffect, runFoldWhile, runFoldWhileEffect, runFoldWhileScoped, runFoldWhileScopedEffect, runForEach, runForEachChunk, runForEachChunkScoped, runForEachScoped, runForEachWhile, runForEachWhileScoped, runHead, runIntoPubSub, runIntoPubSubScoped, runIntoQueue, runIntoQueueElementsScoped, runIntoQueueScoped, runLast, runScoped, runSum, scan, scanEffect, scanReduce, scanReduceEffect, schedule, scheduleWith, scoped, sliding, slidingSize, some, someOrElse, someOrFail, split, splitLines, splitOnChunk, succeed, suspend, sync, take, takeRight, takeUntil, takeUntilEffect, takeWhile, tap, tapBoth, tapError, tapErrorCause, tapSink, throttle, throttleEffect, tick, timeout, timeoutFail, timeoutFailCause, timeoutTo, toChannel, toPubSub, toPull, toQueue, toQueueOfElements, toReadableStream, transduce, unfold, unfoldChunk, unfoldChunkEffect, unfoldEffect, unit, unwrap, unwrapScoped, updateService, when, whenCase, whenCaseEffect, whenEffect, withSpan, zip, zipAll, zipAllLeft, zipAllRight, zipAllSortedByKey, zipAllSortedByKeyLeft, zipAllSortedByKeyRight, zipAllSortedByKeyWith, zipAllWith, zipFlatten, zipLatest, zipLatestWith, zipLeft, zipRight, zipWith, zipWithChunks, zipWithIndex, zipWithNext, zipWithPrevious, zipWithPreviousAndNext };
+export { DefaultChunkSize, Do, StreamImpl, StreamTypeId, _async, accumulate, accumulateChunks, acquireRelease, aggregate, aggregateWithin, aggregateWithinEither, as, asyncEffect, asyncInterrupt, asyncOption, asyncScoped, bind, bindTo, branchAfter, broadcast, broadcastDynamic, broadcastedQueues, broadcastedQueuesDynamic, buffer, bufferChunks, catchAll, catchAllCause, catchSome, catchSomeCause, catchTag, catchTags, changes, changesWith, changesWithEffect, channelToStream, chunks, chunksWith, combine, combineChunks, concat, concatAll, context, contextWith, contextWithEffect, contextWithStream, cross, crossLeft, crossRight, crossWith, debounce, decodeText, die, dieMessage, dieSync, distributedWith, distributedWithDynamic, distributedWithDynamicCallback, drain, drainFork, drop, dropRight, dropUntil, dropUntilEffect, dropWhile, dropWhileEffect, either, empty, encodeText, ensuring, ensuringWith, execute, fail, failCause, failCauseSync, failSync, filter, filterEffect, filterMap, filterMapEffect, filterMapWhile, filterMapWhileEffect, finalizer, find, findEffect, flatMap, flatten, flattenChunks, flattenEffect, flattenExitOption, flattenIterables, flattenTake, forever, fromAsyncIterable, fromChannel, fromChunk, fromChunkPubSub, fromChunkQueue, fromChunks, fromEffect, fromEffectOption, fromIterable, fromIterableEffect, fromIteratorSucceed, fromPubSub, fromPull, fromQueue, fromReadableStream, fromReadableStreamByob, fromSchedule, groupAdjacentBy, grouped, groupedWithin, haltAfter, haltWhen, haltWhenDeferred, identityStream, interleave, interleaveWith, interruptAfter, interruptWhen, interruptWhenDeferred, intersperse, intersperseAffixes, isStream, iterate, let_, make, map, mapAccum, mapAccumEffect, mapBoth, mapChunks, mapChunksEffect, mapConcat, mapConcatChunk, mapConcatChunkEffect, mapConcatEffect, mapEffectPar, mapEffectSequential, mapError, mapErrorCause, mapInputContext, matchConcurrency, merge, mergeAll, mergeEither, mergeLeft, mergeRight, mergeWith, mkString, never, onDone, onError, orDie, orDieWith, orElse, orElseEither, orElseFail, orElseIfEmpty, orElseIfEmptyChunk, orElseIfEmptyStream, orElseSucceed, paginate, paginateChunk, paginateChunkEffect, paginateEffect, partition, partitionEither, peel, pipeThrough, pipeThroughChannel, pipeThroughChannelOrFail, prepend, provideContext, provideLayer, provideService, provideServiceEffect, provideServiceStream, provideSomeLayer, range, rechunk, refineOrDie, refineOrDieWith, repeat, repeatEffect, repeatEffectChunk, repeatEffectChunkOption, repeatEffectOption, repeatEffectWithSchedule, repeatEither, repeatElements, repeatElementsWith, repeatValue, repeatWith, repeatWithSchedule, retry, run, runCollect, runCount, runDrain, runFold, runFoldEffect, runFoldScoped, runFoldScopedEffect, runFoldWhile, runFoldWhileEffect, runFoldWhileScoped, runFoldWhileScopedEffect, runForEach, runForEachChunk, runForEachChunkScoped, runForEachScoped, runForEachWhile, runForEachWhileScoped, runHead, runIntoPubSub, runIntoPubSubScoped, runIntoQueue, runIntoQueueElementsScoped, runIntoQueueScoped, runLast, runScoped, runSum, scan, scanEffect, scanReduce, scanReduceEffect, schedule, scheduleWith, scoped, sliding, slidingSize, some, someOrElse, someOrFail, split, splitLines, splitOnChunk, succeed, suspend, sync, take, takeRight, takeUntil, takeUntilEffect, takeWhile, tap, tapBoth, tapError, tapErrorCause, tapSink, throttle, throttleEffect, tick, timeout, timeoutFail, timeoutFailCause, timeoutTo, toChannel, toPubSub, toPull, toQueue, toQueueOfElements, toReadableStream, transduce, unfold, unfoldChunk, unfoldChunkEffect, unfoldEffect, unit, unwrap, unwrapScoped, updateService, when, whenCase, whenCaseEffect, whenEffect, withSpan, zip, zipAll, zipAllLeft, zipAllRight, zipAllSortedByKey, zipAllSortedByKeyLeft, zipAllSortedByKeyRight, zipAllSortedByKeyWith, zipAllWith, zipFlatten, zipLatest, zipLatestWith, zipLeft, zipRight, zipWith, zipWithChunks, zipWithIndex, zipWithNext, zipWithPrevious, zipWithPreviousAndNext };

package/internal/supervisor.esm.js

@@ -2,6 +2,7 @@ import { pipe } from '../Function/dist/effect-Function.esm.js';
 import { globalValue } from '../GlobalValue/dist/effect-GlobalValue.esm.js';
 import { map, zip, sync, unit } from './core.esm.js';
 import { get, set } from '../MutableRef/dist/effect-MutableRef.esm.js';
+import { hasProperty, isTagged } from '../Predicate/dist/effect-Predicate.esm.js';
 import { add, remove } from '../SortedSet/dist/effect-SortedSet.esm.js';
 
 /** @internal */
@@ -86,9 +87,7 @@ class Zip {
     return new Zip(this, right);
   }
 }
-const isZip = self => {
-  return typeof self === "object" && self !== null && SupervisorTypeId in self && "_tag" in self && self._tag === "Zip";
-};
+const isZip = self => hasProperty(self, SupervisorTypeId) && isTagged(self, "Zip");
 class Track {
   [SupervisorTypeId] = supervisorVariance;
   fibers = new Set();

package/internal/version.esm.js

@@ -0,0 +1,3 @@
+const moduleVersion = "2.0.0-next.53";
+
+export { moduleVersion };

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "effect",
-  "version": "2.0.0-next.52",
-  "packageManager": "pnpm@8.7.3",
+  "version": "2.0.0-next.53",
+  "packageManager": "pnpm@8.10.0",
   "publishConfig": {
     "access": "public"
   },
+  "author": "Michael Arnaldi <michael.arnaldi@effectful.co>",
+  "license": "MIT",
   "sideEffects": false,
   "preconstruct": {
     "distFilenameStrategy": "full",
@@ -23,8 +25,6 @@
     "type": "git",
     "url": "https://github.com/Effect-TS/effect.git"
   },
-  "author": "Michael Arnaldi <ma@matechs.com>",
-  "license": "MIT",
   "bugs": {
     "url": "https://github.com/Effect-TS/effect/issues"
   },
@@ -1062,9 +1062,10 @@
     "@babel/preset-typescript": "^7.23.0",
     "@changesets/changelog-github": "^0.4.8",
     "@changesets/cli": "^2.26.2",
-    "@definitelytyped/dtslint": "^0.0.182",
+    "@edge-runtime/vm": "^3.1.6",
     "@effect/build-utils": "^0.1.9",
-    "@effect/docgen": "^0.2.0",
+    "@effect/docgen": "^0.2.1",
+    "@effect/dtslint": "^0.0.3",
     "@effect/eslint-plugin": "^0.1.2",
     "@effect/language-service": "^0.0.21",
     "@preconstruct/cli": "^2.8.1",
@@ -1082,6 +1083,7 @@
     "eslint-plugin-simple-import-sort": "^10.0.0",
     "eslint-plugin-sort-destructure-keys": "^1.5.0",
     "fast-check": "^3.13.1",
+    "jsdom": "^22.1.0",
     "madge": "^6.1.0",
     "prettier": "^3.0.3",
     "ts-node": "^10.9.1",
@@ -1091,18 +1093,18 @@
   },
   "scripts": {
     "build": "pnpm gen && preconstruct fix && preconstruct build && pnpm gen",
-    "gen": "build-utils prepare-v1",
+    "gen": "build-utils prepare-v1 && node scripts/version.mjs",
     "clean": "node scripts/clean.mjs",
     "test": "vitest",
     "check": "tsc -p tsconfig.json",
     "coverage": "vitest run --coverage",
     "circular": "madge --extensions ts --circular --no-color --no-spinner --warning src",
-    "update-version": "changeset version && pnpm install --no-frozen-lockfile",
+    "update-version": "changeset version && pnpm install --no-frozen-lockfile && node scripts/version.mjs",
     "lint": "eslint src test",
     "lint-fix": "eslint src test --fix",
     "fix": "preconstruct fix",
     "docgen": "docgen",
-    "dtslint": "dtslint --expectOnly dtslint",
+    "dtslint": "dtslint dtslint",
     "dtslint-clean": "dtslint --installAll"
   }
 }

package/src/BigDecimal.ts

@@ -23,6 +23,7 @@ import * as Option from "./Option"
 import * as order from "./Order"
 import type { Ordering } from "./Ordering"
 import { type Pipeable, pipeArguments } from "./Pipeable"
+import { hasProperty } from "./Predicate"
 
 const DEFAULT_PRECISION = 100
 
@@ -84,7 +85,7 @@ const BigDecimalProto: Omit<BigDecimal, "value" | "scale" | "normalized"> = {
  * @since 2.0.0
  * @category guards
  */
-export const isBigDecimal = (u: unknown): u is BigDecimal => typeof u === "object" && u !== null && TypeId in u
+export const isBigDecimal = (u: unknown): u is BigDecimal => hasProperty(u, TypeId)
 
 /**
  * Creates a `BigDecimal` from a `bigint` value and a scale.

package/src/Chunk.ts

@@ -15,7 +15,7 @@ import * as Order from "./Order"
 import type { Pipeable } from "./Pipeable"
 import { pipeArguments } from "./Pipeable"
 import type { Predicate, Refinement } from "./Predicate"
-import { isObject } from "./Predicate"
+import { hasProperty } from "./Predicate"
 import * as RA from "./ReadonlyArray"
 import type { NonEmptyReadonlyArray } from "./ReadonlyArray"
 
@@ -116,7 +116,9 @@ const emptyArray: ReadonlyArray<never> = []
  * @since 2.0.0
  */
 export const getEquivalence = <A>(isEquivalent: Equivalence.Equivalence<A>): Equivalence.Equivalence<Chunk<A>> =>
-  Equivalence.make((self, that) => toReadonlyArray(self).every((value, i) => isEquivalent(value, unsafeGet(that, i))))
+  Equivalence.make((self, that) =>
+    self.length === that.length && toReadonlyArray(self).every((value, i) => isEquivalent(value, unsafeGet(that, i)))
+  )
 
 const _equivalence = getEquivalence(Equal.equals)
 
@@ -212,7 +214,7 @@ const makeChunk = <A>(backing: Backing<A>): Chunk<A> => {
 export const isChunk: {
   <A>(u: Iterable<A>): u is Chunk<A>
   (u: unknown): u is Chunk<unknown>
-} = (u: unknown): u is Chunk<unknown> => isObject(u) && TypeId in u
+} = (u: unknown): u is Chunk<unknown> => hasProperty(u, TypeId)
 
 const _empty = makeChunk<never>({ _tag: "IEmpty" })
 

package/src/Duration.ts

@@ -11,7 +11,7 @@ import * as Option from "./Option"
 import * as order from "./Order"
 import type { Pipeable } from "./Pipeable"
 import { pipeArguments } from "./Pipeable"
-import { isBigInt, isNumber } from "./Predicate"
+import { hasProperty, isBigInt, isNumber } from "./Predicate"
 
 const TypeId: unique symbol = Symbol.for("effect/Duration")
 
@@ -162,7 +162,7 @@ const make = (input: number | bigint): Duration => {
  * @since 2.0.0
  * @category guards
  */
-export const isDuration = (u: unknown): u is Duration => typeof u === "object" && u !== null && TypeId in u
+export const isDuration = (u: unknown): u is Duration => hasProperty(u, TypeId)
 
 /**
  * @since 2.0.0

package/src/Effect.ts

@@ -208,6 +208,7 @@ export declare namespace Effect {
    * @category models
    */
   export interface VarianceStruct<R, E, A> {
+    readonly _V: string
     readonly _R: (_: never) => R
     readonly _E: (_: never) => E
     readonly _A: (_: never) => A

package/src/Equal.ts

@@ -3,6 +3,7 @@
  */
 import type { Equivalence } from "./Equivalence"
 import * as Hash from "./Hash"
+import { hasProperty } from "./Predicate"
 
 /**
  * @since 2.0.0
@@ -55,7 +56,7 @@ function compareBoth(self: unknown, that: unknown) {
  * @since 2.0.0
  * @category guards
  */
-export const isEqual = (u: unknown): u is Equal => typeof u === "object" && u !== null && symbol in u
+export const isEqual = (u: unknown): u is Equal => hasProperty(u, symbol)
 
 /**
  * @since 2.0.0

package/src/GlobalValue.ts

@@ -1,7 +1,9 @@
 /**
  * @since 2.0.0
  */
-const globalStoreId = Symbol.for("effect/GlobalValue/globalStoreId")
+import { moduleVersion } from "./internal/version"
+
+const globalStoreId = Symbol.for(`effect/GlobalValue/globalStoreId/${moduleVersion}`)
 
 if (!(globalStoreId in globalThis)) {
   ;(globalThis as any)[globalStoreId] = new Map()

package/src/Hash.ts

@@ -3,6 +3,7 @@
  */
 import { pipe } from "./Function"
 import { globalValue } from "./GlobalValue"
+import { hasProperty } from "./Predicate"
 import { PCGRandom } from "./Utils"
 
 /** @internal */
@@ -98,7 +99,7 @@ export const optimize = (n: number): number => (n & 0xbfffffff) | ((n >>> 1) & 0
  * @since 2.0.0
  * @category guards
  */
-export const isHash = (u: unknown): u is Hash => typeof u === "object" && u !== null && symbol in u
+export const isHash = (u: unknown): u is Hash => hasProperty(u, symbol)
 
 /**
  * @since 2.0.0

package/src/Inspectable.ts

@@ -2,6 +2,8 @@
  * @since 2.0.0
  */
 
+import { hasProperty, isFunction } from "./Predicate"
+
 /**
  * @since 2.0.0
  * @category symbols
@@ -29,7 +31,7 @@ export interface Inspectable {
  */
 export const toJSON = (x: unknown): unknown => {
   if (
-    typeof x === "object" && x !== null && "toJSON" in x && typeof x["toJSON"] === "function" &&
+    hasProperty(x, "toJSON") && isFunction(x["toJSON"]) &&
     x["toJSON"].length === 0
   ) {
     return x.toJSON()

package/src/List.ts

@@ -32,7 +32,7 @@ import * as Option from "./Option"
 import type { Pipeable } from "./Pipeable"
 import { pipeArguments } from "./Pipeable"
 import type { Predicate, Refinement } from "./Predicate"
-import { isObject } from "./Predicate"
+import { hasProperty } from "./Predicate"
 import * as ReadonlyArray from "./ReadonlyArray"
 
 /**
@@ -206,7 +206,7 @@ const _Nil = Object.create(NilProto) as Nil<never>
 export const isList: {
   <A>(u: Iterable<A>): u is List<A>
   (u: unknown): u is List<unknown>
-} = (u: unknown): u is List<unknown> => isObject(u) && TypeId in u
+} = (u: unknown): u is List<unknown> => hasProperty(u, TypeId)
 
 /**
  * Returns `true` if the specified value is a `List.Nil<A>`, `false` otherwise.
@@ -671,8 +671,8 @@ export const flatMap: {
  * @since 2.0.0
  */
 export const flatMapNonEmpty: {
-  <A, B>(f: (a: A, i: number) => Cons<B>): (self: Cons<A>) => Cons<B>
-  <A, B>(self: Cons<A>, f: (a: A, i: number) => Cons<B>): Cons<B>
+  <A, B>(f: (a: A) => Cons<B>): (self: Cons<A>) => Cons<B>
+  <A, B>(self: Cons<A>, f: (a: A) => Cons<B>): Cons<B>
 } = flatMap as any
 
 /**
@@ -734,15 +734,16 @@ export declare namespace List {
 export const map: {
   <T extends List<any>, B>(f: (a: List.Infer<T>, i: number) => B): (self: T) => List.With<T, B>
   <T extends List<any>, B>(self: T, f: (a: List.Infer<T>, i: number) => B): List.With<T, B>
-} = dual(2, <A, B>(self: List<A>, f: (a: A) => B): List<B> => {
+} = dual(2, <A, B>(self: List<A>, f: (a: A, i: number) => B): List<B> => {
   if (isNil(self)) {
     return self as unknown as List<B>
   } else {
-    const head = makeCons(f(self.head), _Nil)
+    let i = 0
+    const head = makeCons(f(self.head, i++), _Nil)
     let nextHead = head
     let rest = self.tail
     while (!isNil(rest)) {
-      const next = makeCons(f(rest.head), _Nil)
+      const next = makeCons(f(rest.head, i++), _Nil)
       nextHead.tail = next
       nextHead = next
       rest = rest.tail

package/src/Predicate.ts

@@ -282,7 +282,25 @@ export const isUnknown: (input: unknown) => input is unknown = (_): _ is unknown
  * @since 2.0.0
  */
 export const isObject = (input: unknown): input is object =>
-  (typeof input === "object" && input != null) || isFunction(input)
+  (typeof input === "object" && input !== null) || isFunction(input)
+
+/**
+ * Checks whether a value is an `object` containing a specified property key.
+ *
+ * @param property - The field to check within the object.
+ * @param self - The value to examine.
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+export const hasProperty: {
+  <P extends PropertyKey>(property: P): (self: unknown) => self is { [K in P]: unknown }
+  <P extends PropertyKey>(self: unknown, property: P): self is { [K in P]: unknown }
+} = dual(
+  2,
+  <P extends PropertyKey>(self: unknown, property: P): self is { [K in P]: unknown } =>
+    isObject(self) && (property in self)
+)
 
 /**
  * Tests if a value is an `object` with a property `_tag` that matches the given tag.
@@ -308,8 +326,7 @@ export const isTagged: {
   <K extends string>(self: unknown, tag: K): self is { _tag: K }
 } = dual(
   2,
-  <K extends string>(self: unknown, tag: K): self is { _tag: K } =>
-    isObject(self) && "_tag" in self && self["_tag"] === tag
+  <K extends string>(self: unknown, tag: K): self is { _tag: K } => hasProperty(self, "_tag") && self["_tag"] === tag
 )
 
 /**
@@ -421,7 +438,7 @@ export const isDate = (input: unknown): input is Date => input instanceof Date
  * @category guards
  * @since 2.0.0
  */
-export const isIterable = (input: unknown): input is Iterable<unknown> => isObject(input) && Symbol.iterator in input
+export const isIterable = (input: unknown): input is Iterable<unknown> => hasProperty(input, Symbol.iterator)
 
 /**
  * A guard that succeeds when the input is a record.

package/src/RequestResolver.ts

@@ -231,7 +231,7 @@ export const fromFunction: <A extends Request.Request<never, any>>(
  * @category constructors
  */
 export const fromFunctionBatched: <A extends Request.Request<never, any>>(
-  f: (chunk: Array<A>) => Array<Request.Request.Success<A>>
+  f: (chunk: Array<A>) => Iterable<Request.Request.Success<A>>
 ) => RequestResolver<A, never> = internal.fromFunctionBatched
 
 /**
@@ -240,9 +240,31 @@ export const fromFunctionBatched: <A extends Request.Request<never, any>>(
  * @since 2.0.0
  * @category constructors
  */
-export const fromFunctionEffect: <R, A extends Request.Request<any, any>>(
+export const fromEffect: <R, A extends Request.Request<any, any>>(
   f: (a: A) => Effect.Effect<R, Request.Request.Error<A>, Request.Request.Success<A>>
-) => RequestResolver<A, R> = internal.fromFunctionEffect
+) => RequestResolver<A, R> = internal.fromEffect
+
+/**
+ * Constructs a data source from a list of tags paired to functions, that takes
+ * a list of requests and returns a list of results of the same size. Each item
+ * in the result list must correspond to the item at the same index in the
+ * request list.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromEffectTagged: <A extends Request.Request<any, any> & { readonly _tag: string }>() => <
+  Fns extends {
+    readonly [Tag in A["_tag"]]: [Extract<A, { readonly _tag: Tag }>] extends [infer Req]
+      ? Req extends Request.Request<infer ReqE, infer ReqA>
+        ? (requests: Array<Req>) => Effect.Effect<any, ReqE, Iterable<ReqA>>
+      : never
+      : never
+  }
+>(
+  fns: Fns
+) => RequestResolver<A, ReturnType<Fns[keyof Fns]> extends Effect.Effect<infer R, infer _E, infer _A> ? R : never> =
+  internal.fromEffectTagged
 
 /**
  * A data source that never executes requests.

package/src/SortedMap.ts

@@ -10,7 +10,7 @@ import * as Option from "./Option"
 import type { Order } from "./Order"
 import type { Pipeable } from "./Pipeable"
 import { pipeArguments } from "./Pipeable"
-import { isObject } from "./Predicate"
+import { hasProperty } from "./Predicate"
 import * as RBT from "./RedBlackTree"
 
 const TypeId: unique symbol = Symbol.for("effect/SortedMap")
@@ -72,7 +72,7 @@ const makeImpl = <K, V>(tree: RBT.RedBlackTree<K, V>): SortedMap<K, V> => {
 export const isSortedMap: {
   <K, V>(u: Iterable<readonly [K, V]>): u is SortedMap<K, V>
   (u: unknown): u is SortedMap<unknown, unknown>
-} = (u: unknown): u is SortedMap<unknown, unknown> => isObject(u) && TypeId in u
+} = (u: unknown): u is SortedMap<unknown, unknown> => hasProperty(u, TypeId)
 
 /**
  * @since 2.0.0

package/src/SortedSet.ts

@@ -11,7 +11,7 @@ import type { Order } from "./Order"
 import type { Pipeable } from "./Pipeable"
 import { pipeArguments } from "./Pipeable"
 import type { Predicate, Refinement } from "./Predicate"
-import { isObject } from "./Predicate"
+import { hasProperty } from "./Predicate"
 import * as RBT from "./RedBlackTree"
 
 const TypeId: unique symbol = Symbol.for("effect/SortedSet")
@@ -77,7 +77,7 @@ const fromTree = <A>(keyTree: RBT.RedBlackTree<A, boolean>): SortedSet<A> => {
 export const isSortedSet: {
   <A>(u: Iterable<A>): u is SortedSet<A>
   (u: unknown): u is SortedSet<unknown>
-} = (u: unknown): u is SortedSet<unknown> => isObject(u) && TypeId in u
+} = (u: unknown): u is SortedSet<unknown> => hasProperty(u, TypeId)
 
 /**
  * @since 2.0.0

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