@fncts/io 0.0.13 → 0.0.16

package/_src/Layer/api.ts

@@ -10,8 +10,9 @@ import { DecisionTag } from "@fncts/io/Schedule";
 export function and_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<RIn, E, ROut>,
   that: Layer<RIn1, E1, ROut1>,
+  __tsplusTrace?: string,
 ): Layer<RIn | RIn1, E | E1, ROut | ROut1> {
-  return new ZipWithC(self, that, (a, b) => a.union(b));
+  return new ZipWithC(self, that, (a, b) => a.union(b), __tsplusTrace);
 }
 
 /**
@@ -24,6 +25,7 @@ export function and_<RIn, E, ROut, RIn1, E1, ROut1>(
 export function andTo_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<RIn, E, ROut>,
   that: Layer<RIn1, E1, ROut1>,
+  __tsplusTrace?: string,
 ): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1> {
   return self.and(self.to(that));
 }
@@ -38,6 +40,7 @@ export function andTo_<RIn, E, ROut, RIn1, E1, ROut1>(
 export function andUsing_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<RIn1, E1, ROut1>,
   that: Layer<RIn, E, ROut>,
+  __tsplusTrace?: string,
 ): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1> {
   return that.and(that.to(self));
 }
@@ -48,6 +51,7 @@ export function andUsing_<RIn, E, ROut, RIn1, E1, ROut1>(
 export function catchAll_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<RIn, E, ROut>,
   f: (e: E) => Layer<RIn1, E1, ROut1>,
+  __tsplusTrace?: string,
 ): Layer<RIn | RIn1, E1, ROut | ROut1> {
   return self.matchLayer(f, Layer.succeedEnvironmentNow);
 }
@@ -58,6 +62,7 @@ export function catchAll_<RIn, E, ROut, RIn1, E1, ROut1>(
 export function flatMap_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<RIn, E, ROut>,
   f: (r: Environment<ROut>) => Layer<RIn1, E1, ROut1>,
+  __tsplusTrace?: string,
 ): Layer<RIn | RIn1, E | E1, ROut1> {
   return self.matchLayer(Layer.failNow, f);
 }
@@ -68,42 +73,43 @@ export function flatMap_<RIn, E, ROut, RIn1, E1, ROut1>(
 export function compose_<RIn, E, ROut, E1, ROut1>(
   self: Layer<RIn, E, ROut>,
   that: Layer<ROut, E1, ROut1>,
+  __tsplusTrace?: string,
 ): Layer<RIn, E | E1, ROut1> {
-  return new To(self, that);
+  return new To(self, that, __tsplusTrace);
 }
 
 /**
  * @tsplus static fncts.io.LayerOps environment
  */
-export function environment<RIn>(): Layer<RIn, never, RIn> {
+export function environment<RIn>(__tsplusTrace?: string): Layer<RIn, never, RIn> {
   return Layer(IO.environment<RIn>());
 }
 
 /**
  * @tsplus static fncts.io.LayerOps fail
  */
-export function fail<E>(e: Lazy<E>): Layer<never, E, never> {
+export function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Layer<never, E, never> {
   return Layer(IO.fail(e));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps failCause
  */
-export function failCause<E>(cause: Lazy<Cause<E>>): Layer<never, E, never> {
+export function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Layer<never, E, never> {
   return Layer(IO.failCause(cause));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps failCauseNow
  */
-export function failCauseNow<E>(cause: Cause<E>): Layer<never, E, never> {
+export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Layer<never, E, never> {
   return Layer(IO.failCauseNow(cause));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps failNow
  */
-export function failNow<E>(e: E): Layer<never, E, never> {
+export function failNow<E>(e: E, __tsplusTrace?: string): Layer<never, E, never> {
   return Layer(IO.failNow(e));
 }
 
@@ -113,6 +119,7 @@ export function failNow<E>(e: E): Layer<never, E, never> {
 export function flatten<RIn, E, RIn1, E1, ROut>(
   self: Layer<RIn, E, Layer<RIn1, E1, ROut>>,
   tag: Tag<Layer<RIn1, E1, ROut>>,
+  __tsplusTrace?: string,
 ): Layer<RIn | RIn1, E | E1, ROut> {
   return self.flatMap((environment) => environment.get(tag));
 }
@@ -120,7 +127,7 @@ export function flatten<RIn, E, RIn1, E1, ROut>(
 /**
  * @tsplus getter fncts.io.Layer fresh
  */
-export function fresh<R, E, A>(self: Layer<R, E, A>): Layer<R, E, A> {
+export function fresh<R, E, A>(self: Layer<R, E, A>, __tsplusTrace?: string): Layer<R, E, A> {
   return new Fresh(self);
 }
 
@@ -131,6 +138,7 @@ export function fromFunction<R, A>(
   f: (r: R) => A,
   /** @tsplus implicit local */ tagR: Tag<R>,
   /** @tsplus implicit local */ tagA: Tag<A>,
+  __tsplusTrace?: string,
 ): Layer<R, never, A> {
   return Layer.fromIOEnvironment(IO.serviceWith((service) => Environment.empty.add(f(service), Derive()), Derive()));
 }
@@ -142,6 +150,7 @@ export function fromFunctionIO<R, E, A, R1>(
   f: (r: R) => IO<R1, E, A>,
   tagR: Tag<R>,
   tagA: Tag<A>,
+  __tsplusTrace?: string,
 ): Layer<R1 | R, E, A> {
   return Layer.fromIOEnvironment(
     IO.serviceWithIO((service) => f(service).map((a) => Environment.empty.add(a, tagA)), tagR),
@@ -153,34 +162,34 @@ export function fromFunctionIO<R, E, A, R1>(
  * @tsplus static fncts.io.LayerOps __call
  */
 export function fromIOEnvironment<R, E, A>(io: IO<R, E, Environment<A>>, __tsplusTrace?: string): Layer<R, E, A> {
-  return new FromScoped(io);
+  return new FromScoped(io, __tsplusTrace);
 }
 
 /**
  * @tsplus static fncts.io.LayerOps fromIO
  */
-export function fromIO<R, E, A>(resource: IO<R, E, A>, tag: Tag<A>): Layer<R, E, A> {
+export function fromIO<R, E, A>(resource: IO<R, E, A>, tag: Tag<A>, __tsplusTrace?: string): Layer<R, E, A> {
   return Layer.fromIOEnvironment(resource.map((a) => Environment().add(a, tag)));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps fromValue
  */
-export function fromValue<A>(value: Lazy<A>, tag: Tag<A>): Layer<never, never, A> {
+export function fromValue<A>(value: Lazy<A>, tag: Tag<A>, __tsplusTrace?: string): Layer<never, never, A> {
   return Layer.fromIO(IO.succeed(value), tag);
 }
 
 /**
  * @tsplus static fncts.io.LayerOps halt
  */
-export function halt(defect: Lazy<unknown>): Layer<never, never, never> {
+export function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Layer<never, never, never> {
   return Layer(IO.halt(defect));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps haltNow
  */
-export function haltNow(defect: unknown): Layer<never, never, never> {
+export function haltNow(defect: unknown, __tsplusTrace?: string): Layer<never, never, never> {
   return Layer(IO.haltNow(defect));
 }
 
@@ -191,8 +200,9 @@ export function matchCauseLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>
   self: Layer<RIn, E, ROut>,
   failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>,
   success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>,
+  __tsplusTrace?: string,
 ): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2> {
-  return new Fold(self, failure, success);
+  return new Fold(self, failure, success, __tsplusTrace);
 }
 
 /**
@@ -202,6 +212,7 @@ export function matchLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(
   self: Layer<RIn, E, ROut>,
   failure: (e: E) => Layer<RIn1, E1, ROut1>,
   success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>,
+  __tsplusTrace?: string,
 ): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2> {
   return self.matchCauseLayer((cause) => cause.failureOrCause.match(failure, Layer.failCauseNow), success);
 }
@@ -212,6 +223,7 @@ export function matchLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(
 export function map_<RIn, E, ROut, ROut1>(
   self: Layer<RIn, E, ROut>,
   f: (r: Environment<ROut>) => Environment<ROut1>,
+  __tsplusTrace?: string,
 ): Layer<RIn, E, ROut1> {
   return self.flatMap((a) => Layer.succeedEnvironmentNow(f(a)));
 }
@@ -219,14 +231,21 @@ export function map_<RIn, E, ROut, ROut1>(
 /**
  * @tsplus fluent fncts.io.Layer mapError
  */
-export function mapError_<RIn, E, ROut, E1>(self: Layer<RIn, E, ROut>, f: (e: E) => E1): Layer<RIn, E1, ROut> {
+export function mapError_<RIn, E, ROut, E1>(
+  self: Layer<RIn, E, ROut>,
+  f: (e: E) => E1,
+  __tsplusTrace?: string,
+): Layer<RIn, E1, ROut> {
   return self.catchAll((e) => Layer.failNow(f(e)));
 }
 
 /**
  * @tsplus getter fncts.io.Layer memoize
  */
-export function memoize<RIn, E, ROut>(self: Layer<RIn, E, ROut>): URIO<Scope, Layer<RIn, E, ROut>> {
+export function memoize<RIn, E, ROut>(
+  self: Layer<RIn, E, ROut>,
+  __tsplusTrace?: string,
+): URIO<Scope, Layer<RIn, E, ROut>> {
   return IO.serviceWithIO((scope: Scope) => self.build(scope), Scope.Tag).memoize.map((_) => new FromScoped(_));
 }
 
@@ -236,6 +255,7 @@ export function memoize<RIn, E, ROut>(self: Layer<RIn, E, ROut>): URIO<Scope, La
 export function orElse_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<RIn, E, ROut>,
   that: Layer<RIn1, E1, ROut1>,
+  __tsplusTrace?: string,
 ): Layer<RIn | RIn1, E | E1, ROut | ROut1> {
   return self.catchAll(() => that);
 }
@@ -243,7 +263,7 @@ export function orElse_<RIn, E, ROut, RIn1, E1, ROut1>(
 /**
  * @tsplus getter fncts.io.Layer orHalt
  */
-export function orHalt<RIn, E, ROut>(self: Layer<RIn, E, ROut>): Layer<RIn, never, ROut> {
+export function orHalt<RIn, E, ROut>(self: Layer<RIn, E, ROut>, __tsplusTrace?: string): Layer<RIn, never, ROut> {
   return self.catchAll(Layer.haltNow);
 }
 
@@ -252,6 +272,7 @@ export function orHalt<RIn, E, ROut>(self: Layer<RIn, E, ROut>): Layer<RIn, neve
  */
 export function passthrough<RIn extends Spreadable, E, ROut extends Spreadable>(
   self: Layer<RIn, E, ROut>,
+  __tsplusTrace?: string,
 ): Layer<RIn, E, RIn & ROut> {
   return Layer.environment<RIn>().and(self);
 }
@@ -262,8 +283,9 @@ export function passthrough<RIn extends Spreadable, E, ROut extends Spreadable>(
 export function retry_<RIn, E, ROut, S, RIn1>(
   self: Layer<RIn, E, ROut>,
   schedule: Schedule.WithState<S, RIn1, E, any>,
+  __tsplusTrace?: string,
 ): Layer<RIn | RIn1, E, ROut> {
-  const tag = Tag<{ readonly state: S }>();
+  const tag = Tag<{ readonly state: S }>("fncts.io.Layer.retryState");
   return Layer.succeedNow({ state: schedule.initial }, tag).flatMap((environment) =>
     retryLoop(self, schedule, environment.get(tag).state, tag),
   );
@@ -274,6 +296,7 @@ function retryUpdate<S, RIn, E, X>(
   e: E,
   s: S,
   tag: Tag<{ readonly state: S }>,
+  __tsplusTrace?: string,
 ): Layer<RIn, E, { readonly state: S }> {
   return Layer.fromIO(
     Clock.currentTime.flatMap((now) =>
@@ -294,6 +317,7 @@ function retryLoop<RIn, E, ROut, S, RIn1, X>(
   schedule: Schedule.WithState<S, RIn1, E, X>,
   s: S,
   tag: Tag<{ readonly state: S }>,
+  __tsplusTrace?: string,
 ): Layer<RIn | RIn1, E, ROut> {
   return self.catchAll((e) =>
     retryUpdate(schedule, e, s, tag).flatMap((env) => retryLoop(self, schedule, env.get(tag).state, tag).fresh),
@@ -303,49 +327,56 @@ function retryLoop<RIn, E, ROut, S, RIn1, X>(
 /**
  * @tsplus static fncts.io.LayerOps scoped
  */
-export function scoped<R, E, A>(io: Lazy<IO<R, E, A>>, tag: Tag<A>): Layer<Exclude<R, Scope>, E, A> {
+export function scoped<R, E, A>(
+  io: Lazy<IO<R, E, A>>,
+  tag: Tag<A>,
+  __tsplusTrace?: string,
+): Layer<Exclude<R, Scope>, E, A> {
   return Layer.scopedEnvironment(io().map((a) => Environment.empty.add(a, tag)));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps scopedEnvironment
  */
-export function scopedEnvironment<R, E, A>(io: Lazy<IO<R, E, Environment<A>>>): Layer<Exclude<R, Scope>, E, A> {
-  return new FromScoped(IO.defer(io));
+export function scopedEnvironment<R, E, A>(
+  io: Lazy<IO<R, E, Environment<A>>>,
+  __tsplusTrace?: string,
+): Layer<Exclude<R, Scope>, E, A> {
+  return new FromScoped(IO.defer(io), __tsplusTrace);
 }
 
 /**
  * @tsplus static fncts.io.LayerOps service
  */
-export function service<A>(tag: Tag<A>): Layer<A, never, A> {
+export function service<A>(tag: Tag<A>, __tsplusTrace?: string): Layer<A, never, A> {
   return Layer.fromIO(IO.service(tag), tag);
 }
 
 /**
  * @tsplus static fncts.io.LayerOps succeed
  */
-export function succeed<A>(resource: Lazy<A>, tag: Tag<A>): Layer<never, never, A> {
+export function succeed<A>(resource: Lazy<A>, tag: Tag<A>, __tsplusTrace?: string): Layer<never, never, A> {
   return Layer.fromIOEnvironment(IO.succeed(Environment.empty.add(resource(), tag)));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps succeedEnvironment
  */
-export function succeedEnvironment<A>(a: Lazy<Environment<A>>): Layer<never, never, A> {
+export function succeedEnvironment<A>(a: Lazy<Environment<A>>, __tsplusTrace?: string): Layer<never, never, A> {
   return Layer.fromIOEnvironment(IO.succeed(a));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps succeedEnvironmentNow
  */
-export function succeedEnvironmentNow<A>(a: Environment<A>): Layer<never, never, A> {
+export function succeedEnvironmentNow<A>(a: Environment<A>, __tsplusTrace?: string): Layer<never, never, A> {
   return Layer.fromIOEnvironment(IO.succeedNow(a));
 }
 
 /**
  * @tsplus static fncts.io.LayerOps succeedNow
  */
-export function succeedNow<A>(resource: A, tag: Tag<A>): Layer<never, never, A> {
+export function succeedNow<A>(resource: A, tag: Tag<A>, __tsplusTrace?: string): Layer<never, never, A> {
   return Layer.fromIOEnvironment(IO.succeedNow(Environment.empty.add(resource, tag)));
 }
 
@@ -359,8 +390,9 @@ export function to_<RIn, E, ROut, RIn1, E1, ROut1>(
 export function to_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<RIn, E, ROut>,
   that: Layer<ROut | RIn1, E1, ROut1>,
+  __tsplusTrace?: string,
 ): Layer<RIn | RIn1, E | E1, ROut1> {
-  return new To(Layer(IO.environment<RIn1>()).and(self), that);
+  return new To(Layer(IO.environment<RIn1>(), __tsplusTrace).and(self), that);
 }
 
 /**
@@ -373,6 +405,7 @@ export function using_<RIn, E, ROut, RIn1, E1, ROut1>(
 export function using_<RIn, E, ROut, RIn1, E1, ROut1>(
   self: Layer<ROut | RIn1, E1, ROut1>,
   that: Layer<RIn, E, ROut>,
+  __tsplusTrace?: string,
 ): Layer<RIn | RIn1, E | E1, ROut1> {
-  return new To(Layer(IO.environment<RIn1>()).and(that), self);
+  return new To(Layer(IO.environment<RIn1>(), __tsplusTrace).and(that), self);
 }

package/_src/Layer/definition.ts

@@ -55,6 +55,7 @@ export class Fold<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2> extends Layer<
     readonly self: Layer<RIn, E, ROut>,
     readonly failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>,
     readonly success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>,
+    readonly trace?: string,
   ) {
     super();
   }
@@ -62,28 +63,28 @@ export class Fold<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2> extends Layer<
 
 export class Fresh<RIn, E, ROut> extends Layer<RIn, E, ROut> {
   readonly _tag = LayerTag.Fresh;
-  constructor(readonly self: Layer<RIn, E, ROut>) {
+  constructor(readonly self: Layer<RIn, E, ROut>, readonly trace?: string) {
     super();
   }
 }
 
 export class FromScoped<RIn, E, ROut> extends Layer<Exclude<RIn, Scope>, E, ROut> {
   readonly _tag = LayerTag.Scoped;
-  constructor(readonly self: IO<RIn, E, Environment<ROut>>) {
+  constructor(readonly self: IO<RIn, E, Environment<ROut>>, readonly trace?: string) {
     super();
   }
 }
 
 export class Defer<RIn, E, ROut> extends Layer<RIn, E, ROut> {
   readonly _tag = LayerTag.Defer;
-  constructor(readonly self: () => Layer<RIn, E, ROut>) {
+  constructor(readonly self: () => Layer<RIn, E, ROut>, readonly trace?: string) {
     super();
   }
 }
 
 export class To<RIn, E, ROut, E1, ROut1> extends Layer<RIn, E | E1, ROut1> {
   readonly _tag = LayerTag.To;
-  constructor(readonly self: Layer<RIn, E, ROut>, readonly that: Layer<ROut, E1, ROut1>) {
+  constructor(readonly self: Layer<RIn, E, ROut>, readonly that: Layer<ROut, E1, ROut1>, readonly trace?: string) {
     super();
   }
 }
@@ -94,6 +95,7 @@ export class ZipWith<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer<RIn | R
     readonly self: Layer<RIn, E, ROut>,
     readonly that: Layer<RIn1, E1, ROut1>,
     readonly f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>,
+    readonly trace?: string,
   ) {
     super();
   }
@@ -105,6 +107,7 @@ export class ZipWithC<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer<RIn |
     readonly self: Layer<RIn, E, ROut>,
     readonly that: Layer<RIn1, E1, ROut1>,
     readonly f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>,
+    readonly trace?: string,
   ) {
     super();
   }

package/_src/Queue/api/dimapIO.ts

@@ -49,7 +49,12 @@ class DimapIO<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D> extends QueueInternal<
  *
  * @tsplus fluent fncts.io.Queue dimap
  */
-export function dimap_<RA, RB, EA, EB, A, B, C, D>(self: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => A, g: (b: B) => D) {
+export function dimap_<RA, RB, EA, EB, A, B, C, D>(
+  self: PQueue<RA, RB, EA, EB, A, B>,
+  f: (c: C) => A,
+  g: (b: B) => D,
+  __tsplusTrace?: string,
+) {
   return self.dimapIO(
     (c: C) => IO.succeedNow(f(c)),
     (b) => IO.succeedNow(g(b)),
@@ -66,6 +71,7 @@ export function dimapIO_<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (c: C) => IO<RC, EC, A>,
   g: (b: B) => IO<RD, ED, D>,
+  __tsplusTrace?: string,
 ): PQueue<RC | RA, RD | RB, EC | EA, ED | EB, C, D> {
   concrete(queue);
   return new DimapIO(queue, f, g);
@@ -79,6 +85,7 @@ export function dimapIO_<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D>(
 export function contramapIO_<RA, RB, EA, EB, A, B, RC, EC, C>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (c: C) => IO<RC, EC, A>,
+  __tsplusTrace?: string,
 ): PQueue<RA | RC, RB, EA | EC, EB, C, B> {
   return queue.dimapIO(f, IO.succeedNow);
 }
@@ -91,6 +98,7 @@ export function contramapIO_<RA, RB, EA, EB, A, B, RC, EC, C>(
 export function contramap_<RA, RB, EA, EB, A, B, C>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (c: C) => A,
+  __tsplusTrace?: string,
 ): PQueue<RA, RB, EA, EB, C, B> {
   return queue.contramapIO((c) => IO.succeedNow(f(c)));
 }
@@ -103,6 +111,7 @@ export function contramap_<RA, RB, EA, EB, A, B, C>(
 export function mapIO_<RA, RB, EA, EB, A, B, R2, E2, C>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (b: B) => IO<R2, E2, C>,
+  __tsplusTrace?: string,
 ): PQueue<RA, R2 | RB, EA, EB | E2, A, C> {
   return queue.dimapIO(IO.succeedNow, f);
 }
@@ -115,6 +124,7 @@ export function mapIO_<RA, RB, EA, EB, A, B, R2, E2, C>(
 export function map_<RA, RB, EA, EB, A, B, C>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (b: B) => C,
+  __tsplusTrace?: string,
 ): PQueue<RA, RB, EA, EB, A, C> {
   return queue.mapIO((b) => IO.succeedNow(f(b)));
 }

package/_src/Queue/api/filterInputIO.ts

@@ -54,6 +54,7 @@ export class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends Q
 export function filterInputIO_<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (_: A1) => IO<R2, E2, boolean>,
+  __tsplusTrace?: string,
 ): PQueue<RA | R2, RB, EA | E2, EB, A1, B> {
   concrete(queue);
   return new FilterInputIO(queue, f);
@@ -68,6 +69,7 @@ export function filterInputIO_<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>(
 export function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (_: A1) => boolean,
+  __tsplusTrace?: string,
 ): PQueue<RA, RB, EA, EB, A1, B> {
   return queue.filterInputIO((a) => IO.succeedNow(f(a)));
 }

package/_src/Queue/api/filterOutputIO.ts

@@ -58,6 +58,7 @@ export class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInterna
 export function filterOutputIO_<RA, RB, EA, EB, A, B, RB1, EB1>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   f: (b: B) => IO<RB1, EB1, boolean>,
+  __tsplusTrace?: string,
 ): PQueue<RA, RB | RB1, EA, EB | EB1, A, B> {
   concrete(queue);
   return new FilterOutputIO(queue, f);
@@ -69,6 +70,7 @@ export function filterOutputIO_<RA, RB, EA, EB, A, B, RB1, EB1>(
 export function filterOutput_<RA, RB, EA, EB, A, B>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   p: Predicate<B>,
+  __tsplusTrace?: string,
 ): PQueue<RA, RB, EA, EB, A, B> {
   return queue.filterOutputIO((b) => IO.succeedNow(p(b)));
 }

package/_src/Queue/api/operations.ts

@@ -7,7 +7,10 @@ import { concrete } from "@fncts/io/Queue/definition";
  *
  * @tsplus getter fncts.io.Queue awaitShutdown
  */
-export function awaitShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): UIO<void> {
+export function awaitShutdown<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
+): UIO<void> {
   concrete(queue);
   return queue.awaitShutdown;
 }
@@ -17,7 +20,7 @@ export function awaitShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB
  *
  * @tsplus getter fncts.io.Queue capacity
  */
-export function capacity<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): number {
+export function capacity<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): number {
   concrete(queue);
   return queue.capacity;
 }
@@ -27,7 +30,10 @@ export function capacity<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A,
  *
  * @tsplus getter fncts.io.Queue isShutdown
  */
-export function isShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): UIO<boolean> {
+export function isShutdown<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
+): UIO<boolean> {
   concrete(queue);
   return queue.isShutdown;
 }
@@ -37,7 +43,11 @@ export function isShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A
  *
  * @tsplus fluent fncts.io.Queue offer
  */
-export function offer_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, a: A): IO<RA, EA, boolean> {
+export function offer_<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  a: A,
+  __tsplusTrace?: string,
+): IO<RA, EA, boolean> {
   concrete(queue);
   return queue.offer(a);
 }
@@ -60,7 +70,11 @@ export function offer_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>
  *
  * @tsplus fluent fncts.io.Queue offerAll
  */
-export function offerAll_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, as: Iterable<A>) {
+export function offerAll_<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  as: Iterable<A>,
+  __tsplusTrace?: string,
+) {
   concrete(queue);
   return queue.offerAll(as);
 }
@@ -71,7 +85,7 @@ export function offerAll_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A,
  *
  * @tsplus getter fncts.io.Queue shutdown
  */
-export function shutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>) {
+export function shutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string) {
   concrete(queue);
   return queue.shutdown;
 }
@@ -83,7 +97,7 @@ export function shutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A,
  *
  * @tsplus getter fncts.io.Queue size
  */
-export function size<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>) {
+export function size<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string) {
   concrete(queue);
   return queue.size;
 }
@@ -94,7 +108,7 @@ export function size<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>)
  *
  * @tsplus getter fncts.io.Queue take
  */
-export function take<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): IO<RB, EB, B> {
+export function take<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<RB, EB, B> {
   concrete(queue);
   return queue.take;
 }
@@ -105,7 +119,7 @@ export function take<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>):
  *
  * @tsplus getter fncts.io.Queue takeAll
  */
-export function takeAll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>) {
+export function takeAll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string) {
   concrete(queue);
   return queue.takeAll;
 }
@@ -115,7 +129,11 @@ export function takeAll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B
  *
  * @tsplus fluent fncts.io.Queue takeAllUpTo
  */
-export function takeAllUpTo_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, n: number) {
+export function takeAllUpTo_<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  n: number,
+  __tsplusTrace?: string,
+) {
   concrete(queue);
   return queue.takeUpTo(n);
 }

package/_src/Queue/api/poll.ts

@@ -5,7 +5,10 @@ import { concrete } from "@fncts/io/Queue/definition";
  *
  * @tsplus getter fncts.io.Queue poll
  */
-export function poll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): IO<RB, EB, Maybe<B>> {
+export function poll<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
+): IO<RB, EB, Maybe<B>> {
   concrete(queue);
   return queue.takeUpTo(1).map((bs) => bs.head);
 }

package/_src/Queue/api/takeBetween.ts

@@ -1,6 +1,10 @@
 import { concrete } from "@fncts/io/Queue/definition";
 
-function takeRemainderLoop<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, n: number): IO<RB, EB, Conc<B>> {
+function takeRemainderLoop<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  n: number,
+  __tsplusTrace?: string,
+): IO<RB, EB, Conc<B>> {
   concrete(queue);
   if (n <= 0) {
     return IO.succeedNow(Conc.empty());
@@ -20,6 +24,7 @@ export function takeBetween_<RA, RB, EA, EB, A, B>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   min: number,
   max: number,
+  __tsplusTrace?: string,
 ): IO<RB, EB, Conc<B>> {
   concrete(queue);
   if (max < min) {

package/_src/Queue/api/zipWithIO.ts

@@ -64,6 +64,7 @@ export function zipWithIO_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C,
   fa: PQueue<RA, RB, EA, EB, A, B>,
   fb: PQueue<RA1, RB1, EA1, EB1, A1, C>,
   f: (b: B, c: C) => IO<R3, E3, D>,
+  __tsplusTrace?: string,
 ): PQueue<RA | RA1, RB | RB1 | R3, EA | EA1, E3 | EB | EB1, A1, D> {
   concrete(fa);
   concrete(fb);
@@ -79,6 +80,7 @@ export function zipWith_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B,
   queue: PQueue<RA, RB, EA, EB, A, B>,
   that: PQueue<RA1, RB1, EA1, EB1, A1, C>,
   f: (b: B, c: C) => D,
+  __tsplusTrace?: string,
 ): PQueue<RA | RA1, RB | RB1, EA | EA1, EB | EB1, A1, D> {
   return zipWithIO_(queue, that, (b, c) => IO.succeedNow(f(b, c)));
 }
@@ -91,6 +93,7 @@ export function zipWith_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B,
 export function zip_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, A>(
   queue: PQueue<RA, RB, EA, EB, A, B>,
   that: PQueue<RA1, RB1, EA1, EB1, A1, C>,
+  __tsplusTrace?: string,
 ): PQueue<RA | RA1, RB | RB1, EA | EA1, EB | EB1, A1, readonly [B, C]> {
   return zipWith_(queue, that, tuple);
 }