@fncts/io 0.0.13 → 0.0.16

package/_src/TFuture/api.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus fluent fncts.io.TFuture done
  */
-export function done_<E, A>(self: TFuture<E, A>, v: Either<E, A>): USTM<boolean> {
+export function done_<E, A>(self: TFuture<E, A>, v: Either<E, A>, __tsplusTrace?: string): USTM<boolean> {
   return TFuture.reverseGet(self).get.flatMap((mea) =>
     mea.match(
       () =>
@@ -16,27 +16,27 @@ export function done_<E, A>(self: TFuture<E, A>, v: Either<E, A>): USTM<boolean>
 /**
  * @tsplus fluent fncts.io.TFuture fail
  */
-export function fail_<E, A>(self: TFuture<E, A>, e: E): USTM<boolean> {
+export function fail_<E, A>(self: TFuture<E, A>, e: E, __tsplusTrace?: string): USTM<boolean> {
   return self.done(Either.left(e));
 }
 
 /**
  * @tsplus getter fncts.io.TFuture poll
  */
-export function poll<E, A>(self: TFuture<E, A>): USTM<Maybe<Either<E, A>>> {
+export function poll<E, A>(self: TFuture<E, A>, __tsplusTrace?: string): USTM<Maybe<Either<E, A>>> {
   return TFuture.reverseGet(self).get;
 }
 
 /**
  * @tsplus fluent fncts.io.TFuture succeed
  */
-export function succeed_<E, A>(self: TFuture<E, A>, a: A): USTM<boolean> {
+export function succeed_<E, A>(self: TFuture<E, A>, a: A, __tsplusTrace?: string): USTM<boolean> {
   return self.done(Either.right(a));
 }
 
 /**
  * @tsplus getter fncts.io.TFuture await
  */
-export function wait<E, A>(self: TFuture<E, A>): STM<never, E, A> {
+export function wait<E, A>(self: TFuture<E, A>, __tsplusTrace?: string): STM<never, E, A> {
   return TFuture.reverseGet(self).get.filterMapSTM((mea) => mea.map(STM.fromEitherNow));
 }

package/_src/TFuture/constructors.ts

@@ -2,13 +2,13 @@
  * @tsplus static fncts.io.TFutureOps make
  * @tsplus static fncts.io.TFutureOps __call
  */
-export function make<E, A>(): USTM<TFuture<E, A>> {
+export function make<E, A>(__tsplusTrace?: string): USTM<TFuture<E, A>> {
   return TRef.make<Maybe<Either<E, A>>>(Nothing()).map((_) => TFuture.get(_));
 }
 
 /**
  * @tsplus static fncts.io.TFutureOps makeCommit
  */
-export function makeCommit<E, A>(): UIO<TFuture<E, A>> {
+export function makeCommit<E, A>(__tsplusTrace?: string): UIO<TFuture<E, A>> {
   return TFuture.make<E, A>().commit;
 }

package/_src/TReentrantLock/api.ts

@@ -12,7 +12,7 @@ export const emptyReadLock: ReadLock = new ReadLock(HashMap.makeDefault());
 /**
  * @tsplus static fncts.io.TReentrantLock.ReadLockOps __call
  */
-export function makeReadLock(fiberId: FiberId, count: number): ReadLock {
+export function makeReadLock(fiberId: FiberId, count: number, __tsplusTrace?: string): ReadLock {
   return count <= 0 ? ReadLock.empty : new ReadLock(HashMap.makeDefault<FiberId, number>().set(fiberId, count));
 }
 
@@ -20,21 +20,21 @@ export function makeReadLock(fiberId: FiberId, count: number): ReadLock {
  * @tsplus static fncts.io.TReentrantLockOps make
  * @tsplus static fncts.io.TReentrantLockOps __call
  */
-export function make(): USTM<TReentrantLock> {
+export function make(__tsplusTrace?: string): USTM<TReentrantLock> {
   return TRef.make<LockState>(new ReadLock(HashMap.makeDefault())).map((ref) => new TReentrantLock(ref));
 }
 
 /**
  * @tsplus getter fncts.io.TReentrantLock acquireRead
  */
-export function acquireRead(self: TReentrantLock): USTM<number> {
+export function acquireRead(self: TReentrantLock, __tsplusTrace?: string): USTM<number> {
   return adjustRead(self, 1);
 }
 
 /**
  * @tsplus getter fncts.io.TReentrantLock acquireWrite
  */
-export function acquireWrite(self: TReentrantLock): USTM<number> {
+export function acquireWrite(self: TReentrantLock, __tsplusTrace?: string): USTM<number> {
   return STM.Effect((journal, fiberId, _) => {
     const lockState = self.data.unsafeGet(journal);
     switch (lockState._tag) {
@@ -59,14 +59,14 @@ export function acquireWrite(self: TReentrantLock): USTM<number> {
 /**
  * @tsplus getter fncts.io.TReentrantLock releaseRead
  */
-export function releaseRead(self: TReentrantLock): USTM<number> {
+export function releaseRead(self: TReentrantLock, __tsplusTrace?: string): USTM<number> {
   return adjustRead(self, -1);
 }
 
 /**
  * @tsplus getter fncts.io.TReentrantLock releaseWrite
  */
-export function releaseWrite(self: TReentrantLock): USTM<number> {
+export function releaseWrite(self: TReentrantLock, __tsplusTrace?: string): USTM<number> {
   return STM.Effect((journal, fiberId) => {
     const lockState: LockState = self.data.unsafeGet(journal);
     let res: LockState | undefined;
@@ -89,7 +89,7 @@ export function releaseWrite(self: TReentrantLock): USTM<number> {
 /**
  * @tsplus fluent fncts.io.TReentrantLock withReadLock
  */
-export function withReadLock<R, E, A>(self: TReentrantLock, io: IO<R, E, A>): IO<R, E, A> {
+export function withReadLock<R, E, A>(self: TReentrantLock, io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return IO.uninterruptibleMask(
     ({ restore }) => restore(self.acquireRead.commit) > restore(io).ensuring(self.releaseRead.commit),
   );
@@ -98,7 +98,7 @@ export function withReadLock<R, E, A>(self: TReentrantLock, io: IO<R, E, A>): IO
 /**
  * @tsplus fluent fncts.io.TReentrantLock withWriteLock
  */
-export function withWriteLock<R, E, A>(self: TReentrantLock, io: IO<R, E, A>): IO<R, E, A> {
+export function withWriteLock<R, E, A>(self: TReentrantLock, io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return IO.uninterruptibleMask(
     ({ restore }) => restore(self.acquireWrite.commit) > restore(io).ensuring(self.releaseWrite.commit),
   );
@@ -121,53 +121,53 @@ export function writeLock(self: TReentrantLock, __tsplusTrace?: string): IO<Scop
 /**
  * @tsplus getter fncts.io.TReentrantLock readLocked
  */
-export function readLocked(self: TReentrantLock): USTM<boolean> {
+export function readLocked(self: TReentrantLock, __tsplusTrace?: string): USTM<boolean> {
   return self.data.get.map((state) => state.readLocks > 0);
 }
 
 /**
  * @tsplus getter fncts.io.TReentrantLock writeLocked
  */
-export function writeLocked(self: TReentrantLock): USTM<boolean> {
+export function writeLocked(self: TReentrantLock, __tsplusTrace?: string): USTM<boolean> {
   return self.data.get.map((state) => state.writeLocks > 0);
 }
 
 /**
  * @tsplus getter fncts.io.TReentrantLock locked
  */
-export function locked(self: TReentrantLock): USTM<boolean> {
+export function locked(self: TReentrantLock, __tsplusTrace?: string): USTM<boolean> {
   return self.readLocked.zipWith(self.writeLocked, (a, b) => a || b);
 }
 
 /**
  * @tsplus getter fncts.io.TReentrantLock fiberReadLocks
  */
-export function fiberReadLocks(self: TReentrantLock): USTM<number> {
+export function fiberReadLocks(self: TReentrantLock, __tsplusTrace?: string): USTM<number> {
   return STM.Effect((journal, fiberId) => self.data.unsafeGet(journal).readLocksHeld(fiberId));
 }
 
 /**
  * @tsplus getter fncts.io.TReentrantLock fiberWriteLocks
  */
-export function fiberWriteLocks(self: TReentrantLock): USTM<number> {
+export function fiberWriteLocks(self: TReentrantLock, __tsplusTrace?: string): USTM<number> {
   return STM.Effect((journal, fiberId) => self.data.unsafeGet(journal).writeLocksHeld(fiberId));
 }
 
 /**
  * @tsplus getter fncts.io.TReentrantLock writeLocks
  */
-export function writeLocks(self: TReentrantLock): USTM<number> {
+export function writeLocks(self: TReentrantLock, __tsplusTrace?: string): USTM<number> {
   return self.data.get.map((state) => state.writeLocks);
 }
 
 /**
  * @tsplus getter fncts.io.TReentrantLock readLocks
  */
-export function readLocks(self: TReentrantLock): USTM<number> {
+export function readLocks(self: TReentrantLock, __tsplusTrace?: string): USTM<number> {
   return self.data.get.map((state) => state.readLocks);
 }
 
-function adjustRead(self: TReentrantLock, delta: number): USTM<number> {
+function adjustRead(self: TReentrantLock, delta: number, __tsplusTrace?: string): USTM<number> {
   return STM.Effect((journal, fiberId, _) => {
     const lockState = self.data.unsafeGet(journal);
     switch (lockState._tag) {

package/_src/TRef/api.ts

@@ -5,7 +5,7 @@ import { Effect } from "../STM/definition.js";
 import { Entry } from "../STM/internal/Entry.js";
 import { concrete } from "../TRef/definition.js";
 
-function getOrMakeEntry<A>(self: Atomic<A>, journal: Journal): Entry {
+function getOrMakeEntry<A>(self: Atomic<A>, journal: Journal, __tsplusTrace?: string): Entry {
   if (journal.has(self)) {
     return journal.get(self)!;
   }
@@ -19,7 +19,7 @@ function getOrMakeEntry<A>(self: Atomic<A>, journal: Journal): Entry {
  *
  * @tsplus getter fncts.io.TRef get
  */
-export function get<EA, EB, A, B>(self: TRef<EA, EB, A, B>): STM<never, EB, B> {
+export function get<EA, EB, A, B>(self: TRef<EA, EB, A, B>, __tsplusTrace?: string): STM<never, EB, B> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -47,7 +47,11 @@ export function get<EA, EB, A, B>(self: TRef<EA, EB, A, B>): STM<never, EB, B> {
  *
  * @tsplus fluent fncts.io.TRef modify
  */
-export function modify_<E, A, B>(self: TRef<E, E, A, A>, f: (a: A) => readonly [B, A]): STM<never, E, B> {
+export function modify_<E, A, B>(
+  self: TRef<E, E, A, A>,
+  f: (a: A) => readonly [B, A],
+  __tsplusTrace?: string,
+): STM<never, E, B> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -99,7 +103,7 @@ export function modify_<E, A, B>(self: TRef<E, E, A, A>, f: (a: A) => readonly [
  *
  * @tsplus fluent fncts.io.TRef set
  */
-export function set_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, a: A): STM<never, EA, void> {
+export function set_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, a: A, __tsplusTrace?: string): STM<never, EA, void> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -131,7 +135,7 @@ export function set_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, a: A): STM<never, E
  *
  * @tsplus fluent fncts.io.TRef unsafeGet
  */
-export function unsafeGet_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, journal: Journal): A {
+export function unsafeGet_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, journal: Journal, __tsplusTrace?: string): A {
   concrete(self);
   switch (self._tag) {
     case "Atomic":
@@ -153,6 +157,7 @@ export function modifyJust_<E, A, B>(
   self: TRef<E, E, A, A>,
   b: B,
   f: (a: A) => Maybe<readonly [B, A]>,
+  __tsplusTrace?: string,
 ): STM<never, E, B> {
   return self.modify((a) => f(a).getOrElse([b, a]));
 }
@@ -162,7 +167,7 @@ export function modifyJust_<E, A, B>(
  *
  * @tsplus fluent fncts.io.TRef getAndSet
  */
-export function getAndSet_<E, A>(self: TRef<E, E, A, A>, a: A): STM<never, E, A> {
+export function getAndSet_<E, A>(self: TRef<E, E, A, A>, a: A, __tsplusTrace?: string): STM<never, E, A> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -184,7 +189,7 @@ export function getAndSet_<E, A>(self: TRef<E, E, A, A>, a: A): STM<never, E, A>
  *
  * @tsplus fluent fncts.io.TRef getAndUpdate
  */
-export function getAndUpdate_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM<never, E, A> {
+export function getAndUpdate_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A, __tsplusTrace?: string): STM<never, E, A> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -207,7 +212,11 @@ export function getAndUpdate_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM
  *
  * @tsplus fluent fncts.io.TRef getAndUpdateJust
  */
-export function getAndUpdateJust_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>): STM<never, E, A> {
+export function getAndUpdateJust_<E, A>(
+  self: TRef<E, E, A, A>,
+  f: (a: A) => Maybe<A>,
+  __tsplusTrace?: string,
+): STM<never, E, A> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -237,7 +246,7 @@ export function getAndUpdateJust_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => May
  *
  * @tsplus fluent fncts.io.TRef update
  */
-export function update_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM<never, E, void> {
+export function update_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A, __tsplusTrace?: string): STM<never, E, void> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -257,7 +266,11 @@ export function update_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM<never
  *
  * @tsplus fluent fncts.io.TRef updateJust
  */
-export function updateJust_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>): STM<never, E, void> {
+export function updateJust_<E, A>(
+  self: TRef<E, E, A, A>,
+  f: (a: A) => Maybe<A>,
+  __tsplusTrace?: string,
+): STM<never, E, void> {
   return self.update((a) => f(a).getOrElse(a));
 }
 
@@ -266,7 +279,7 @@ export function updateJust_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>)
  *
  * @tsplus fluent fncts.io.TRef updateAndGet
  */
-export function updateAndGet_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM<never, E, A> {
+export function updateAndGet_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A, __tsplusTrace?: string): STM<never, E, A> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -292,14 +305,23 @@ export function updateAndGet_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM
  *
  * @tsplus fluent fncts.io.TRef updateJustAndGet
  */
-export function updateJustAndGet_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>): STM<never, E, A> {
+export function updateJustAndGet_<E, A>(
+  self: TRef<E, E, A, A>,
+  f: (a: A) => Maybe<A>,
+  __tsplusTrace?: string,
+): STM<never, E, A> {
   return self.updateAndGet((a) => f(a).getOrElse(a));
 }
 
 /**
  * @tsplus fluent fncts.io.TRef unsafeSet
  */
-export function unsafeSet_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, journal: Journal, a: A): void {
+export function unsafeSet_<EA, EB, A, B>(
+  self: TRef<EA, EB, A, B>,
+  journal: Journal,
+  a: A,
+  __tsplusTrace?: string,
+): void {
   concrete(self);
   switch (self._tag) {
     case "Atomic":

package/_src/TRef/constructors.ts

@@ -13,7 +13,7 @@ import { Atomic } from "./definition.js";
  *
  * @tsplus static fncts.io.TRefOps makeNow
  */
-export function makeNow<A>(a: A): STM<never, never, UTRef<A>> {
+export function makeNow<A>(a: A, __tsplusTrace?: string): STM<never, never, UTRef<A>> {
   return new Effect((journal) => {
     const value     = a;
     const versioned = new Versioned(value);
@@ -29,7 +29,7 @@ export function makeNow<A>(a: A): STM<never, never, UTRef<A>> {
  *
  * @tsplus static fncts.io.TRefOps make
  */
-export function make<A>(a: Lazy<A>): STM<never, never, UTRef<A>> {
+export function make<A>(a: Lazy<A>, __tsplusTrace?: string): STM<never, never, UTRef<A>> {
   return new Effect((journal) => {
     const value     = a();
     const versioned = new Versioned(value);
@@ -57,13 +57,13 @@ export function unsafeMake<A>(a: A): UTRef<A> {
  *
  * @tsplus static fncts.io.TRefOps makeCommit
  */
-export function makeCommit<A>(a: Lazy<A>): UIO<UTRef<A>> {
+export function makeCommit<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<UTRef<A>> {
   return make(a).commit;
 }
 
 /**
  * Makes a new `TRef` that is initialized to the specified value.
  */
-export function makeCommitNow<A>(a: A): UIO<UTRef<A>> {
+export function makeCommitNow<A>(a: A, __tsplusTrace?: string): UIO<UTRef<A>> {
   return makeNow(a).commit;
 }

package/_src/TSemaphore/api.ts

@@ -5,14 +5,14 @@ import { Effect, RetryException } from "../STM/definition.js";
 /**
  * @tsplus getter fncts.io.TSemaphore acquire
  */
-export function acquire(self: TSemaphore): USTM<void> {
+export function acquire(self: TSemaphore, __tsplusTrace?: string): USTM<void> {
   return self.acquireN(1);
 }
 
 /**
  * @tsplus fluent fncts.io.TSemaphore acquireN
  */
-export function acquireN_(self: TSemaphore, n: number): USTM<void> {
+export function acquireN_(self: TSemaphore, n: number, __tsplusTrace?: string): USTM<void> {
   return new Effect((journal) => {
     assert(n >= 0, "Negative permits given to TSemaphore#acquire");
 
@@ -26,21 +26,21 @@ export function acquireN_(self: TSemaphore, n: number): USTM<void> {
 /**
  * @tsplus getter fncts.io.TSemaphore available
  */
-export function available(self: TSemaphore): USTM<number> {
+export function available(self: TSemaphore, __tsplusTrace?: string): USTM<number> {
   return TSemaphore.reverseGet(self).get;
 }
 
 /**
  * @tsplus getter fncts.io.TSemaphore release
  */
-export function release(self: TSemaphore): USTM<void> {
+export function release(self: TSemaphore, __tsplusTrace?: string): USTM<void> {
   return self.releaseN(1);
 }
 
 /**
  * @tsplus fluent fncts.io.TSemaphore releaseN
  */
-export function releaseN_(self: TSemaphore, n: number): USTM<void> {
+export function releaseN_(self: TSemaphore, n: number, __tsplusTrace?: string): USTM<void> {
   return new Effect((journal) => {
     assert(n >= 0, "Negative permits given to TSemaphore#releaseN");
 
@@ -52,7 +52,7 @@ export function releaseN_(self: TSemaphore, n: number): USTM<void> {
 /**
  * @tsplus getter fncts.io.TSemaphore withPermits
  */
-export function withPermits(self: TSemaphore) {
+export function withPermits(self: TSemaphore, __tsplusTrace?: string) {
   return (n: number) =>
     <R, E, A>(io: IO<R, E, A>) =>
       IO.uninterruptibleMask(({ restore }) =>
@@ -63,6 +63,6 @@ export function withPermits(self: TSemaphore) {
 /**
  * @tsplus getter fncts.io.TSemaphore withPermit
  */
-export function withPermit(self: TSemaphore) {
+export function withPermit(self: TSemaphore, __tsplusTrace?: string) {
   return <R, E, A>(io: IO<R, E, A>) => self.withPermits(1)(io);
 }

package/_src/TSemaphore/constructors.ts

@@ -2,7 +2,7 @@
  * @tsplus static fncts.io.TSemaphoreOps __call
  * @tsplus static fncts.io.TSemaphoreOps make
  */
-export function make(permits: number): USTM<TSemaphore> {
+export function make(permits: number, __tsplusTrace?: string): USTM<TSemaphore> {
   return TRef.make(permits).map((ref) => TSemaphore.get(ref));
 }
 

package/_src/collection/immutable/Conc/filterIO.ts

@@ -1,7 +1,11 @@
 /**
  * @tsplus fluent fncts.Conc filterIO
  */
-export function filterIO<A, R, E>(self: Conc<A>, p: (a: A) => IO<R, E, boolean>): IO<R, E, Conc<A>> {
+export function filterIO<A, R, E>(
+  self: Conc<A>,
+  p: (a: A) => IO<R, E, boolean>,
+  __tsplusTrace?: string,
+): IO<R, E, Conc<A>> {
   return IO.defer(() => {
     const builder = new ConcBuilder<A>();
     let dest: IO<R, E, ConcBuilder<A>> = IO.succeedNow(builder);

package/_src/collection/immutable/Conc/findIO.ts

@@ -6,6 +6,7 @@ function findIOLoop_<R, E, A>(
   array: ArrayLike<A>,
   i: number,
   length: number,
+  __tsplusTrace?: string,
 ): IO<R, E, Maybe<A>> {
   if (i < length) {
     const a = array[i]!;
@@ -23,7 +24,11 @@ function findIOLoop_<R, E, A>(
 /**
  * @tsplus fluent fncts.Conc findIO
  */
-export function findIO_<R, E, A>(as: Conc<A>, f: (a: A) => IO<R, E, boolean>): IO<R, E, Maybe<A>> {
+export function findIO_<R, E, A>(
+  as: Conc<A>,
+  f: (a: A) => IO<R, E, boolean>,
+  __tsplusTrace?: string,
+): IO<R, E, Maybe<A>> {
   concrete(as);
   const iterator = as.arrayIterator();
   let result;

package/_src/collection/immutable/Conc/mapIO.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus fluent fncts.Conc mapIO
  */
-export function mapIO_<A, R, E, B>(as: Conc<A>, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>> {
+export function mapIO_<A, R, E, B>(as: Conc<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<B>> {
   return IO.defer(() => {
     const out = Conc.builder<B>();
     return IO.foreachDiscard(as, (a) =>

package/_src/collection/immutable/Conc/takeWhileIO.ts

@@ -3,7 +3,11 @@ import { concrete } from "@fncts/base/collection/immutable/Conc";
 /**
  * @tsplus fluent fncts.Conc takeWhileIO
  */
-export function takeWhileIO_<A, R, E>(as: Conc<A>, p: (a: A) => IO<R, E, boolean>): IO<R, E, Conc<A>> {
+export function takeWhileIO_<A, R, E>(
+  as: Conc<A>,
+  p: (a: A) => IO<R, E, boolean>,
+  __tsplusTrace?: string,
+): IO<R, E, Conc<A>> {
   return IO.defer(() => {
     concrete(as);
     let taking: IO<R, E, boolean> = IO.succeedNow(true);

package/_src/collection/immutable/Conc.ts

@@ -1,4 +1,6 @@
 // codegen:start { preset: barrel, include: ./Conc/*.ts }
+export * from "./Conc/dropUntilIO.js";
+export * from "./Conc/dropWhileIO.js";
 export * from "./Conc/filterIO.js";
 export * from "./Conc/findIO.js";
 export * from "./Conc/mapIO.js";

package/_src/data/Exit/foreachIO.ts

@@ -7,6 +7,7 @@
 export function foreachIO_<E2, A2, R, E, A>(
   exit: Exit<E2, A2>,
   f: (a: A2) => IO<R, E, A>,
+  __tsplusTrace?: string,
 ): IO<R, never, Exit<E | E2, A>> {
   return exit.match(
     (c): URIO<R, Exit<E | E2, A>> => IO.succeedNow(Exit.failCause(c)),

package/_src/global.ts

@@ -0,0 +1,149 @@
+/**
+ * @tsplus global
+ */
+import type {} from "@fncts/base/global";
+/**
+ * @tsplus global
+ */
+import type {} from "@fncts/io";
+
+/**
+ * @tsplus global
+ */
+import { hasTypeId, isByte, isObject } from "@fncts/base/util/predicates";
+/**
+ * @tsplus global
+ */
+import { Cached } from "@fncts/io/Cached/definition";
+/**
+ * @tsplus global
+ */
+import { Channel } from "@fncts/io/Channel";
+/**
+ * @tsplus global
+ */
+import { Clock } from "@fncts/io/Clock/definition";
+/**
+ * @tsplus global
+ */
+import { Console } from "@fncts/io/Console/definition";
+/**
+ * @tsplus global
+ */
+import { Fiber } from "@fncts/io/Fiber/definition";
+/**
+ * @tsplus global
+ */
+import { FiberDescriptor } from "@fncts/io/FiberDescriptor";
+/**
+ * @tsplus global
+ */
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+/**
+ * @tsplus global
+ */
+import { FiberRefs } from "@fncts/io/FiberRefs";
+/**
+ * @tsplus global
+ */
+import { FiberScope } from "@fncts/io/FiberScope";
+/**
+ * @tsplus global
+ */
+import { Future } from "@fncts/io/Future";
+/**
+ * @tsplus global
+ */
+import { Hub, PHub } from "@fncts/io/Hub/definition";
+/**
+ * @tsplus global
+ */
+import { InterruptStatus } from "@fncts/io/InterruptStatus";
+/**
+ * @tsplus global
+ */
+import { FIO, IO, UIO, URIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus global
+ */
+import { IOEnv } from "@fncts/io/IOEnv";
+/**
+ * @tsplus global
+ */
+import { Layer } from "@fncts/io/Layer";
+/**
+ * @tsplus global
+ */
+import { Logger } from "@fncts/io/Logger/definition";
+/**
+ * @tsplus global
+ */
+import { LogLevel } from "@fncts/io/LogLevel";
+/**
+ * @tsplus global
+ */
+import { PQueue, Queue } from "@fncts/io/Queue/definition";
+/**
+ * @tsplus global
+ */
+import { Random } from "@fncts/io/Random/definition";
+/**
+ * @tsplus global
+ */
+import { PRef, Ref } from "@fncts/io/Ref";
+/**
+ * @tsplus global
+ */
+import { RuntimeConfig, RuntimeConfigFlag, RuntimeConfigFlags } from "@fncts/io/RuntimeConfig";
+/**
+ * @tsplus global
+ */
+import { Schedule } from "@fncts/io/Schedule/definition";
+/**
+ * @tsplus global
+ */
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @tsplus global
+ */
+import { Finalizer } from "@fncts/io/Scope/Finalizer";
+/**
+ * @tsplus global
+ */
+import { ScopedRef } from "@fncts/io/ScopedRef/definition";
+/**
+ * @tsplus global
+ */
+import { Sink } from "@fncts/io/Sink/definition";
+/**
+ * @tsplus global
+ */
+import { STM, USTM } from "@fncts/io/STM/definition";
+/**
+ * @tsplus global
+ */
+import { Stream } from "@fncts/io/Stream/definition";
+/**
+ * @tsplus global
+ */
+import { Supervisor } from "@fncts/io/Supervisor/definition";
+/**
+ * @tsplus global
+ */
+import { TExit } from "@fncts/io/TExit/definition";
+/**
+ * @tsplus global
+ */
+import { TFuture } from "@fncts/io/TFuture/definition";
+/**
+ * @tsplus global
+ */
+import { TRef, UTRef } from "@fncts/io/TRef/definition";
+/**
+ * @tsplus global
+ */
+import { TSemaphore } from "@fncts/io/TSemaphore/definition";
+/**
+ * @tsplus global
+ */
+import { HKT } from "@fncts/typelevel/HKT";