@fncts/io 0.0.13 → 0.0.16

package/_src/Fiber/api/inheritRefs.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus getter fncts.io.Fiber inheritRefs
  */
-export function inheritRefs<E, A>(fiber: Fiber<E, A>): UIO<void> {
+export function inheritRefs<E, A>(fiber: Fiber<E, A>, __tsplusTrace?: string): UIO<void> {
   fiber.concrete();
   return fiber.inheritRefs;
 }

package/_src/Fiber/api/interrupt.ts

@@ -5,7 +5,7 @@
  *
  * @tsplus getter fncts.io.Fiber interrupt
  */
-export function interrupt<E, A>(fiber: Fiber<E, A>): UIO<Exit<E, A>> {
+export function interrupt<E, A>(fiber: Fiber<E, A>, __tsplusTrace?: string): UIO<Exit<E, A>> {
   fiber.concrete();
   return IO.fiberId.flatMap((id) => fiber.interruptAs(id));
 }

package/_src/Fiber/api/interruptAll.ts

@@ -3,7 +3,7 @@
  *
  * @tsplus static fncts.io.FiberOps interruptAllAs
  */
-export function interruptAllAs_(fs: Iterable<Fiber<any, any>>, id: FiberId): UIO<void> {
+export function interruptAllAs_(fs: Iterable<Fiber<any, any>>, id: FiberId, __tsplusTrace?: string): UIO<void> {
   return fs.foldLeft(IO.unit, (io, f) => io.flatMap(() => f.interruptAs(id).asUnit));
 }
 
@@ -12,6 +12,6 @@ export function interruptAllAs_(fs: Iterable<Fiber<any, any>>, id: FiberId): UIO
  *
  * @tsplus static fncts.io.FiberOps interruptAll
  */
-export function interruptAll(fs: Iterable<Fiber<any, any>>): UIO<void> {
+export function interruptAll(fs: Iterable<Fiber<any, any>>, __tsplusTrace?: string): UIO<void> {
   return IO.fiberId.flatMap((id) => Fiber.interruptAllAs(fs, id));
 }

package/_src/Fiber/api/interruptAs.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus fluent fncts.io.Fiber interruptAs
  */
-export function interruptAs<E, A>(self: Fiber<E, A>, fiberId: FiberId): UIO<Exit<E, A>> {
+export function interruptAs<E, A>(self: Fiber<E, A>, fiberId: FiberId, __tsplusTrace?: string): UIO<Exit<E, A>> {
   self.concrete();
   return self.interruptAs(fiberId);
 }

package/_src/Fiber/api/join.ts

@@ -7,7 +7,7 @@
  *
  * @tsplus getter fncts.io.Fiber join
  */
-export function join<E, A>(fiber: Fiber<E, A>): FIO<E, A> {
+export function join<E, A>(fiber: Fiber<E, A>, __tsplusTrace?: string): FIO<E, A> {
   fiber.concrete();
   return fiber.await.flatMap(IO.fromExitNow).tap(() => fiber.inheritRefs);
 }

package/_src/Fiber/api/joinAll.ts

@@ -5,7 +5,7 @@
  *
  * @tsplus static fncts.io.FiberOps joinAll
  */
-export function joinAll<E, A>(as: Iterable<Fiber<E, A>>): IO<never, E, Conc<A>> {
+export function joinAll<E, A>(as: Iterable<Fiber<E, A>>, __tsplusTrace?: string): IO<never, E, Conc<A>> {
   return Fiber.awaitAll(as)
     .flatMap(IO.fromExitNow)
     .tap(() => IO.foreach(as, (f) => f.inheritRefs));

package/_src/Fiber/api/mapFiber.ts

@@ -4,6 +4,10 @@
  *
  * @tsplus fluent fncts.io.Fiber mapFiber
  */
-export function mapFiber_<A, E, E1, A1>(fiber: Fiber<E, A>, f: (a: A) => Fiber<E1, A1>): UIO<Fiber<E | E1, A1>> {
+export function mapFiber_<A, E, E1, A1>(
+  fiber: Fiber<E, A>,
+  f: (a: A) => Fiber<E1, A1>,
+  __tsplusTrace?: string,
+): UIO<Fiber<E | E1, A1>> {
   return fiber.await.map((exit) => exit.match(Fiber.failCause, f));
 }

package/_src/Fiber/api/mapIO.ts

@@ -5,7 +5,11 @@ import { SyntheticFiber } from "@fncts/io/Fiber/definition";
  *
  * @tsplus fluent fncts.io.Fiber mapIO
  */
-export function mapIO_<E, E1, A, B>(fiber: Fiber<E, A>, f: (a: A) => FIO<E1, B>): Fiber<E | E1, B> {
+export function mapIO_<E, E1, A, B>(
+  fiber: Fiber<E, A>,
+  f: (a: A) => FIO<E1, B>,
+  __tsplusTrace?: string,
+): Fiber<E | E1, B> {
   return new SyntheticFiber(
     fiber.id,
     fiber.await.flatMap((_) => _.foreachIO(f)),
@@ -26,6 +30,6 @@ export function mapIO_<E, E1, A, B>(fiber: Fiber<E, A>, f: (a: A) => FIO<E1, B>)
  *
  * @tsplus fluent fncts.io.Fiber map
  */
-export function map_<E, A, B>(fa: Fiber<E, A>, f: (a: A) => B): Fiber<E, B> {
+export function map_<E, A, B>(fa: Fiber<E, A>, f: (a: A) => B, __tsplusTrace?: string): Fiber<E, B> {
   return fa.mapIO((a) => IO.succeedNow(f(a)));
 }

package/_src/Fiber/api/poll.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus getter fncts.io.Fiber poll
  */
-export function poll<E, A>(self: Fiber<E, A>): UIO<Maybe<Exit<E, A>>> {
+export function poll<E, A>(self: Fiber<E, A>, __tsplusTrace?: string): UIO<Maybe<Exit<E, A>>> {
   self.concrete();
   return self.poll;
 }

package/_src/Fiber/api/zipWith.ts

@@ -11,6 +11,7 @@ export function zipWith_<E, A, E1, B, C>(
   self: Fiber<E, A>,
   that: Fiber<E1, B>,
   f: (a: A, b: B) => C,
+  __tsplusTrace?: string,
 ): Fiber<E | E1, C> {
   return new SyntheticFiber(
     self.id,

package/_src/Fiber/constructors.ts

@@ -3,7 +3,7 @@ import { SyntheticFiber } from "@fncts/io/Fiber/definition";
 /**
  * @tsplus static fncts.io.FiberOps done
  */
-export function done<E, A>(exit: Exit<E, A>): Fiber<E, A> {
+export function done<E, A>(exit: Exit<E, A>, __tsplusTrace?: string): Fiber<E, A> {
   return new SyntheticFiber(
     FiberId.none,
     IO.succeedNow(exit),
@@ -17,27 +17,27 @@ export function done<E, A>(exit: Exit<E, A>): Fiber<E, A> {
 /**
  * @tsplus static fncts.io.FiberOps fail
  */
-export function fail<E>(e: E): Fiber<E, never> {
+export function fail<E>(e: E, __tsplusTrace?: string): Fiber<E, never> {
   return done(Exit.fail(e));
 }
 
 /**
  * @tsplus static fncts.io.FiberOps failCause
  */
-export function failCause<E>(cause: Cause<E>): Fiber<E, never> {
+export function failCause<E>(cause: Cause<E>, __tsplusTrace?: string): Fiber<E, never> {
   return done(Exit.failCause(cause));
 }
 
 /**
  * @tsplus static fncts.io.FiberOps interruptAs
  */
-export function interrupted(id: FiberId): Fiber<never, never> {
+export function interrupted(id: FiberId, __tsplusTrace?: string): Fiber<never, never> {
   return done(Exit.interrupt(id));
 }
 
 /**
  * @tsplus static fncts.io.FiberOps succeed
  */
-export function succeed<A>(a: A): Fiber<never, A> {
+export function succeed<A>(a: A, __tsplusTrace?: string): Fiber<never, A> {
   return done(Exit.succeed(a));
 }

package/_src/FiberRef/api/locallyScoped.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus fluent fncts.io.FiberRef locallyScoped
  */
-export function locallyScoped_<A>(ref: FiberRef<A>, a: A): IO<Scope, never, void> {
+export function locallyScoped_<A>(ref: FiberRef<A>, a: A, __tsplusTrace?: string): IO<Scope, never, void> {
   return IO.acquireRelease(
     ref.get.flatMap((old) => ref.set(a).as(old)),
     (a) => ref.set(a),

package/_src/FiberRef/api/locallyScopedWith.ts

@@ -1,6 +1,10 @@
 /**
  * @tsplus fluent fncts.io.FiberRef locallyScopedWith
  */
-export function locallyScopedWith<A>(self: FiberRef<A>, f: (a: A) => A): IO<Scope, never, void> {
+export function locallyScopedWith<A>(
+  self: FiberRef<A>,
+  f: (a: A) => A,
+  __tsplusTrace?: string,
+): IO<Scope, never, void> {
   return self.getWith((a) => self.locallyScoped(f(a)));
 }

package/_src/FiberRef/api.ts

@@ -20,35 +20,35 @@ export function update_<A>(fiberRef: FiberRef<A>, f: (a: A) => A, __tsplusTrace?
 /**
  * @tsplus fluent fncts.io.FiberRef set
  */
-export function set_<A>(fiberRef: FiberRef<A>, a: A): UIO<void> {
+export function set_<A>(fiberRef: FiberRef<A>, a: A, __tsplusTrace?: string): UIO<void> {
   return fiberRef.modify(() => [undefined, a]);
 }
 
 /**
  * @tsplus getter fncts.io.FiberRef get
  */
-export function get<A>(fiberRef: FiberRef<A>): UIO<A> {
+export function get<A>(fiberRef: FiberRef<A>, __tsplusTrace?: string): UIO<A> {
   return fiberRef.modify((a) => [a, a]);
 }
 
 /**
  * @tsplus fluent fncts.io.FiberRef getAndSet
  */
-export function getAndSet_<A>(fiberRef: FiberRef<A>, a: A): UIO<A> {
+export function getAndSet_<A>(fiberRef: FiberRef<A>, a: A, __tsplusTrace?: string): UIO<A> {
   return fiberRef.modify((v) => [v, a]);
 }
 
 /**
  * @tsplus fluent fncts.io.FiberRef getAndUpdate
  */
-export function getAndUpdate_<A>(fiberRef: FiberRef<A>, f: (a: A) => A): UIO<A> {
+export function getAndUpdate_<A>(fiberRef: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): UIO<A> {
   return fiberRef.modify((a) => [a, f(a)]);
 }
 
 /**
  * @tsplus fluent fncts.io.FiberRef getAndUpdateJust
  */
-export function getAndUpdateJust_<A>(fiberRef: FiberRef<A>, f: (a: A) => Maybe<A>): UIO<A> {
+export function getAndUpdateJust_<A>(fiberRef: FiberRef<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<A> {
   return fiberRef.modify((a) => [a, f(a).getOrElse(a)]);
 }
 
@@ -59,7 +59,7 @@ export function getAndUpdateJust_<A>(fiberRef: FiberRef<A>, f: (a: A) => Maybe<A
  *
  * @tsplus fluent fncts.io.FiberRef locally
  */
-export function locally_<A>(fiberRef: FiberRef<A>, value: A) {
+export function locally_<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrace?: string) {
   return <R1, E1, B>(use: IO<R1, E1, B>): IO<R1, E1, B> => {
     return new FiberRefLocally(value, fiberRef, use);
   };
@@ -72,7 +72,7 @@ export function locally_<A>(fiberRef: FiberRef<A>, value: A) {
  *
  * @tsplus fluent fncts.io.FiberRef locallyWith
  */
-export function locallyWith_<A>(self: FiberRef<A>, f: (a: A) => A) {
+export function locallyWith_<A>(self: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string) {
   return <R1, E1, B>(use: IO<R1, E1, B>): IO<R1, E1, B> => self.getWith((a) => self.locally(f(a))(use));
 }
 

package/_src/FiberRef/constructors.ts

@@ -2,6 +2,7 @@ import { identity } from "@fncts/base/data/function";
 
 function makeWith<Value, Patch>(
   ref: Lazy<FiberRef.WithPatch<Value, Patch>>,
+  __tsplusTrace?: string,
 ): IO<Scope, never, FiberRef.WithPatch<Value, Patch>> {
   return IO.acquireRelease(
     IO.succeed(ref).tap((ref) => ref.update(identity)),
@@ -16,6 +17,7 @@ export function make<A>(
   initial: A,
   fork: (a: A) => A = identity,
   join: (a: A, a1: A) => A = (_, a) => a,
+  __tsplusTrace?: string,
 ): IO<Scope, never, FiberRef<A>> {
   return makeWith(FiberRef.unsafeMake(initial, fork, join));
 }

package/_src/Future/api.ts

@@ -8,7 +8,7 @@ import { Done, FutureStateTag, Pending } from "@fncts/io/Future/definition";
  *
  * @tsplus fluent fncts.io.Future done
  */
-export function done_<E, A>(future: Future<E, A>, exit: Exit<E, A>): UIO<boolean> {
+export function done_<E, A>(future: Future<E, A>, exit: Exit<E, A>, __tsplusTrace?: string): UIO<boolean> {
   return future.fulfillWith(IO.fromExitNow(exit));
 }
 
@@ -18,7 +18,7 @@ export function done_<E, A>(future: Future<E, A>, exit: Exit<E, A>): UIO<boolean
  *
  * @tsplus fluent fncts.io.Future fail
  */
-export function fail_<E, A>(future: Future<E, A>, e: E): UIO<boolean> {
+export function fail_<E, A>(future: Future<E, A>, e: E, __tsplusTrace?: string): UIO<boolean> {
   return future.fulfillWith(IO.failNow(e));
 }
 
@@ -28,7 +28,7 @@ export function fail_<E, A>(future: Future<E, A>, e: E): UIO<boolean> {
  *
  * @tsplus fluent fncts.io.Future failCause
  */
-export function failCause_<E, A>(future: Future<E, A>, cause: Cause<E>): UIO<boolean> {
+export function failCause_<E, A>(future: Future<E, A>, cause: Cause<E>, __tsplusTrace?: string): UIO<boolean> {
   return future.fulfillWith(IO.failCauseNow(cause));
 }
 
@@ -41,7 +41,11 @@ export function failCause_<E, A>(future: Future<E, A>, cause: Cause<E>): UIO<boo
  *
  * @tsplus fluent fncts.io.Future fulfill
  */
-export function fulfill_<R, E, A>(future: Future<E, A>, io: IO<R, E, A>): IO<R, never, boolean> {
+export function fulfill_<R, E, A>(
+  future: Future<E, A>,
+  io: IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, never, boolean> {
   return IO.uninterruptibleMask(({ restore }) => restore(io).result.flatMap((exit) => future.done(exit)));
 }
 
@@ -60,7 +64,7 @@ export function fulfill_<R, E, A>(future: Future<E, A>, io: IO<R, E, A>): IO<R,
  *
  * @tsplus fluent fncts.io.Future fulfillWith
  */
-export function fulfillWith_<E, A>(future: Future<E, A>, io: FIO<E, A>): UIO<boolean> {
+export function fulfillWith_<E, A>(future: Future<E, A>, io: FIO<E, A>, __tsplusTrace?: string): UIO<boolean> {
   return IO.succeed(() => {
     switch (future.state._tag) {
       case FutureStateTag.Done: {
@@ -84,7 +88,7 @@ export function fulfillWith_<E, A>(future: Future<E, A>, io: FIO<E, A>): UIO<boo
  *
  * @tsplus fluent fncts.io.Future halt
  */
-export function halt_<E, A>(future: Future<E, A>, defect: unknown): UIO<boolean> {
+export function halt_<E, A>(future: Future<E, A>, defect: unknown, __tsplusTrace?: string): UIO<boolean> {
   return future.fulfillWith(IO.haltNow(defect));
 }
 
@@ -94,7 +98,7 @@ export function halt_<E, A>(future: Future<E, A>, defect: unknown): UIO<boolean>
  *
  * @tsplus getter fncts.io.Future interrupt
  */
-export function interrupt<E, A>(future: Future<E, A>): UIO<boolean> {
+export function interrupt<E, A>(future: Future<E, A>, __tsplusTrace?: string): UIO<boolean> {
   return IO.fiberId.flatMap((id) => future.fulfillWith(IO.interruptAs(id)));
 }
 
@@ -104,7 +108,7 @@ export function interrupt<E, A>(future: Future<E, A>): UIO<boolean> {
  *
  * @tsplus fluent fncts.io.Future interruptAs
  */
-export function interruptAs_<E, A>(future: Future<E, A>, id: FiberId): UIO<boolean> {
+export function interruptAs_<E, A>(future: Future<E, A>, id: FiberId, __tsplusTrace?: string): UIO<boolean> {
   return future.fulfillWith(IO.interruptAs(id));
 }
 
@@ -114,7 +118,7 @@ export function interruptAs_<E, A>(future: Future<E, A>, id: FiberId): UIO<boole
  *
  * @tsplus getter fncts.io.Future isDone
  */
-export function isDone<E, A>(future: Future<E, A>): UIO<boolean> {
+export function isDone<E, A>(future: Future<E, A>, __tsplusTrace?: string): UIO<boolean> {
   return IO.succeed(future.state._tag === FutureStateTag.Done);
 }
 
@@ -124,7 +128,7 @@ export function isDone<E, A>(future: Future<E, A>): UIO<boolean> {
  *
  * @tsplus getter fncts.io.Future poll
  */
-export function poll<E, A>(future: Future<E, A>): UIO<Maybe<FIO<E, A>>> {
+export function poll<E, A>(future: Future<E, A>, __tsplusTrace?: string): UIO<Maybe<FIO<E, A>>> {
   return IO.succeed(() => {
     switch (future.state._tag) {
       case FutureStateTag.Done: {
@@ -142,7 +146,7 @@ export function poll<E, A>(future: Future<E, A>): UIO<Maybe<FIO<E, A>>> {
  *
  * @tsplus fluent fncts.io.Future succeed
  */
-export function succeed_<A, E>(future: Future<E, A>, a: A) {
+export function succeed_<A, E>(future: Future<E, A>, a: A, __tsplusTrace?: string) {
   return future.fulfillWith(IO.succeedNow(a));
 }
 
@@ -152,7 +156,7 @@ export function succeed_<A, E>(future: Future<E, A>, a: A) {
  *
  * @tsplus fluent fncts.io.Future unsafeDone
  */
-export function unsafeDone_<E, A>(future: Future<E, A>, io: FIO<E, A>) {
+export function unsafeDone_<E, A>(future: Future<E, A>, io: FIO<E, A>, __tsplusTrace?: string) {
   if (future.state._tag === FutureStateTag.Pending) {
     const state  = future.state;
     future.state = new Done(io);
@@ -165,7 +169,7 @@ export function unsafeDone_<E, A>(future: Future<E, A>, io: FIO<E, A>) {
 /**
  * @tsplus fluent fncts.io.Future unsafeSucceed
  */
-export function unsafeSucceed_<A>(future: Future<never, A>, a: A): void {
+export function unsafeSucceed_<A>(future: Future<never, A>, a: A, __tsplusTrace?: string): void {
   future.unsafeDone(IO.succeedNow(a));
 }
 
@@ -175,7 +179,7 @@ export function unsafeSucceed_<A>(future: Future<never, A>, a: A): void {
  *
  * @tsplus getter fncts.io.Future await
  */
-export function wait<E, A>(future: Future<E, A>): IO<never, E, A> {
+export function wait<E, A>(future: Future<E, A>, __tsplusTrace?: string): IO<never, E, A> {
   return IO.asyncInterrupt<never, E, A>((k) => {
     switch (future.state._tag) {
       case FutureStateTag.Done: {
@@ -189,7 +193,11 @@ export function wait<E, A>(future: Future<E, A>): IO<never, E, A> {
   }, future.blockingOn);
 }
 
-function interruptJoiner<E, A>(future: Future<E, A>, joiner: (a: FIO<E, A>) => void): Canceler<never> {
+function interruptJoiner<E, A>(
+  future: Future<E, A>,
+  joiner: (a: FIO<E, A>) => void,
+  __tsplusTrace?: string,
+): Canceler<never> {
   return IO.succeed(() => {
     switch (future.state._tag) {
       case FutureStateTag.Pending: {

package/_src/Future/constructors.ts

@@ -5,7 +5,7 @@ import { Future, Pending } from "@fncts/io/Future/definition";
  *
  * @tsplus static fncts.io.FutureOps make
  */
-export function make<E, A>(): IO<never, never, Future<E, A>> {
+export function make<E, A>(__tsplusTrace?: string): IO<never, never, Future<E, A>> {
   return IO.fiberId.flatMap((id) => Future.makeAs<E, A>(id));
 }
 
@@ -14,7 +14,7 @@ export function make<E, A>(): IO<never, never, Future<E, A>> {
  *
  * @tsplus static fncts.io.FutureOps makeAs
  */
-export function makeAs<E, A>(fiberId: FiberId) {
+export function makeAs<E, A>(fiberId: FiberId, __tsplusTrace?: string) {
   return IO.succeed(unsafeMake<E, A>(fiberId));
 }
 

package/_src/Hub/api.ts

@@ -16,7 +16,10 @@ import { QueueInternal } from "@fncts/io/Queue";
  *
  * @tsplus getter fncts.io.Hub awaitShutdown
  */
-export function awaitShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): UIO<void> {
+export function awaitShutdown<RA, RB, EA, EB, A, B>(
+  self: PHub<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
+): UIO<void> {
   concrete(self);
   return self.awaitShutdown;
 }
@@ -26,7 +29,7 @@ export function awaitShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A
  *
  * @tsplus getter fncts.io.Hub capacity
  */
-export function capacity<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): number {
+export function capacity<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): number {
   concrete(self);
   return self.capacity;
 }
@@ -40,6 +43,7 @@ export function capacity<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>)
 export function contramapIO_<RA, RB, RC, EA, EB, EC, A, B, C>(
   self: PHub<RA, RB, EA, EB, A, B>,
   f: (c: C) => IO<RC, EC, A>,
+  __tsplusTrace?: string,
 ): PHub<RC | RA, RB, EA | EC, EB, C, B> {
   return self.dimapIO(f, IO.succeedNow);
 }
@@ -79,6 +83,7 @@ export function dimap_<RA, RB, EA, EB, A, B, C, D>(
   self: PHub<RA, RB, EA, EB, A, B>,
   f: (c: C) => A,
   g: (b: B) => D,
+  __tsplusTrace?: string,
 ): PHub<RA, RB, EA, EB, C, D> {
   return self.dimapIO(
     (c) => IO.succeedNow(f(c)),
@@ -96,6 +101,7 @@ export function dimapIO_<RA, RB, RC, RD, EA, EB, EC, ED, A, B, C, D>(
   source: PHub<RA, RB, EA, EB, A, B>,
   f: (c: C) => IO<RC, EC, A>,
   g: (b: B) => IO<RD, ED, D>,
+  __tsplusTrace?: string,
 ): PHub<RC | RA, RD | RB, EA | EC, EB | ED, C, D> {
   concrete(source);
   return new DimapIO(source, f, g);
@@ -125,6 +131,7 @@ class FilterInputIO<RA, RA1, RB, EA, EA1, EB, A, B> extends PHubInternal<RA | RA
 export function filterInputIO_<RA, RA1, RB, EA, EA1, EB, A, B>(
   source: PHub<RA, RB, EA, EB, A, B>,
   f: (a: A) => IO<RA1, EA1, boolean>,
+  __tsplusTrace?: string,
 ): PHub<RA | RA1, RB, EA | EA1, EB, A, B> {
   concrete(source);
   return new FilterInputIO(source, f);
@@ -135,7 +142,11 @@ export function filterInputIO_<RA, RA1, RB, EA, EA1, EB, A, B>(
  *
  * @tsplus fluent fncts.io.Hub filterInput
  */
-export function filterInput_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, f: (a: A) => boolean) {
+export function filterInput_<RA, RB, EA, EB, A, B>(
+  self: PHub<RA, RB, EA, EB, A, B>,
+  f: (a: A) => boolean,
+  __tsplusTrace?: string,
+) {
   return self.filterInputIO((a) => IO.succeedNow(f(a)));
 }
 
@@ -162,6 +173,7 @@ class FilterOutputIO<RA, RB, RB1, EA, EB, EB1, A, B> extends PHubInternal<RA, RB
 export function filterOutputIO_<RA, RB, RB1, EA, EB, EB1, A, B>(
   source: PHub<RA, RB, EA, EB, A, B>,
   f: (a: B) => IO<RB1, EB1, boolean>,
+  __tsplusTrace?: string,
 ): PHub<RA, RB | RB1, EA, EB | EB1, A, B> {
   concrete(source);
   return new FilterOutputIO(source, f);
@@ -175,6 +187,7 @@ export function filterOutputIO_<RA, RB, RB1, EA, EB, EB1, A, B>(
 export function filterOutput_<RA, RB, EA, EB, A, B>(
   self: PHub<RA, RB, EA, EB, A, B>,
   f: (b: B) => boolean,
+  __tsplusTrace?: string,
 ): PHub<RA, RB, EA, EB, A, B> {
   return self.filterOutputIO((b) => IO.succeedNow(f(b)));
 }
@@ -184,7 +197,10 @@ export function filterOutput_<RA, RB, EA, EB, A, B>(
  *
  * @tsplus getter fncts.io.Hub isShutdown
  */
-export function isShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): UIO<boolean> {
+export function isShutdown<RA, RB, EA, EB, A, B>(
+  self: PHub<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
+): UIO<boolean> {
   concrete(self);
   return self.isShutdown;
 }
@@ -198,7 +214,7 @@ export function isShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B
  *
  * @tsplus static fncts.io.HubOps makeBounded
  */
-export function makeBounded<A>(requestedCapacity: number): UIO<Hub<A>> {
+export function makeBounded<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>> {
   return IO.succeed(HubInternal.makeBounded<A>(requestedCapacity)).flatMap((hub) =>
     makeHubInternal(hub, new BackPressure()),
   );
@@ -212,7 +228,7 @@ export function makeBounded<A>(requestedCapacity: number): UIO<Hub<A>> {
  *
  * @tsplus static fncts.io.HubOps makeDropping
  */
-export function makeDropping<A>(requestedCapacity: number): UIO<Hub<A>> {
+export function makeDropping<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>> {
   return IO.succeed(HubInternal.makeBounded<A>(requestedCapacity)).flatMap((hub) =>
     makeHubInternal(hub, new Dropping()),
   );
@@ -226,7 +242,7 @@ export function makeDropping<A>(requestedCapacity: number): UIO<Hub<A>> {
  *
  * @tsplus static fncts.io.HubOps makeSliding
  */
-export function makeSliding<A>(requestedCapacity: number): UIO<Hub<A>> {
+export function makeSliding<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>> {
   return IO.succeed(HubInternal.makeBounded<A>(requestedCapacity)).flatMap((hub) =>
     makeHubInternal(hub, new Sliding()),
   );
@@ -237,7 +253,7 @@ export function makeSliding<A>(requestedCapacity: number): UIO<Hub<A>> {
  *
  * @tsplus static fncts.io.HubOps makeUnbounded
  */
-export function makeUnbounded<A>(): UIO<Hub<A>> {
+export function makeUnbounded<A>(__tsplusTrace?: string): UIO<Hub<A>> {
   return IO.succeed(HubInternal.makeUnbounded<A>()).flatMap((hub) => makeHubInternal(hub, new Dropping()));
 }
 
@@ -249,6 +265,7 @@ export function makeUnbounded<A>(): UIO<Hub<A>> {
 export function map_<RA, RB, EA, EB, A, B, C>(
   self: PHub<RA, RB, EA, EB, A, B>,
   f: (b: B) => C,
+  __tsplusTrace?: string,
 ): PHub<RA, RB, EA, EB, A, C> {
   return self.mapIO((b) => IO.succeedNow(f(b)));
 }
@@ -262,6 +279,7 @@ export function map_<RA, RB, EA, EB, A, B, C>(
 export function mapIO_<RA, RB, RC, EA, EB, EC, A, B, C>(
   self: PHub<RA, RB, EA, EB, A, B>,
   f: (b: B) => IO<RC, EC, C>,
+  __tsplusTrace?: string,
 ): PHub<RA, RC | RB, EA, EB | EC, A, C> {
   return self.dimapIO(IO.succeedNow, f);
 }
@@ -288,7 +306,11 @@ class ToQueue<RA, RB, EA, EB, A, B> extends QueueInternal<RA, never, EA, unknown
  *
  * @tsplus fluent fncts.io.Hub publish
  */
-export function publish_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, a: A): IO<RA, EA, boolean> {
+export function publish_<RA, RB, EA, EB, A, B>(
+  self: PHub<RA, RB, EA, EB, A, B>,
+  a: A,
+  __tsplusTrace?: string,
+): IO<RA, EA, boolean> {
   concrete(self);
   return self.publish(a);
 }
@@ -302,6 +324,7 @@ export function publish_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>,
 export function publishAll_<RA, RB, EA, EB, A, B>(
   self: PHub<RA, RB, EA, EB, A, B>,
   as: Iterable<A>,
+  __tsplusTrace?: string,
 ): IO<RA, EA, boolean> {
   concrete(self);
   return self.publishAll(as);
@@ -312,7 +335,7 @@ export function publishAll_<RA, RB, EA, EB, A, B>(
  *
  * @tsplus getter fncts.io.Hub shutdown
  */
-export function shutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): UIO<void> {
+export function shutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<void> {
   concrete(self);
   return self.shutdown;
 }
@@ -326,6 +349,7 @@ export function shutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>)
  */
 export function subscribe<RA, RB, EA, EB, A, B>(
   self: PHub<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
 ): IO<Scope, never, Hub.Dequeue<RB, EB, B>> {
   concrete(self);
   return self.subscribe;
@@ -336,7 +360,7 @@ export function subscribe<RA, RB, EA, EB, A, B>(
  *
  * @tsplus getter fncts.io.Hub size
  */
-export function size<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): UIO<number> {
+export function size<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<number> {
   concrete(self);
   return self.size;
 }
@@ -346,7 +370,10 @@ export function size<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): UI
  *
  * @tsplus getter fncts.io.Hub toQueue
  */
-export function toQueue<RA, RB, EA, EB, A, B>(source: PHub<RA, RB, EA, EB, A, B>): Hub.Enqueue<RA, EA, A> {
+export function toQueue<RA, RB, EA, EB, A, B>(
+  source: PHub<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
+): Hub.Enqueue<RA, EA, A> {
   concrete(source);
   return new ToQueue(source);
 }

package/_src/IO/api/acquireRelease.ts

@@ -5,6 +5,7 @@
 export function acquireRelease<R, E, A, R1>(
   acquire: Lazy<IO<R, E, A>>,
   release: (a: A) => IO<R1, never, any>,
+  __tsplusTrace?: string,
 ): IO<R | R1 | Scope, E, A> {
   return IO.acquireReleaseExit(acquire, (a, _) => release(a));
 }

package/_src/IO/api/addFinalizer.ts

@@ -1,9 +1,6 @@
 /**
  * @tsplus static fncts.io.IOOps addFinalizer
  */
-export function addFinalizer<R>(
-  finalizer: Lazy<URIO<R, any>>,
-  __tsplusTrace?: string,
-): IO<R | Scope, never, void> {
+export function addFinalizer<R>(finalizer: Lazy<URIO<R, any>>, __tsplusTrace?: string): IO<R | Scope, never, void> {
   return IO.addFinalizerExit(() => finalizer());
 }

package/_src/IO/api/addFinalizerExit.ts

@@ -1,7 +1,10 @@
 /**
  * @tsplus static fncts.io.IOOps addFinalizerExit
  */
-export function addFinalizerExit<R>(finalizer: (exit: Exit<any, any>) => URIO<R, any>): IO<R | Scope, never, void> {
+export function addFinalizerExit<R>(
+  finalizer: (exit: Exit<any, any>) => URIO<R, any>,
+  __tsplusTrace?: string,
+): IO<R | Scope, never, void> {
   return Do((_) => {
     const environment = _(IO.environment<R>());
     const scope       = _(IO.scope);

package/_src/IO/api/asyncIO.ts

@@ -1,7 +1,10 @@
 /**
  * @tsplus static fncts.io.IOOps asyncIO
  */
-export function asyncIO<R, E, A>(register: (k: (_: IO<R, E, A>) => void) => IO<R, E, void>): IO<R, E, A> {
+export function asyncIO<R, E, A>(
+  register: (k: (_: IO<R, E, A>) => void) => IO<R, E, void>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
   return Do((Δ) => {
     const f = Δ(Future.make<E, A>());
     const r = Δ(IO.runtime<R>());