@fncts/io 0.0.21 → 0.0.23

package/_src/STM/internal/Versioned.ts

@@ -2,6 +2,6 @@ export const VersionedTypeId = Symbol.for("fncts.io.Versioned");
 export type VersionedTypeId = typeof VersionedTypeId;
 
 export class Versioned<A> {
-  readonly _typeId: VersionedTypeId = VersionedTypeId;
+  readonly [VersionedTypeId]: VersionedTypeId = VersionedTypeId;
   constructor(readonly value: A) {}
 }

package/_src/STM.ts

@@ -4,6 +4,7 @@ export * from "./STM/definition.js";
 export * from "./STM/driver.js";
 // codegen:end
 // codegen:start { preset: barrel, include: STM/api/*.ts }
+export * from "./STM/api/atomically.js";
 export * from "./STM/api/core-api.js";
 export * from "./STM/api/core-constructors.js";
 // codegen:end

package/_src/Schedule/api/driver.ts

@@ -15,11 +15,11 @@ export function driver<State, Env, In, Out>(
         const [state1, out, decision] = _(schedule.step(now, inp, state));
         return _(
           decision.match(
-            () => ref.set([Just(out), state1]).apSecond(IO.failNow(Nothing() as Nothing)),
+            () => ref.set([Just(out), state1]).zipRight(IO.failNow(Nothing() as Nothing)),
             (interval) =>
               ref
                 .set([Just(out), state1])
-                .apSecond(Clock.sleep(Duration.fromInterval(now, interval.start)))
+                .zipRight(Clock.sleep(Duration.fromInterval(now, interval.start)))
                 .as(out),
           ),
         );

package/_src/Schedule/api.ts

@@ -18,7 +18,7 @@ export function make<State, Env, In, Out>(
 /**
  * @tsplus pipeable fncts.io.Schedule addDelay
  */
-export function addDelay<Out>(f: (out: Out) => number, __tsplusTrace?: string) {
+export function addDelay<Out>(f: (out: Out) => Duration, __tsplusTrace?: string) {
   return <State, Env, In>(self: Schedule.WithState<State, Env, In, Out>): Schedule.WithState<State, Env, In, Out> => {
     return self.addDelayIO((out) => IO.succeed(f(out)));
   };
@@ -27,7 +27,7 @@ export function addDelay<Out>(f: (out: Out) => number, __tsplusTrace?: string) {
 /**
  * @tsplus pipeable fncts.io.Schedule addDelayIO
  */
-export function addDelayIO<Out, Env1>(f: (out: Out) => URIO<Env1, number>, __tsplusTrace?: string) {
+export function addDelayIO<Out, Env1>(f: (out: Out) => URIO<Env1, Duration>, __tsplusTrace?: string) {
   return <State, Env, In>(
     self: Schedule.WithState<State, Env, In, Out>,
   ): Schedule.WithState<State, Env | Env1, In, Out> => {
@@ -93,6 +93,15 @@ export function as<Out2>(out2: Lazy<Out2>, __tsplusTrace?: string) {
   };
 }
 
+/**
+ * @tsplus getter fncts.io.Schedule asUnit
+ */
+export function asUnit<State, Env, In, Out>(
+  self: Schedule.WithState<State, Env, In, Out>,
+): Schedule.WithState<State, Env, In, void> {
+  return self.as(undefined);
+}
+
 /**
  * @tsplus pipeable fncts.io.Schedule check
  */
@@ -174,16 +183,16 @@ export function contramapIO<I, R1, I2>(f: (inp: I2) => URIO<R1, I>, __tsplusTrac
  * @tsplus static fncts.io.ScheduleOps delayed
  */
 export function delayed<S, R, I>(
-  schedule: Schedule.WithState<S, R, I, number>,
+  schedule: Schedule.WithState<S, R, I, Duration>,
   __tsplusTrace?: string,
-): Schedule.WithState<S, R, I, number> {
+): Schedule.WithState<S, R, I, Duration> {
   return schedule.addDelay((x) => x);
 }
 
 /**
  * @tsplus pipeable fncts.io.Schedule delayed
  */
-export function delayedSelf(f: (delay: number) => number, __tsplusTrace?: string) {
+export function delayedSelf(f: (delay: Duration) => Duration, __tsplusTrace?: string) {
   return <S, R, I, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I, O> => {
     return self.delayedIO((delay) => IO.succeed(f(delay)));
   };
@@ -192,7 +201,7 @@ export function delayedSelf(f: (delay: number) => number, __tsplusTrace?: string
 /**
  * @tsplus pipeable fncts.io.Schedule delayedIO
  */
-export function delayedIO<R1>(f: (delay: number) => URIO<R1, number>, __tsplusTrace?: string) {
+export function delayedIO<R1>(f: (delay: Duration) => URIO<R1, Duration>, __tsplusTrace?: string) {
   return <S, R, I, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R | R1, I, O> => {
     return self.modifyDelayIO((_, delay) => f(delay));
   };
@@ -244,16 +253,16 @@ export function dimapIO<I, O, R1, I2, R2, O2>(
  * @tsplus static fncts.io.ScheduleOps duration
  */
 export function duration(
-  duration: number,
+  duration: Duration,
   __tsplusTrace?: string,
-): Schedule.WithState<boolean, never, unknown, number> {
-  return Schedule<boolean, never, unknown, number>(true, (now, _, state) =>
+): Schedule.WithState<boolean, never, unknown, Duration> {
+  return Schedule<boolean, never, unknown, Duration>(true, (now, _, state) =>
     IO.succeed(() => {
       if (state) {
-        const interval = Interval.after(now + duration);
+        const interval = Interval.after(now + duration.milliseconds);
         return [false, duration, Decision.continueWith(interval)];
       } else {
-        return [false, 0, Decision.Done];
+        return [false, Duration.zero, Decision.Done];
       }
     }),
   );
@@ -287,16 +296,18 @@ export function eitherWith<O, S1, R1, I1, O1, O2>(
 /**
  * @tsplus static fncts.io.ScheduleOps elapsed
  */
-export const elapsed: Schedule.WithState<Maybe<number>, never, unknown, number> = Schedule(Nothing(), (now, _, state) =>
-  IO.succeed(
-    state.match(
-      () => [Just(now), 0, Decision.continueWith(Interval(now, Number.MAX_SAFE_INTEGER))],
-      (start) => {
-        const duration = now - start;
-        return [Just(start), duration, Decision.continueWith(Interval(now, Number.MAX_SAFE_INTEGER))];
-      },
+export const elapsed: Schedule.WithState<Maybe<number>, never, unknown, Duration> = Schedule(
+  Nothing(),
+  (now, _, state) =>
+    IO.succeed(
+      state.match(
+        () => [Just(now), Duration.zero, Decision.continueWith(Interval(now, Number.MAX_SAFE_INTEGER))],
+        (start) => {
+          const duration = Duration.fromInterval(start, now);
+          return [Just(start), duration, Decision.continueWith(Interval(now, Number.MAX_SAFE_INTEGER))];
+        },
+      ),
     ),
-  ),
 );
 
 /**
@@ -319,10 +330,10 @@ export function ensuring(finalizer: UIO<any>, __tsplusTrace?: string) {
  * @tsplus static fncts.io.ScheduleOps exponential
  */
 export function exponential(
-  base: number,
+  base: Duration,
   factor = 2,
   __tsplusTrace?: string,
-): Schedule.WithState<number, never, unknown, number> {
+): Schedule.WithState<number, never, unknown, Duration> {
   return Schedule.delayed(Schedule.forever.map((i) => base * Math.pow(factor, i)));
 }
 
@@ -341,20 +352,21 @@ export function exponential(
  * @tsplus static fncts.io.ScheduleOps fixed
  */
 export function fixed(
-  interval: number,
+  interval: Duration,
   __tsplusTrace?: string,
 ): Schedule.WithState<readonly [Maybe<readonly [number, number]>, number], never, unknown, number> {
+  const intervalMillis = interval.milliseconds;
   return Schedule([Nothing(), 0], (now, inp, [ms, n]) =>
     IO.succeed(
       ms.match(
         () => {
-          const nextRun = now + interval;
+          const nextRun = now + intervalMillis;
           return [[Just([now, nextRun]), n + 1], n, Decision.continueWith(Interval.after(nextRun))];
         },
         ([startMillis, lastRun]) => {
-          const runningBehind = now > lastRun + interval;
-          const boundary      = interval === 0 ? interval : interval - ((now - startMillis) % interval);
-          const sleepTime     = boundary === 0 ? interval : boundary;
+          const runningBehind = now > lastRun + intervalMillis;
+          const boundary      = intervalMillis === 0 ? intervalMillis : intervalMillis - ((now - startMillis) % intervalMillis);
+          const sleepTime     = boundary === 0 ? intervalMillis : boundary;
           const nextRun       = runningBehind ? now : now + sleepTime;
           return [[Just([startMillis, nextRun]), n + 1], n, Decision.continueWith(Interval.after(nextRun))];
         },
@@ -489,7 +501,7 @@ export function intersectWith<S1, R1, I1, O1>(
 /**
  * @tsplus static fncts.io.Schedule linear
  */
-export function linear(base: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number> {
+export function linear(base: Duration, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, Duration> {
   return Schedule.delayed(Schedule.forever.map((i) => base * (i + 1)));
 }
 
@@ -519,7 +531,7 @@ export function mapIO<Out, Env1, Out1>(f: (out: Out) => URIO<Env1, Out1>, __tspl
  * @tsplus pipeable fncts.io.Schedule modifyDelayIO
  */
 export function modifyDelayIO<Out, Env1>(
-  f: (out: Out, duration: number) => URIO<Env1, number>,
+  f: (out: Out, duration: Duration) => URIO<Env1, Duration>,
   __tsplusTrace?: string,
 ) {
   return <State, Env, In>(
@@ -533,7 +545,7 @@ export function modifyDelayIO<Out, Env1>(
             const delay = Interval(now, interval.start).size;
             return f(out, delay).map((duration) => {
               const oldStart    = interval.start;
-              const newStart    = now + duration;
+              const newStart    = now + duration.milliseconds;
               const delta       = newStart - oldStart;
               const newEnd      = interval.end + delta;
               const newInterval = Interval(newStart, newEnd);
@@ -546,6 +558,16 @@ export function modifyDelayIO<Out, Env1>(
   };
 }
 
+/**
+ * @tsplus static fncts.io.ScheduleOps once
+ */
+export const once: Schedule.WithState<number, never, any, void> = Schedule.recurs(1).asUnit;
+
+/**
+ * @tsplus static fncts.io.ScheduleOps asap
+ */
+export const asap = Schedule.once.delayed(() => (0).milliseconds);
+
 /**
  * @tsplus pipeable fncts.io.Schedule onDecision
  */
@@ -615,21 +637,21 @@ export function reconsiderIO<S, O, R1, O1>(
 }
 
 /**
- * @tsplus static fncts.io.Schedule recurs
+ * @tsplus static fncts.io.ScheduleOps recurs
  */
 export function recurs(n: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number> {
   return Schedule.forever.whileOutput((_) => _ < n);
 }
 
 /**
- * @tsplus static fncts.io.Schedule recurWhile
+ * @tsplus static fncts.io.ScheduleOps recurWhile
  */
 export function recurWhile<A>(f: (a: A) => boolean, __tsplusTrace?: string): Schedule.WithState<void, never, A, A> {
   return identity<A>().whileInput(f);
 }
 
 /**
- * @tsplus static fncts.io.Schedule recurWhileIO
+ * @tsplus static fncts.io.ScheduleOps recurWhileIO
  */
 export function recurWhileIO<R, A>(
   f: (a: A) => URIO<R, boolean>,
@@ -682,7 +704,7 @@ export function repetitions<S, R, I, O>(
 /**
  * @tsplus pipeable fncts.io.Schedule resetAfter
  */
-export function resetAfter(duration: number, __tsplusTrace?: string) {
+export function resetAfter(duration: Duration, __tsplusTrace?: string) {
   return <S, R, I, O>(
     self: Schedule.WithState<S, R, I, O>,
   ): Schedule.WithState<readonly [S, Maybe<number>], R, I, O> => {
@@ -732,7 +754,7 @@ export function run<I>(now: number, input: Iterable<I>, __tsplusTrace?: string)
 /**
  * @tsplus static fncts.io.Schedule spaced
  */
-export function spaced(duration: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number> {
+export function spaced(duration: Duration, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number> {
   return Schedule.forever.addDelay(() => duration);
 }
 
@@ -748,7 +770,7 @@ export function succeed<A>(a: Lazy<A>, __tsplusTrace?: string): Schedule.WithSta
  */
 export function tapInput<I, R1>(f: (inp: I) => URIO<R1, any>, __tsplusTrace?: string) {
   return <S, R, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R | R1, I, O> => {
-    return Schedule(self.initial, (now, inp, state) => f(inp).apSecond(self.step(now, inp, state)));
+    return Schedule(self.initial, (now, inp, state) => f(inp).zipRight(self.step(now, inp, state)));
   };
 }
 
@@ -849,9 +871,9 @@ export function untilOutputIO<O, R1>(f: (out: O) => URIO<R1, boolean>, __tsplusT
  * @tsplus static fncts.io.Schedule upTo
  */
 export function upTo(
-  duration: number,
+  duration: Duration,
   __tsplusTrace?: string,
-): Schedule.WithState<Maybe<number>, never, unknown, number> {
+): Schedule.WithState<Maybe<number>, never, unknown, Duration> {
   return Schedule.elapsed.whileOutput((n) => n < duration);
 }
 

package/_src/Schedule/definition.ts

@@ -1,6 +1,9 @@
 import type { Decision } from "./Decision.js";
 import type { Driver as Driver_ } from "./Driver.js";
 
+export const ScheduleVariance = Symbol.for("fncts.io.Schedule.Variance");
+export type ScheduleVariance = typeof ScheduleVariance;
+
 /**
  * A `Schedule<Env, In, Out>` defines a recurring schedule, which consumes
  * values of type `In`, and which returns values of type `Out`.
@@ -32,9 +35,11 @@ import type { Driver as Driver_ } from "./Driver.js";
  * @tsplus companion fncts.io.ScheduleOps
  */
 export abstract class Schedule<Env, In, Out> {
-  readonly _Env!: () => Env;
-  readonly _In!: (_: In) => void;
-  readonly _Out!: () => Out;
+  declare [ScheduleVariance]: {
+    readonly _Env: (_: never) => Env;
+    readonly _In: (_: In) => void;
+    readonly _Out: (_: never) => Out;
+  };
   readonly _State!: unknown;
   abstract readonly initial: this["_State"];
   abstract step(

package/_src/Scope/ReleaseMap/api/releaseAll.ts

@@ -17,9 +17,10 @@ export function releaseAll(exit: Exit<any, any>, execStrategy: ExecutionStrategy
               ([_, f]) => Finalizer.reverseGet(s.update(f))(exit).result,
             ).flatMap((exits) =>
               IO.fromExit(
-                (execStrategy._tag === "Sequential" ? Exit.collectAll(exits) : Exit.collectAllC(exits)).getOrElse(
-                  Exit.succeed(Conc.empty()),
-                ),
+                (execStrategy._tag === "Sequential"
+                  ? Exit.collectAll(exits)
+                  : Exit.collectAllConcurrent(exits)
+                ).getOrElse(Exit.succeed(Conc.empty())),
               ),
             ),
             new Exited(s.nextKey, exit, s.update),

package/_src/Scope/ReleaseMap/constructors.ts

@@ -8,7 +8,7 @@ import { ReleaseMap, Running } from "./definition.js";
  * @tsplus static fncts.io.Scope.ReleaseMapOps unsafeMake
  */
 export function unsafeMake(): ReleaseMap {
-  return ReleaseMap.get(Ref.unsafeMake<State>(new Running(0, HashMap.makeDefault(), identity)));
+  return ReleaseMap.get(Ref.unsafeMake<State>(new Running(0, HashMap.empty(), identity)));
 }
 
 /**

package/_src/Scope/definition.ts

@@ -1,4 +1,4 @@
-export const ScopeTypeId = Symbol.for("fncts.base.control.Scope");
+export const ScopeTypeId = Symbol.for("fncts.io.Scope");
 export type ScopeTypeId = typeof ScopeTypeId;
 
 /**
@@ -6,7 +6,7 @@ export type ScopeTypeId = typeof ScopeTypeId;
  * @tsplus companion fncts.io.ScopeOps
  */
 export abstract class Scope {
-  readonly _typeId: ScopeTypeId = ScopeTypeId;
+  readonly [ScopeTypeId]: ScopeTypeId = ScopeTypeId;
   abstract addFinalizerExit(finalizer: Finalizer): UIO<void>;
   abstract fork: UIO<Scope.Closeable>;
 }

package/_src/ScopedRef/definition.ts

@@ -6,7 +6,7 @@ export type ScopedRefTypeId = typeof ScopedRefTypeId;
  * @tsplus companion fncts.io.ScopedRefOps
  */
 export abstract class ScopedRef<A> {
-  readonly _typeId: ScopedRefTypeId = ScopedRefTypeId;
+  readonly [ScopedRefTypeId]: ScopedRefTypeId = ScopedRefTypeId;
   abstract set<R, E>(acquire: IO<R | Scope, E, A>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, void>;
   abstract get: UIO<A>;
 }

package/_src/Sink/api.ts

@@ -5,9 +5,9 @@ import { MergeDecision } from "../Channel/internal/MergeDecision.js";
 /**
  * Like {@link zip}, but keeps only the result from this sink
  *
- * @tsplus pipeable fncts.io.Sink apFirst
+ * @tsplus pipeable fncts.io.Sink zipLeft
  */
-export function apFirst<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
+export function zipLeft<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
   that: Lazy<Sink<R1, E1, In1, L1, Z1>>,
   __tsplusTrace?: string,
 ) {
@@ -19,9 +19,9 @@ export function apFirst<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
 /**
  * Like {@link zipC}, but keeps only the result from this sink
  *
- * @tsplus pipeable fncts.io.Sink apFirstC
+ * @tsplus pipeable fncts.io.Sink zipLeftC
  */
-export function apFirstC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
+export function zipLeftC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
   that: Lazy<Sink<R1, E1, In1, L1, Z1>>,
   __tsplusTrace?: string,
 ) {
@@ -33,9 +33,9 @@ export function apFirstC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
 /**
  * Like {@link zip}, but keeps only the result from the `that` sink
  *
- * @tsplus pipeable fncts.io.Sink apSecond
+ * @tsplus pipeable fncts.io.Sink zipRight
  */
-export function apSecond<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
+export function zipRight<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
   that: Lazy<Sink<R1, E1, In1, L1, Z1>>,
   __tsplusTrace?: string,
 ) {
@@ -47,9 +47,9 @@ export function apSecond<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
 /**
  * Like {@link zipC}, but keeps only the result from the `that` sink
  *
- * @tsplus pipeable fncts.io.Sink apSecondC
+ * @tsplus pipeable fncts.io.Sink zipRightC
  */
-export function apSecondC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
+export function zipRightC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
   that: Lazy<Sink<R1, E1, In1, L1, Z1>>,
   __tsplusTrace?: string,
 ) {
@@ -338,7 +338,7 @@ export function makeDropWhile<Err, In>(
       if (more) {
         return loop;
       } else {
-        return Channel.writeNow(leftover).apSecond(Channel.id<never, Conc<In>, any>());
+        return Channel.writeNow(leftover).zipRight(Channel.id<never, Conc<In>, any>());
       }
     },
     Channel.failNow,
@@ -591,7 +591,10 @@ function fromPushPull<R, E, In, L, Z>(
  *
  * @tsplus static fncts.io.SinkOps fromQueue
  */
-export function fromQueue<In>(queue: Lazy<Enqueue<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void> {
+export function fromQueue<In>(
+  queue: Lazy<Queue.Enqueue<In>>,
+  __tsplusTrace?: string,
+): Sink<never, never, In, never, void> {
   return Sink.unwrap(IO.succeed(queue).map((queue) => Sink.foreachChunk((inp: Conc<In>) => queue.offerAll(inp))));
 }
 
@@ -602,7 +605,7 @@ export function fromQueue<In>(queue: Lazy<Enqueue<In>>, __tsplusTrace?: string):
  * @tsplus static fncts.io.SinkOps fromQueueWithShutdown
  */
 export function fromQueueWithShutdown<In>(
-  queue: Lazy<Enqueue<In>>,
+  queue: Lazy<Queue.Enqueue<In>>,
   __tsplusTrace?: string,
 ): Sink<never, never, In, never, void> {
   return Sink.unwrapScoped(
@@ -813,7 +816,7 @@ function foreachWhileLoop<R, Err, In>(
   }
   return Channel.fromIO(f(chunk.unsafeGet(idx)))
     .flatMap((b) => (b ? foreachWhileLoop(f, chunk, idx + 1, len, cont) : Channel.writeNow(chunk.drop(idx))))
-    .catchAll((e) => Channel.writeNow(chunk.drop(idx)).apSecond(Channel.failNow(e)));
+    .catchAll((e) => Channel.writeNow(chunk.drop(idx)).zipRight(Channel.failNow(e)));
 }
 
 /**

package/_src/State/api.ts

@@ -6,7 +6,7 @@ import { StateInternal } from "./internal.js";
 /**
  * @tsplus getter fncts.io.State get
  */
-export function get_<S>(self: State<S>, __tsplusTrace?: string): UIO<S> {
+export function get<S>(self: State<S>, __tsplusTrace?: string): UIO<S> {
   concrete(self);
   return self.get;
 }

package/_src/State/definition.ts

@@ -1,5 +1,6 @@
-import type { StateInternal } from "./internal.js";
+import type { StateInternal} from "./internal.js";
 
+import { StateVariance } from "./internal.js";
 import { StateTypeId } from "./internal.js";
 
 /**
@@ -7,8 +8,10 @@ import { StateTypeId } from "./internal.js";
  * @tsplus companion fncts.io.StateOps
  */
 export abstract class State<S> {
-  readonly _A!: () => S;
-  readonly _typeId: StateTypeId = StateTypeId;
+  readonly [StateTypeId]: StateTypeId = StateTypeId;
+  declare [StateVariance]: {
+    readonly _S: (_: S) => S;
+  };
 }
 
 /**

package/_src/State/internal.ts

@@ -1,9 +1,14 @@
-export const StateTypeId = Symbol.for("fncts.base.control.State");
+export const StateVariance = Symbol.for("fncts.io.State.Variance");
+export type StateVariance = typeof StateVariance;
+
+export const StateTypeId = Symbol.for("fncts.io.State");
 export type StateTypeId = typeof StateTypeId;
 
 export abstract class StateInternal<S> {
-  declare _A: () => S;
-  readonly _typeId: StateTypeId = StateTypeId;
+  readonly [StateTypeId]: StateTypeId = StateTypeId;
+  declare [StateVariance]: {
+    readonly _S: (_: S) => S;
+  };
   abstract get: UIO<S>;
   abstract set(s: S, __tsplusTrace?: string): UIO<void>;
   abstract update(f: (s: S) => S, __tsplusTrace?: string): UIO<void>;

package/_src/Stream/api/zipAllWith.ts

@@ -62,7 +62,7 @@ function pull<R, E, A, R1, E1, B, C, D, F>(
         (rightChunk) => IO.succeedNow(Exit.succeed(tuple(rightChunk.map(right), new DrainRight()))),
       );
     case "PullBoth":
-      return pullLeft.unjust.zipC(pullRight.unjust).matchIO(
+      return pullLeft.unjust.zipConcurrent(pullRight.unjust).matchIO(
         (err) => IO.succeedNow(Exit.fail(Just(err))),
         ([maybeLeftChunk, maybeRightChunk]) =>
           maybeLeftChunk.match(

package/_src/Stream/api/zipWithChunks.ts

@@ -23,7 +23,7 @@ function pull<R, E, A1, R1, E1, A2, A3>(
 ): IO<R | R1, never, Exit<Maybe<E | E1>, readonly [Conc<A3>, State<A1, A2>]>> {
   switch (state._tag) {
     case "PullBoth":
-      return pullLeft.zipC(pullRight).matchIO(
+      return pullLeft.zipConcurrent(pullRight).matchIO(
         (err) => IO.succeedNow(Exit.fail(err)),
         ([leftChunk, rightChunk]) => {
           if (leftChunk.isEmpty && rightChunk.isEmpty) {