@fncts/io 0.0.38 → 0.0.40

package/_src/State.ts

@@ -1,4 +1,5 @@
-// codegen:start { preset: barrel, include: ./State/*.ts, exclude: ./State/internal.ts }
-export * from "./State/api.js";
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: barrel, include: ./State/*.ts, exclude: State/internal.ts }
 export * from "./State/definition.js";
+export * from "./State/api.js";
 // codegen:end

package/_src/Stream/api/zipAllWith.ts

@@ -132,8 +132,8 @@ function zipWithChunks<A, B, C>(
   __tsplusTrace?: string,
 ): readonly [Conc<C>, State<A, B>] {
   const [out, r] = zipChunks(leftChunk, rightChunk, f);
-  return r.match(
-    (leftChunk) => (leftChunk.isEmpty ? [out, new PullBoth()] : [out, new PullRight(leftChunk)]),
-    (rightChunk) => (rightChunk.isEmpty ? [out, new PullBoth()] : [out, new PullLeft(rightChunk)]),
-  );
+  return r.match({
+    Left: (leftChunk) => (leftChunk.isEmpty ? [out, new PullBoth()] : [out, new PullRight(leftChunk)]),
+    Right: (rightChunk) => (rightChunk.isEmpty ? [out, new PullBoth()] : [out, new PullLeft(rightChunk)]),
+  });
 }

package/_src/Stream/api/zipWithChunks.ts

@@ -73,10 +73,10 @@ function handleSuccess<A1, A2, A3>(
   __tsplusTrace?: string,
 ): readonly [Conc<A3>, State<A1, A2>] {
   const [out, remaining] = f(leftChunk, rightChunk);
-  return remaining.match(
-    (l) => (leftChunk.isEmpty ? [out, new PullBoth()] : [out, new PullRight(leftChunk)]),
-    (r) => (rightChunk.isEmpty ? [out, new PullBoth()] : [out, new PullLeft(rightChunk)]),
-  );
+  return remaining.match({
+    Left: (l) => (leftChunk.isEmpty ? [out, new PullBoth()] : [out, new PullRight(leftChunk)]),
+    Right: (r) => (rightChunk.isEmpty ? [out, new PullBoth()] : [out, new PullLeft(rightChunk)]),
+  });
 }
 
 /**

package/_src/Stream/api.ts

@@ -56,7 +56,9 @@ export function aggregateAsyncWithin<R1, E1, A1, B, R2, C>(
   __tsplusTrace?: string,
 ) {
   return <R, E, A extends A1>(stream: Stream<R, E, A>): Stream<R | R1 | R2, E | E1, B> => {
-    return stream.aggregateAsyncWithinEither(sink, schedule).filterMap((cb) => cb.match(() => Nothing(), Maybe.just));
+    return stream
+      .aggregateAsyncWithinEither(sink, schedule)
+      .filterMap((cb) => cb.match({ Left: () => Nothing(), Right: Maybe.just }));
   };
 }
 
@@ -165,14 +167,14 @@ export function aggregateAsyncWithinEither<R1, E1, A1, B, R2, C>(
             (scheduleExit, sinkFiber) =>
               IO.fromExit(scheduleExit).matchCauseIO(
                 (cause) =>
-                  cause.failureOrCause.match(
-                    () =>
+                  cause.failureOrCause.match({
+                    Left: () =>
                       handoff.offer(HandoffSignal.End(new ScheduleEnd())).forkDaemon >
                       sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Nothing())),
-                    (cause) =>
+                    Right: (cause) =>
                       handoff.offer(HandoffSignal.Halt(cause)).forkDaemon >
                       sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Nothing())),
-                  ),
+                  }),
                 (c) =>
                   handoff.offer(HandoffSignal.End(new ScheduleEnd())).forkDaemon >
                   sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Just(c))),
@@ -255,8 +257,8 @@ export function asyncInterrupt<R, E, A>(
           }),
         ),
       );
-      return eitherStream.match(
-        (canceler) => {
+      return eitherStream.match({
+        Left: (canceler) => {
           const loop: Channel<never, unknown, unknown, unknown, E, Conc<A>, void> = Channel.unwrap(
             output.take
               .flatMap((take) => take.done)
@@ -267,8 +269,8 @@ export function asyncInterrupt<R, E, A>(
           );
           return new Stream(loop).ensuring(canceler);
         },
-        (stream) => Stream.unwrap(output.shutdown.as(stream)),
-      );
+        Right: (stream) => Stream.unwrap(output.shutdown.as(stream)),
+      });
     }),
   );
 }
@@ -336,10 +338,10 @@ export function asyncIO<R, E, A, R1 = R, E1 = E>(
             .matchCauseIO(
               (cause) =>
                 output.shutdown.as(
-                  cause.failureOrCause.match(
-                    (maybeError) => maybeError.match(() => Channel.endNow(undefined), Channel.failNow),
-                    Channel.failCauseNow,
-                  ),
+                  cause.failureOrCause.match({
+                    Left: (maybeError) => maybeError.match(() => Channel.endNow(undefined), Channel.failNow),
+                    Right: Channel.failCauseNow,
+                  }),
                 ),
               (as) => IO.succeed(Channel.writeNow(as) > loop),
             ),
@@ -577,7 +579,7 @@ function bufferSignalConsumer<R, E, A>(
  */
 export function catchAll<R1, E, E1, A1>(f: (e: E) => Stream<R1, E1, A1>, __tsplusTrace?: string) {
   return <R, A>(stream: Stream<R, E, A>): Stream<R | R1, E1, A | A1> => {
-    return stream.catchAllCause((cause) => cause.failureOrCause.match(f, Stream.failCauseNow));
+    return stream.catchAllCause((cause) => cause.failureOrCause.match({ Left: f, Right: Stream.failCauseNow }));
   };
 }
 
@@ -3208,7 +3210,7 @@ export function toPull<R, E, A>(
   __tsplusTrace?: string,
 ): IO<R | Scope, never, IO<R, Maybe<E>, Conc<A>>> {
   return stream.channel.toPull.map((io) =>
-    io.mapError(Maybe.just).flatMap((r) => r.match(() => IO.failNow(Nothing()), IO.succeedNow)),
+    io.mapError(Maybe.just).flatMap((r) => r.match({ Left: () => IO.failNow(Nothing()), Right: IO.succeedNow })),
   );
 }
 
@@ -3430,22 +3432,22 @@ export function zipWithLatest<A, R1, E1, B, C>(fb: Stream<R1, E1, B>, f: (a: A,
                 Stream.repeatIOMaybe(left)
                   .mergeEither(Stream.repeatIOMaybe(right))
                   .mapIO((ab) =>
-                    ab.match(
-                      (leftChunk) =>
+                    ab.match({
+                      Left: (leftChunk) =>
                         latest.modify(([_, rightLatest]) =>
                           tuple(
                             leftChunk.map((a) => f(a, rightLatest)),
                             tuple(leftChunk.unsafeGet(leftChunk.length - 1), rightLatest),
                           ),
                         ),
-                      (rightChunk) =>
+                      Right: (rightChunk) =>
                         latest.modify(([leftLatest, _]) =>
                           tuple(
                             rightChunk.map((b) => f(leftLatest, b)),
                             tuple(leftLatest, rightChunk.unsafeGet(rightChunk.length - 1)),
                           ),
                         ),
-                    ),
+                    }),
                   )
                   .flatMap(Stream.fromChunkNow),
               ),

package/_src/Stream/internal/Handoff.ts

@@ -27,7 +27,10 @@ export class Full<A> {
   readonly [StateTypeId]: typeof StateTypeId = StateTypeId;
   readonly _tag = HandoffStateTag.Full;
 
-  constructor(readonly a: A, readonly notifyProducer: Future<never, void>) {}
+  constructor(
+    readonly a: A,
+    readonly notifyProducer: Future<never, void>,
+  ) {}
 }
 
 export type State<A> = Empty | Full<A>;

package/_src/Stream.ts

@@ -1,4 +1,5 @@
-// codegen:start { preset: barrel, include: ./Stream/*.ts, exclude: ./Stream/*(DebounceState|Handoff|Pull|SinkEndReason|Take).ts }
-export * from "./Stream/api.js";
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: barrel, include: ./Stream/*.ts, exclude: Stream/*(DebounceState|Handoff|Pull|SinkEndReason|Take).ts }
 export * from "./Stream/definition.js";
+export * from "./Stream/api.js";
 // codegen:end

package/_src/Subject/definition.ts

@@ -1,4 +1,4 @@
-import type { Push,Sink } from "../Push.js";
+import type { Push, Sink } from "../Push.js";
 
 export const SubjectTypeId = Symbol.for("fncts.io.Push.Subject");
 export type SubjectTypeId = typeof SubjectTypeId;

package/_src/Subject.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Subject/*.ts }
+export * from "./Subject/definition.js";
 export * from "./Subject/api.js";
 export * from "./Subject/Atomic.js";
-export * from "./Subject/definition.js";
 // codegen:end

package/_src/SubscriptionRef.ts

@@ -6,7 +6,11 @@ export type SubscriptionRefTypeId = typeof SubscriptionRefTypeId;
 
 export class SubscriptionRefInternal<A> extends PSynchronizedInternal<never, never, never, never, A, A> {
   readonly [SubscriptionRefTypeId]: SubscriptionRefTypeId = SubscriptionRefTypeId;
-  constructor(readonly semaphore: Semaphore, readonly hub: Hub<A>, readonly ref: Ref<A>) {
+  constructor(
+    readonly semaphore: Semaphore,
+    readonly hub: Hub<A>,
+    readonly ref: Ref<A>,
+  ) {
     super(semaphore, ref.get, (a) => ref.set(a));
   }
   changes: Stream<never, never, A> = Stream.unwrapScoped(

package/_src/Supervisor/definition.ts

@@ -57,7 +57,10 @@ export class ConstSupervisor<A> extends Supervisor<A> {
 
 export class ProxySupervisor<A> extends Supervisor<A> {
   readonly _tag = SupervisorTag.Proxy;
-  constructor(readonly value: UIO<A>, readonly underlying: Supervisor<any>) {
+  constructor(
+    readonly value: UIO<A>,
+    readonly underlying: Supervisor<any>,
+  ) {
     super();
   }
   unsafeOnStart<R, E, A>(
@@ -84,7 +87,10 @@ export class ProxySupervisor<A> extends Supervisor<A> {
 
 export class Zip<A, B> extends Supervisor<readonly [A, B]> {
   readonly _tag = SupervisorTag.Zip;
-  constructor(readonly first: Supervisor<A>, readonly second: Supervisor<B>) {
+  constructor(
+    readonly first: Supervisor<A>,
+    readonly second: Supervisor<B>,
+  ) {
     super();
   }
   value = this.first.value.zip(this.second.value);

package/_src/Supervisor.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Supervisor/*.ts }
-export * from "./Supervisor/api.js";
-export * from "./Supervisor/constructors.js";
 export * from "./Supervisor/definition.js";
+export * from "./Supervisor/constructors.js";
+export * from "./Supervisor/api.js";
 // codegen:end

package/_src/SupervisorPatch.ts

@@ -25,7 +25,10 @@ export class AddSupervisor extends SupervisorPatch {
 
 export class Combine extends SupervisorPatch {
   readonly _tag = SupervisorPatchTag.Combine;
-  constructor(readonly first: SupervisorPatch, readonly second: SupervisorPatch) {
+  constructor(
+    readonly first: SupervisorPatch,
+    readonly second: SupervisorPatch,
+  ) {
     super();
   }
 }
@@ -82,6 +85,7 @@ export function diff(oldValue: Supervisor<any>, newValue: Supervisor<any>): Supe
   }
 }
 
+/** @tsplus tailRec */
 function applyLoop(supervisor: Supervisor<any>, patches: List<SupervisorPatch>): Supervisor<any> {
   if (patches.isEmpty()) {
     return supervisor;

package/_src/TExit.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./TExit/*.ts }
-export * from "./TExit/constructors.js";
 export * from "./TExit/definition.js";
+export * from "./TExit/constructors.js";
 // codegen:end

package/_src/TFuture.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: TFuture/*.ts }
-export * from "./TFuture/api.js";
-export * from "./TFuture/constructors.js";
 export * from "./TFuture/definition.js";
+export * from "./TFuture/constructors.js";
+export * from "./TFuture/api.js";
 // codegen:end

package/_src/TReentrantLock/definition.ts

@@ -36,7 +36,11 @@ export const enum LockTag {
  */
 export class WriteLock implements Lock {
   readonly _tag = LockTag.WriteLock;
-  constructor(readonly writeLocks: number, readonly readLocks: number, readonly fiberId: FiberId) {}
+  constructor(
+    readonly writeLocks: number,
+    readonly readLocks: number,
+    readonly fiberId: FiberId,
+  ) {}
   readLocksHeld(fiberId: FiberId): number {
     return this.fiberId == fiberId ? this.readLocks : 0;
   }

package/_src/TReentrantLock.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: TReentrantLock/*.ts }
-export * from "./TReentrantLock/api.js";
 export * from "./TReentrantLock/definition.js";
+export * from "./TReentrantLock/api.js";
 // codegen:end

package/_src/TRef/definition.ts

@@ -82,7 +82,10 @@ export abstract class TRefInternal<EA, EB, A, B> implements PTRef<EA, EB, A, B>
 
 export class Atomic<A> extends TRefInternal<never, never, A, A> {
   readonly atomic: Atomic<unknown> = this as Atomic<unknown>;
-  constructor(public versioned: Versioned<A>, readonly todo: AtomicReference<HashMap<TxnId, Todo>>) {
+  constructor(
+    public versioned: Versioned<A>,
+    readonly todo: AtomicReference<HashMap<TxnId, Todo>>,
+  ) {
     super();
   }
   match<EC, ED, C, D>(
@@ -159,8 +162,8 @@ export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
       (getEither, setEither, value, atomic) =>
         new Derived((f) =>
           f(
-            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
-            (c) => ca(c).flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
+            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
+            (c) => ca(c).flatMap((a) => setEither(a).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
             value,
             atomic,
           ),
@@ -178,11 +181,11 @@ export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
       (getEither, setEither, value, atomic) =>
         new DerivedAll((f) =>
           f(
-            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
+            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
             (c) => (s) =>
               getEither(s)
-                .match((e) => Either.left(ec(e)), ca(c))
-                .flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
+                .match({ Left: (e) => Either.left(ec(e)), Right: ca(c) })
+                .flatMap((a) => setEither(a).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
             value,
             atomic,
           ),
@@ -192,27 +195,29 @@ export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
 
   get get(): STM<never, EB, B> {
     return this.use((getEither, _setEither, value, _atomic) =>
-      value.get.flatMap((s) => getEither(s).match(STM.failNow, STM.succeedNow)),
+      value.get.flatMap((s) => getEither(s).match({ Left: STM.failNow, Right: STM.succeedNow })),
     );
   }
 
   set(a: A, __tsplusTrace?: string | undefined): STM<never, EA, void> {
-    return this.use((_getEither, setEither, value, _atomic) => setEither(a).match(STM.failNow, (s) => value.set(s)));
+    return this.use((_getEither, setEither, value, _atomic) =>
+      setEither(a).match({ Left: STM.failNow, Right: (s) => value.set(s) }),
+    );
   }
 
   modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): STM<never, EA | EB, C> {
     return this.use((getEither, setEither, value, _atomic) =>
       value.modify((s) =>
-        getEither(s).match(
-          (e) => [Either.left<EA | EB, C>(e), s],
-          (a1) => {
+        getEither(s).match({
+          Left: (e) => [Either.left<EA | EB, C>(e), s],
+          Right: (a1) => {
             const [b, a2] = f(a1);
-            return setEither(a2).match(
-              (e) => [Either.left(e), s],
-              (s) => [Either.right(b), s],
-            );
+            return setEither(a2).match({
+              Left: (e) => [Either.left(e), s],
+              Right: (s) => [Either.right(b), s],
+            });
           },
-        ),
+        }),
       ),
     ).absolve;
   }
@@ -253,8 +258,9 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
       (getEither, setEither, value, atomic) =>
         new DerivedAll((f) =>
           f(
-            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
-            (c) => (s) => ca(c).flatMap((a) => setEither(a)(s).match((e) => Either.left(ea(e)), Either.right)),
+            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
+            (c) => (s) =>
+              ca(c).flatMap((a) => setEither(a)(s).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
             value,
             atomic,
           ),
@@ -272,11 +278,11 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
       (getEither, setEither, value, atomic) =>
         new DerivedAll((f) =>
           f(
-            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
+            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
             (c) => (s) =>
               getEither(s)
-                .match((e) => Either.left(ec(e)), ca(c))
-                .flatMap((a) => setEither(a)(s).match((e) => Either.left(ea(e)), Either.right)),
+                .match({ Left: (e) => Either.left(ec(e)), Right: ca(c) })
+                .flatMap((a) => setEither(a)(s).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
             value,
             atomic,
           ),
@@ -286,17 +292,17 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
 
   get get(): STM<never, EB, B> {
     return this.use((getEither, _setEither, value, _atomic) =>
-      value.get.flatMap((s) => getEither(s).match(STM.failNow, STM.succeedNow)),
+      value.get.flatMap((s) => getEither(s).match({ Left: STM.failNow, Right: STM.succeedNow })),
     );
   }
 
   set(a: A, __tsplusTrace?: string | undefined): STM<never, EA, void> {
     return this.use((_getEither, setEither, value, _atomic) =>
       value.modify((s) =>
-        setEither(a)(s).match(
-          (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
-          (s) => [Either.right(undefined), s],
-        ),
+        setEither(a)(s).match({
+          Left: (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
+          Right: (s) => [Either.right(undefined), s],
+        }),
       ),
     ).absolve;
   }
@@ -304,16 +310,16 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
   modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): STM<never, EA | EB, C> {
     return this.use((getEither, setEither, value, atomic) =>
       value.modify((s) =>
-        getEither(s).match(
-          (e) => [Either.left<EA | EB, C>(e), s],
-          (a1) => {
+        getEither(s).match({
+          Left: (e) => [Either.left<EA | EB, C>(e), s],
+          Right: (a1) => {
             const [b, a2] = f(a1);
-            return setEither(a2)(s).match(
-              (e) => [Either.left(e), s],
-              (s) => [Either.right(b), s],
-            );
+            return setEither(a2)(s).match({
+              Left: (e) => [Either.left(e), s],
+              Right: (s) => [Either.right(b), s],
+            });
           },
-        ),
+        }),
       ),
     ).absolve;
   }

package/_src/TRef.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: TRef/*.ts }
-export * from "./TRef/api.js";
-export * from "./TRef/constructors.js";
 export * from "./TRef/definition.js";
+export * from "./TRef/constructors.js";
+export * from "./TRef/api.js";
 // codegen:end

package/_src/TSemaphore.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: TSemaphore/*.ts }
-export * from "./TSemaphore/api.js";
-export * from "./TSemaphore/constructors.js";
 export * from "./TSemaphore/definition.js";
+export * from "./TSemaphore/constructors.js";
+export * from "./TSemaphore/api.js";
 // codegen:end

package/_src/collection/immutable/Conc.ts

@@ -1,8 +1,9 @@
+/* eslint-disable simple-import-sort/exports */
 // 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";
 export * from "./Conc/takeWhileIO.js";
+export * from "./Conc/mapIO.js";
+export * from "./Conc/findIO.js";
+export * from "./Conc/filterIO.js";
+export * from "./Conc/dropWhileIO.js";
+export * from "./Conc/dropUntilIO.js";
 // codegen:end

package/_src/index.ts

@@ -1,51 +1,52 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./*.ts }
-export type {} from "./Cached.js";
-export type {} from "./CancellerState.js";
-export type {} from "./Channel.js";
-export type {} from "./Clock.js";
-export type {} from "./Console.js";
-export type {} from "./CountdownLatch.js";
-export type {} from "./Fiber.js";
-export type {} from "./FiberDescriptor.js";
-export type {} from "./FiberRef.js";
-export type {} from "./FiberRefs.js";
-export type {} from "./FiberScope.js";
-export type {} from "./FiberStatus.js";
-export type {} from "./Future.js";
 export type {} from "./global.js";
-export type {} from "./Hub.js";
-export type {} from "./InterruptStatus.js";
-export type {} from "./IO.js";
-export type {} from "./IOEnv.js";
-export type {} from "./Layer.js";
-export type {} from "./Logger.js";
-export type {} from "./LogLevel.js";
-export type {} from "./LogSpan.js";
-export type {} from "./MVar.js";
-export type {} from "./Push.js";
-export type {} from "./Queue.js";
-export type {} from "./Random.js";
-export type {} from "./Ref.js";
-export type {} from "./RefSubject.js";
-export type {} from "./Reloadable.js";
-export type {} from "./RuntimeFlag.js";
-export type {} from "./RuntimeFlags.js";
-export type {} from "./Schedule.js";
-export type {} from "./Scope.js";
-export type {} from "./ScopedRef.js";
-export type {} from "./Semaphore.js";
-export type {} from "./Sink.js";
+export type {} from "./TxnId.js";
+export type {} from "./TSemaphore.js";
+export type {} from "./TRef.js";
+export type {} from "./TReentrantLock.js";
+export type {} from "./TFuture.js";
+export type {} from "./TExit.js";
+export type {} from "./SupervisorPatch.js";
+export type {} from "./Supervisor.js";
+export type {} from "./SubscriptionRef.js";
+export type {} from "./Subject.js";
+export type {} from "./Stream.js";
 export type {} from "./State.js";
+export type {} from "./Sink.js";
+export type {} from "./Semaphore.js";
+export type {} from "./ScopedRef.js";
+export type {} from "./Scope.js";
+export type {} from "./Schedule.js";
 export type {} from "./STM.js";
-export type {} from "./Stream.js";
-export type {} from "./Subject.js";
-export type {} from "./SubscriptionRef.js";
-export type {} from "./Supervisor.js";
-export type {} from "./SupervisorPatch.js";
-export type {} from "./TExit.js";
-export type {} from "./TFuture.js";
-export type {} from "./TReentrantLock.js";
-export type {} from "./TRef.js";
-export type {} from "./TSemaphore.js";
-export type {} from "./TxnId.js";
+export type {} from "./RuntimeFlags.js";
+export type {} from "./RuntimeFlag.js";
+export type {} from "./Reloadable.js";
+export type {} from "./RefSubject.js";
+export type {} from "./Ref.js";
+export type {} from "./Random.js";
+export type {} from "./Queue.js";
+export type {} from "./Push.js";
+export type {} from "./MVar.js";
+export type {} from "./Logger.js";
+export type {} from "./LogSpan.js";
+export type {} from "./LogLevel.js";
+export type {} from "./Layer.js";
+export type {} from "./InterruptStatus.js";
+export type {} from "./IOEnv.js";
+export type {} from "./IO.js";
+export type {} from "./Hub.js";
+export type {} from "./Future.js";
+export type {} from "./FiberStatus.js";
+export type {} from "./FiberScope.js";
+export type {} from "./FiberRefs.js";
+export type {} from "./FiberRef.js";
+export type {} from "./FiberDescriptor.js";
+export type {} from "./Fiber.js";
+export type {} from "./CountdownLatch.js";
+export type {} from "./Console.js";
+export type {} from "./Clock.js";
+export type {} from "./Channel.js";
+export type {} from "./CancellerState.js";
+export type {} from "./Cached.js";
 // codegen:end

package/_src/internal/HashedPair.ts

@@ -1,5 +1,8 @@
 export class HashedPair<A, B> implements Hashable, Equatable {
-  constructor(readonly first: A, readonly second: B) {}
+  constructor(
+    readonly first: A,
+    readonly second: B,
+  ) {}
 
   get [Symbol.hash]() {
     return Hashable.combine(Hashable.unknown(this.first), Hashable.unknown(this.second));

package/_src/internal/Hub.ts

@@ -114,7 +114,11 @@ export class BoundedHubArb<A> extends Hub<A> {
 }
 
 class BoundedHubArbSubscription<A> extends SubscriptionInternal<A> {
-  constructor(private self: BoundedHubArb<A>, private subscriberIndex: number, private unsubscribed: boolean) {
+  constructor(
+    private self: BoundedHubArb<A>,
+    private subscriberIndex: number,
+    private unsubscribed: boolean,
+  ) {
     super();
   }
 
@@ -292,7 +296,11 @@ export class BoundedHubPow2<A> extends Hub<A> {
 }
 
 class BoundedHubPow2Subcription<A> extends SubscriptionInternal<A> {
-  constructor(private self: BoundedHubPow2<A>, private subscriberIndex: number, private unsubscribed: boolean) {
+  constructor(
+    private self: BoundedHubPow2<A>,
+    private subscriberIndex: number,
+    private unsubscribed: boolean,
+  ) {
     super();
   }
 
@@ -449,7 +457,11 @@ export class BoundedHubSingle<A> extends Hub<A> {
 }
 
 class BoundedHubSingleSubscription<A> extends SubscriptionInternal<A> {
-  constructor(private self: BoundedHubSingle<A>, private subscriberIndex: number, private unsubscribed: boolean) {
+  constructor(
+    private self: BoundedHubSingle<A>,
+    private subscriberIndex: number,
+    private unsubscribed: boolean,
+  ) {
     super();
   }
 
@@ -510,7 +522,11 @@ class BoundedHubSingleSubscription<A> extends SubscriptionInternal<A> {
 }
 
 class Node<A> {
-  constructor(public value: A | null, public subscribers: number, public next: Node<A> | null) {}
+  constructor(
+    public value: A | null,
+    public subscribers: number,
+    public next: Node<A> | null,
+  ) {}
 }
 
 export class UnboundedHub<A> extends Hub<A> {