@fncts/io 0.0.39 → 0.0.41

package/_src/Reloadable/definition.ts

@@ -11,7 +11,10 @@ export class Reloadable<Service> {
   declare [ReloadableVariance]: {
     readonly _Service: (_: never) => Service;
   };
-  constructor(readonly scopedRef: ScopedRef<Service>, readonly reload: IO<never, unknown, void>) {}
+  constructor(
+    readonly scopedRef: ScopedRef<Service>,
+    readonly reload: IO<never, unknown, void>,
+  ) {}
 
   get get(): UIO<Service> {
     return this.scopedRef.get;

package/_src/Reloadable.ts

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

package/_src/RuntimeFlags.ts

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

package/_src/STM/definition.ts

@@ -67,7 +67,10 @@ export class Effect<R, E, A> extends STM<R, E, A> {
 
 export class OnFailure<R, E, A, E1> extends STM<R, E1, A> {
   readonly stmOpCode = STMTag.OnFailure;
-  constructor(readonly stm: STM<R, E, A>, readonly onFailure: (e: E) => STM<R, E1, A>) {
+  constructor(
+    readonly stm: STM<R, E, A>,
+    readonly onFailure: (e: E) => STM<R, E1, A>,
+  ) {
     super();
   }
   apply(a: A): STM<R, E, A> {
@@ -77,7 +80,10 @@ export class OnFailure<R, E, A, E1> extends STM<R, E1, A> {
 
 export class OnRetry<R, E, A> extends STM<R, E, A> {
   readonly stmOpCode = STMTag.OnRetry;
-  constructor(readonly stm: STM<R, E, A>, readonly onRetry: STM<R, E, A>) {
+  constructor(
+    readonly stm: STM<R, E, A>,
+    readonly onRetry: STM<R, E, A>,
+  ) {
     super();
   }
   apply(a: A): STM<R, E, A> {
@@ -87,7 +93,10 @@ export class OnRetry<R, E, A> extends STM<R, E, A> {
 
 export class OnSuccess<R, E, A, B> extends STM<R, E, B> {
   readonly stmOpCode = STMTag.OnSuccess;
-  constructor(readonly stm: STM<R, E, A>, readonly apply: (a: A) => STM<R, E, B>) {
+  constructor(
+    readonly stm: STM<R, E, A>,
+    readonly apply: (a: A) => STM<R, E, B>,
+  ) {
     super();
   }
 }
@@ -108,7 +117,10 @@ export class SucceedNow<A> extends STM<never, never, A> {
 
 export class ContramapEnvironment<R, E, A, R0> extends STM<R0, E, A> {
   readonly stmOpCode = STMTag.ContramapEnvironment;
-  constructor(readonly stm: STM<R, E, A>, readonly f: (_: Environment<R0>) => Environment<R>) {
+  constructor(
+    readonly stm: STM<R, E, A>,
+    readonly f: (_: Environment<R0>) => Environment<R>,
+  ) {
     super();
   }
 }

package/_src/STM/driver.ts

@@ -16,7 +16,12 @@ export class STMDriver<R, E, A> {
   private contStack: Stack<Cont>;
   private envStack: Stack<Environment<unknown>>;
 
-  constructor(readonly self: STM<R, E, A>, readonly journal: Journal, readonly fiberId: FiberId, r0: Environment<R>) {
+  constructor(
+    readonly self: STM<R, E, A>,
+    readonly journal: Journal,
+    readonly fiberId: FiberId,
+    r0: Environment<R>,
+  ) {
     this.contStack = Stack();
     this.envStack  = Stack.single(r0);
   }

package/_src/STM.ts

@@ -1,10 +1,12 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: STM/*.ts }
-export * from "./STM/api.js";
-export * from "./STM/definition.js";
 export * from "./STM/driver.js";
+export * from "./STM/definition.js";
+export * from "./STM/api.js";
 // codegen:end
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: STM/api/*.ts }
-export * from "./STM/api/atomically.js";
-export * from "./STM/api/core-api.js";
 export * from "./STM/api/core-constructors.js";
+export * from "./STM/api/core-api.js";
+export * from "./STM/api/atomically.js";
 // codegen:end

package/_src/Schedule.ts

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

package/_src/Scope/Finalizer.ts

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

package/_src/Scope/ReleaseMap/definition.ts

@@ -1,6 +1,10 @@
 export class Exited {
   readonly _tag = "Exited";
-  constructor(readonly nextKey: number, readonly exit: Exit<any, any>, readonly update: (_: Finalizer) => Finalizer) {}
+  constructor(
+    readonly nextKey: number,
+    readonly exit: Exit<any, any>,
+    readonly update: (_: Finalizer) => Finalizer,
+  ) {}
 }
 
 export class Running {

package/_src/Scope/ReleaseMap.ts

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

package/_src/Scope/api.ts

@@ -1,3 +1,5 @@
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+
 import { Closeable } from "./definition.js";
 import { ReleaseMap } from "./ReleaseMap.js";
 
@@ -42,8 +44,8 @@ export const global: Scope.Closeable = new (class extends Closeable {
   close(_exit: Lazy<Exit<any, any>>): UIO<void> {
     return IO.unit;
   }
-  get fork(): UIO<Scope.Closeable> {
-    return Scope.make;
+  forkWith(executionStrategy: Lazy<ExecutionStrategy>): UIO<Scope.Closeable> {
+    return Scope.makeWith(executionStrategy);
   }
 })();
 
@@ -53,32 +55,40 @@ export const global: Scope.Closeable = new (class extends Closeable {
  */
 export const make: UIO<Scope.Closeable> = makeWith(ExecutionStrategy.sequential);
 
+/**
+ * @tsplus getter fncts.io.Scope fork
+ */
+export function fork(scope: Scope): UIO<Scope.Closeable> {
+  return scope.forkWith(scope.executionStrategy);
+}
+
 /**
  * @tsplus static fncts.io.ScopeOps makeWith
  * @tsplus static fncts.io.Scope.CloseableOps makeWith
  */
-export function makeWith(executionStrategy: Lazy<ExecutionStrategy>, __tsplusTrace?: string): UIO<Scope.Closeable> {
-  return ReleaseMap.make.map(
-    (releaseMap) =>
-      new (class extends Closeable {
-        addFinalizerExit(finalizer: Finalizer): UIO<void> {
-          return releaseMap.add(finalizer).asUnit;
-        }
-        close(exit: Lazy<Exit<any, any>>): UIO<void> {
-          return IO.defer(releaseMap.releaseAll(exit(), executionStrategy()).asUnit);
-        }
-        get fork() {
-          return IO.uninterruptible(
-            Do((_) => {
-              const scope     = _(Scope.make);
-              const finalizer = _(releaseMap.add(Finalizer.get((exit) => scope.close(exit))));
-              _(scope.addFinalizerExit(finalizer));
-              return scope;
-            }),
-          );
-        }
-      })(),
-  );
+export function makeWith(executionStrategy0: Lazy<ExecutionStrategy>, __tsplusTrace?: string): UIO<Scope.Closeable> {
+  return ReleaseMap.make.map((releaseMap) => {
+    const executionStrategy = executionStrategy0();
+    return new (class extends Closeable {
+      addFinalizerExit(finalizer: Finalizer): UIO<void> {
+        return releaseMap.add(finalizer).asUnit;
+      }
+      close(exit: Lazy<Exit<any, any>>): UIO<void> {
+        return IO.defer(releaseMap.releaseAll(exit(), executionStrategy).asUnit);
+      }
+      executionStrategy: ExecutionStrategy = executionStrategy;
+      forkWith(executionStrategy: Lazy<ExecutionStrategy>) {
+        return IO.uninterruptible(
+          Do((_) => {
+            const scope     = _(Scope.makeWith(executionStrategy));
+            const finalizer = _(releaseMap.add(Finalizer.get((exit) => scope.close(exit))));
+            _(scope.addFinalizerExit(finalizer));
+            return scope;
+          }),
+        );
+      }
+    })();
+  });
 }
 
 /**
@@ -100,10 +110,10 @@ export function unsafeMakeWith(executionStrategy: ExecutionStrategy, __tsplusTra
     close(exit: Lazy<Exit<any, any>>): UIO<void> {
       return IO.defer(releaseMap.releaseAll(exit(), executionStrategy).asUnit);
     }
-    get fork() {
+    forkWith(executionStrategy: Lazy<ExecutionStrategy>) {
       return IO.uninterruptible(
         Do((_) => {
-          const scope     = _(Scope.make);
+          const scope     = _(Scope.makeWith(executionStrategy));
           const finalizer = _(releaseMap.add(Finalizer.get((exit) => scope.close(exit))));
           _(scope.addFinalizerExit(finalizer));
           return scope;

package/_src/Scope/definition.ts

@@ -8,7 +8,8 @@ export type ScopeTypeId = typeof ScopeTypeId;
 export abstract class Scope {
   readonly [ScopeTypeId]: ScopeTypeId = ScopeTypeId;
   abstract addFinalizerExit(finalizer: Finalizer): UIO<void>;
-  abstract fork: UIO<Scope.Closeable>;
+  abstract forkWith(executionStrategy: Lazy<ExecutionStrategy>): UIO<Scope.Closeable>;
+  executionStrategy: ExecutionStrategy = ExecutionStrategy.sequential;
 }
 
 /**

package/_src/Scope.ts

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

package/_src/ScopedRef.ts

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

package/_src/Sink/api.ts

@@ -19,9 +19,9 @@ export function zipLeft<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
 /**
  * Like {@link zipConcurrent}, but keeps only the result from this sink
  *
- * @tsplus pipeable fncts.io.Sink zipLeftC
+ * @tsplus pipeable fncts.io.Sink zipLeftConcurrent
  */
-export function zipLeftC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
+export function zipLeftConcurrent<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
   that: Lazy<Sink<R1, E1, In1, L1, Z1>>,
   __tsplusTrace?: string,
 ) {
@@ -47,9 +47,9 @@ export function zipRight<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
 /**
  * Like {@link zipConcurrent}, but keeps only the result from the `that` sink
  *
- * @tsplus pipeable fncts.io.Sink zipRightC
+ * @tsplus pipeable fncts.io.Sink zipRightConcurrent
  */
-export function zipRightC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
+export function zipRightConcurrent<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
   that: Lazy<Sink<R1, E1, In1, L1, Z1>>,
   __tsplusTrace?: string,
 ) {

package/_src/Sink.ts

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

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/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();
   }
 }

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>(

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));