@fncts/io 0.0.38 → 0.0.40

package/_src/Ref/DerivedAll.ts

@@ -34,8 +34,9 @@ export class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB,
         new DerivedAll((f) =>
           f(
             value,
-            (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 })),
           ),
         ),
     );
@@ -53,28 +54,30 @@ export class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB,
         new DerivedAll((f) =>
           f(
             value,
-            (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 })),
           ),
         ),
     );
   }
 
   get get(): FIO<EB, B> {
-    return this.use((value, getEither) => value.get.flatMap((s) => getEither(s).match(IO.failNow, IO.succeedNow)));
+    return this.use((value, getEither) =>
+      value.get.flatMap((s) => getEither(s).match({ Left: IO.failNow, Right: IO.succeedNow })),
+    );
   }
 
   set(a: A): FIO<EA, void> {
     return this.use(
       (value, _, setEither) =>
         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,
     );
   }
@@ -83,16 +86,16 @@ export class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB,
     return this.use(
       (value, getEither, setEither) =>
         value.modify((s) =>
-          getEither(s).match(
-            (e) => tuple(Either.left(e), s),
-            (a1) => {
+          getEither(s).match({
+            Left: (e) => tuple(Either.left(e), s),
+            Right: (a1) => {
               const [b, a2] = f(a1);
-              return setEither(a2)(s).match(
-                (e) => tuple(Either.left(e), s),
-                (s) => tuple(Either.right<EA | EB, C>(b), s),
-              );
+              return setEither(a2)(s).match({
+                Left: (e) => tuple(Either.left(e), s),
+                Right: (s) => tuple(Either.right<EA | EB, C>(b), s),
+              });
             },
-          ),
+          }),
         ).absolve,
     );
   }

package/_src/Ref/Synchronized.ts

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

package/_src/Ref/api.ts

@@ -2,15 +2,16 @@ import type { PRef } from "./definition.js";
 
 import { identity } from "@fncts/base/data/function";
 
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: api/*.ts }
-export * from "./api/collect.js";
-export * from "./api/dimap.js";
-export * from "./api/filter.js";
-export * from "./api/get.js";
-export * from "./api/match.js";
-export * from "./api/matchAll.js";
-export * from "./api/modify.js";
 export * from "./api/set.js";
+export * from "./api/modify.js";
+export * from "./api/matchAll.js";
+export * from "./api/match.js";
+export * from "./api/get.js";
+export * from "./api/filter.js";
+export * from "./api/dimap.js";
+export * from "./api/collect.js";
 // codegen:end
 
 /**

package/_src/Ref.ts

@@ -1,15 +1,17 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Ref/*.ts }
-export * from "./Ref/api.js";
-export * from "./Ref/Atomic.js";
-export * from "./Ref/constructors.js";
 export * from "./Ref/definition.js";
-export * from "./Ref/Derived.js";
-export * from "./Ref/DerivedAll.js";
+export * from "./Ref/constructors.js";
+export * from "./Ref/api.js";
 export * from "./Ref/Synchronized.js";
+export * from "./Ref/DerivedAll.js";
+export * from "./Ref/Derived.js";
+export * from "./Ref/Atomic.js";
 // codegen:end
 
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Ref/Synchronized/*.ts }
-export * from "./Ref/Synchronized/api.js";
-export * from "./Ref/Synchronized/constructors.js";
 export * from "./Ref/Synchronized/definition.js";
+export * from "./Ref/Synchronized/constructors.js";
+export * from "./Ref/Synchronized/api.js";
 // codegen:end

package/_src/RefSubject/Atomic.ts

@@ -64,9 +64,17 @@ export class AtomicRefSubject<E, A> extends RefSubjectInternal<never, E, A, A> {
 }
 
 class AtomicDimapRef<A, B> extends Atomic<B> {
-  constructor(readonly ref: Atomic<A>, readonly f: (a: A) => B, readonly g: (b: B) => A) {
+  constructor(
+    readonly ref: Atomic<A>,
+    readonly f: (a: A) => B,
+    readonly g: (b: B) => A,
+  ) {
     const value = new (class extends AtomicReference<B> {
-      constructor(readonly ref: AtomicReference<A>, readonly f: (a: A) => B, readonly g: (b: B) => A) {
+      constructor(
+        readonly ref: AtomicReference<A>,
+        readonly f: (a: A) => B,
+        readonly g: (b: B) => A,
+      ) {
         super(f(ref.initial));
       }
 
@@ -91,7 +99,10 @@ class AtomicDimapRef<A, B> extends Atomic<B> {
 }
 
 class AtomicEmitRef<E, A> extends Atomic<A> {
-  constructor(readonly ref: Atomic<A>, readonly sink: Sink<never, E, A>) {
+  constructor(
+    readonly ref: Atomic<A>,
+    readonly sink: Sink<never, E, A>,
+  ) {
     super(ref.value);
   }
 

package/_src/RefSubject/Synchronized/definition.ts

@@ -31,7 +31,10 @@ export class SynchronizedRefSubjectInternal<R, E, A, B>
   implements SynchronizedRefSubject<R, E, A, B>
 {
   readonly [SynchronizedRefSubjectTypeId]: SynchronizedRefSubjectTypeId = SynchronizedRefSubjectTypeId;
-  constructor(readonly semaphore: TSemaphore, readonly ref: RefSubjectInternal<R, E, A, B>) {
+  constructor(
+    readonly semaphore: TSemaphore,
+    readonly ref: RefSubjectInternal<R, E, A, B>,
+  ) {
     super();
   }
 

package/_src/RefSubject/api.ts

@@ -45,7 +45,11 @@ export function set<A>(a: A, __tsplusTrace?: string) {
 }
 
 class Dimap<R, E, A, B, C, D> extends RefSubjectInternal<R, E, C, D> {
-  constructor(readonly ref: RefSubjectInternal<R, E, A, B>, readonly f: (c: C) => A, readonly g: (b: B) => D) {
+  constructor(
+    readonly ref: RefSubjectInternal<R, E, A, B>,
+    readonly f: (c: C) => A,
+    readonly g: (b: B) => D,
+  ) {
     super();
   }
 

package/_src/RefSubject/definition.ts

@@ -62,6 +62,7 @@ export abstract class RefSubjectInternal<R, E, A, B>
 }
 
 /**
+ * @tsplus static fncts.io.Push.RefSubjectOps concrete
  * @tsplus macro remove
  */
 export function concrete<R, E, A, B>(_: RefSubject<R, E, A, B>): asserts _ is RefSubjectInternal<R, E, A, B> {

package/_src/RefSubject.ts

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

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/RuntimeFlags.ts

@@ -14,7 +14,7 @@ export type RuntimeFlags = number & {
  */
 export interface RuntimeFlagsOps {}
 
-export const RuntimeFlags: RuntimeFlagsOps = Newtype();
+export const RuntimeFlags: RuntimeFlagsOps = {};
 
 export declare namespace RuntimeFlags {
   type Patch = RuntimeFlagsPatch;

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/api/core-api.ts

@@ -65,6 +65,6 @@ export function matchSTM<E, A, R1, E1, B, R2, E2, C>(
     return self
       .map(Either.right)
       .catchAll((e) => g(e).map(Either.left))
-      .flatMap((ca) => ca.match(STM.succeedNow, f));
+      .flatMap((ca) => ca.match({ Left: STM.succeedNow, Right: f }));
   };
 }

package/_src/STM/api.ts

@@ -429,7 +429,7 @@ export function foreach<A, R, E, B>(
  * @tsplus static fncts.io.STMOps fromEither
  */
 export function fromEither<E, A>(e: Lazy<Either<E, A>>, __tsplusTrace?: string): STM<never, E, A> {
-  return STM.defer(e().match(STM.failNow, STM.succeedNow));
+  return STM.defer(e().match({ Left: STM.failNow, Right: STM.succeedNow }));
 }
 
 /**
@@ -438,7 +438,7 @@ export function fromEither<E, A>(e: Lazy<Either<E, A>>, __tsplusTrace?: string):
  * @tsplus static fncts.io.STMOps fromEitherNow
  */
 export function fromEitherNow<E, A>(e: Either<E, A>, __tsplusTrace?: string): STM<never, E, A> {
-  return e.match(STM.failNow, STM.succeedNow);
+  return e.match({ Left: STM.failNow, Right: STM.succeedNow });
 }
 
 /**
@@ -553,7 +553,7 @@ export function isSuccess<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string) {
 export function left<R, E, B, C>(stm: STM<R, E, Either<B, C>>, __tsplusTrace?: string): STM<R, Maybe<E>, B> {
   return stm.matchSTM(
     (e) => STM.fail(Just(e)),
-    (bc) => bc.match(STM.succeedNow, () => STM.failNow(Nothing())),
+    (bc) => bc.match({ Left: STM.succeedNow, Right: () => STM.failNow(Nothing()) }),
   );
 }
 
@@ -564,7 +564,7 @@ export function left<R, E, B, C>(stm: STM<R, E, Either<B, C>>, __tsplusTrace?: s
  */
 export function leftOrFail<C, E1>(orFail: (c: C) => E1, __tsplusTrace?: string) {
   return <R, E, B>(stm: STM<R, E, Either<B, C>>): STM<R, E | E1, B> => {
-    return stm.flatMap((bc) => bc.match(STM.succeedNow, (c) => STM.fail(orFail(c))));
+    return stm.flatMap((bc) => bc.match({ Left: STM.succeedNow, Right: (c) => STM.fail(orFail(c)) }));
   };
 }
 

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/api.ts

@@ -618,17 +618,17 @@ export function reconsiderIO<S, O, R1, O1>(
         decision.match(
           () =>
             f(state, out, decision).map((r) =>
-              r.match(
-                (out1) => [state, out1, Decision.Done],
-                ([out1, _]) => [state, out1, Decision.Done],
-              ),
+              r.match({
+                Left: (out1) => [state, out1, Decision.Done],
+                Right: ([out1, _]) => [state, out1, Decision.Done],
+              }),
             ),
           () =>
             f(state, out, decision).map((r) =>
-              r.match(
-                (out1) => [state, out1, Decision.Done],
-                ([out1, interval]) => [state, out1, Decision.continueWith(interval)],
-              ),
+              r.match({
+                Left: (out1) => [state, out1, Decision.Done],
+                Right: ([out1, interval]) => [state, out1, Decision.continueWith(interval)],
+              }),
             ),
         ),
       ),

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/api.ts

@@ -25,13 +25,14 @@ class Synch<A> extends ScopedRef<A> {
     return this.ref.modifyIO(([oldScope, a]) =>
       IO.uninterruptibleMask((restore) =>
         Do((_) => {
+          _(oldScope.close(Exit.unit));
           const newScope = _(Scope.make);
-          const exit     = _(restore(acquire.provideSomeService(newScope, Scope.Tag)).result);
+          const exit     = _(restore(newScope.extend(acquire)).result);
           return _(
             exit.match(
               (cause): UIO<readonly [FIO<E, void>, readonly [Scope.Closeable, A]]> =>
-                newScope.close(Exit.unit).ignore.as([IO.failCauseNow(cause), [oldScope, a]] as const),
-              (a) => oldScope.close(Exit.unit).ignore.as([IO.unit, [newScope, a]] as const),
+                newScope.close(Exit.unit).as([IO.refailCause(cause), [oldScope, a]] as const),
+              (a) => IO.succeedNow([IO.unit, [newScope, a]] as const),
             ),
           );
         }),

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,
 ) {
@@ -567,20 +567,20 @@ function fromPushPull<R, E, In, L, Z>(
     (inp: Conc<In>) =>
       Channel.fromIO(push(Just(inp))).matchChannel(
         ([r, leftovers]) =>
-          r.match(
-            (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
-            (z) => Channel.writeNow(leftovers) > Channel.succeedNow(z),
-          ),
+          r.match({
+            Left: (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
+            Right: (z) => Channel.writeNow(leftovers) > Channel.succeedNow(z),
+          }),
         () => fromPushPull(push),
       ),
     Channel.failNow,
     () =>
       Channel.fromIO(push(Nothing())).matchChannel(
         ([r, leftovers]) =>
-          r.match(
-            (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
-            (z) => Channel.writeNow(leftovers) > Channel.succeedNow(z),
-          ),
+          r.match({
+            Left: (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
+            Right: (z) => Channel.writeNow(leftovers) > Channel.succeedNow(z),
+          }),
         () => Channel.fromIO(IO.halt(new Error("empty sink"))),
       ),
   );

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