@fncts/io 0.0.11 → 0.0.14

package/IO/definition.d.ts

@@ -1,11 +1,11 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { RuntimeConfig } from "@fncts/io/RuntimeConfig";
-import { FiberId } from "@fncts/base/data/FiberId";
-import { Either } from "@fncts/base/data/Either";
-import { Cause } from "@fncts/base/data/Cause";
-import { Maybe } from "@fncts/base/data/Maybe";
-import { FiberScope } from "@fncts/io/FiberScope/definition";
-import { Lazy } from "@fncts/base/data/function";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { FiberScope } from "@fncts/io/FiberScope";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
 import { InterruptStatus } from "@fncts/io/InterruptStatus";
 import { FiberDescriptor } from "@fncts/io/FiberDescriptor";
@@ -13,12 +13,18 @@ import { Supervisor } from "@fncts/io/Supervisor/definition";
 import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { FiberRefs } from "@fncts/io/FiberRefs";
 import { LogLevel } from "@fncts/io/LogLevel";
-import { Exit } from "@fncts/base/data/Exit";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import type { Trace as Trace_ } from "@fncts/base/data/Trace";
 import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
 export declare const IOTypeId: unique symbol;
 export declare type IOTypeId = typeof IOTypeId;
-export interface IOF extends IO<any, any, any> {
+export interface IOF extends HKT {
+    type: IO<this["R"], this["E"], this["A"]>;
+    variance: {
+        R: "-";
+        E: "+";
+        A: "+";
+    };
 }
 /**
  * @tsplus type fncts.io.IO
@@ -26,11 +32,9 @@ export interface IOF extends IO<any, any, any> {
  */
 export declare abstract class IO<R, E, A> {
     readonly _typeId: IOTypeId;
-    readonly [HKT.F]: IOF;
-    readonly [HKT.R]: (_: R) => void;
-    readonly [HKT.E]: () => E;
-    readonly [HKT.A]: () => A;
-    readonly [HKT.T]: IO<HKT._R<this>, HKT._E<this>, HKT._A<this>>;
+    _R: () => R;
+    _E: () => E;
+    _A: () => A;
 }
 /**
  * @tsplus type fncts.io.IOAspects
@@ -47,14 +51,20 @@ export declare const IOAspects: IOAspects;
  */
 export declare function unifyIO<X extends IO<any, any, any>>(self: X): IO<[
     X
-] extends [IO<infer R, any, any>] ? R : never, [
+] extends [{
+    _R: () => infer R;
+}] ? R : never, [
     X
-] extends [IO<any, infer E, any>] ? E : never, [
+] extends [{
+    _E: () => infer E;
+}] ? E : never, [
     X
-] extends [IO<any, any, infer A>] ? A : never>;
-export declare type UIO<A> = IO<unknown, never, A>;
+] extends [{
+    _A: () => infer A;
+}] ? A : never>;
+export declare type UIO<A> = IO<never, never, A>;
 export declare type URIO<R, A> = IO<R, never, A>;
-export declare type FIO<E, A> = IO<unknown, E, A>;
+export declare type FIO<E, A> = IO<never, E, A>;
 export declare const enum IOTag {
     SucceedNow = "SucceedNow",
     Chain = "Chain",
@@ -89,7 +99,7 @@ export declare function isIO(u: unknown): u is IO<any, any, any>;
 /**
  * @internal
  */
-export declare class Chain<R, R1, E, E1, A, A1> extends IO<R & R1, E | E1, A1> {
+export declare class Chain<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A1> {
     readonly io: IO<R, E, A>;
     readonly f: (a: A) => IO<R1, E1, A1>;
     readonly trace?: string | undefined;
@@ -99,7 +109,7 @@ export declare class Chain<R, R1, E, E1, A, A1> extends IO<R & R1, E | E1, A1> {
 /**
  * @internal
  */
-export declare class SucceedNow<A> extends IO<unknown, never, A> {
+export declare class SucceedNow<A> extends IO<never, never, A> {
     readonly value: A;
     readonly trace?: string | undefined;
     readonly _tag = IOTag.SucceedNow;
@@ -108,19 +118,19 @@ export declare class SucceedNow<A> extends IO<unknown, never, A> {
 /**
  * @internal
  */
-export declare class Succeed<A> extends IO<unknown, never, A> {
+export declare class Succeed<A> extends IO<never, never, A> {
     readonly effect: () => A;
     readonly trace?: string | undefined;
     readonly _tag = IOTag.Succeed;
     constructor(effect: () => A, trace?: string | undefined);
 }
-export declare class SucceedWith<A> extends IO<unknown, never, A> {
+export declare class SucceedWith<A> extends IO<never, never, A> {
     readonly effect: (runtimeConfig: RuntimeConfig, fiberId: FiberId) => A;
     readonly trace?: string | undefined;
     readonly _tag = IOTag.SucceedWith;
     constructor(effect: (runtimeConfig: RuntimeConfig, fiberId: FiberId) => A, trace?: string | undefined);
 }
-export declare class Trace extends IO<unknown, never, Trace_> {
+export declare class Trace extends IO<never, never, Trace_> {
     readonly trace?: string | undefined;
     readonly _tag = IOTag.Trace;
     constructor(trace?: string | undefined);
@@ -128,7 +138,7 @@ export declare class Trace extends IO<unknown, never, Trace_> {
 /**
  * @internal
  */
-export declare class Async<R, E, A, R1> extends IO<R & R1, E, A> {
+export declare class Async<R, E, A, R1> extends IO<R | R1, E, A> {
     readonly register: (f: (_: IO<R, E, A>) => void) => Either<Canceler<R1>, IO<R, E, A>>;
     readonly blockingOn: FiberId;
     readonly trace?: string | undefined;
@@ -138,7 +148,7 @@ export declare class Async<R, E, A, R1> extends IO<R & R1, E, A> {
 /**
  * @internal
  */
-export declare class Match<R, E, A, R1, E1, B, R2, E2, C> extends IO<R & R1 & R2, E1 | E2, B | C> {
+export declare class Match<R, E, A, R1, E1, B, R2, E2, C> extends IO<R | R1 | R2, E1 | E2, B | C> {
     readonly io: IO<R, E, A>;
     readonly onFailure: (cause: Cause<E>) => IO<R1, E1, B>;
     readonly apply: (a: A) => IO<R2, E2, C>;
@@ -160,7 +170,7 @@ export declare class Fork<R, E, A> extends IO<R, never, FiberContext<E, A>> {
 /**
  * @internal
  */
-export declare class Fail<E> extends IO<unknown, E, never> {
+export declare class Fail<E> extends IO<never, E, never> {
     readonly cause: Lazy<Cause<E>>;
     readonly trace?: string | undefined;
     readonly _tag = IOTag.Fail;
@@ -169,7 +179,7 @@ export declare class Fail<E> extends IO<unknown, E, never> {
 /**
  * @internal
  */
-export declare class Yield extends IO<unknown, never, void> {
+export declare class Yield extends IO<never, never, void> {
     readonly trace?: string | undefined;
     readonly _tag = IOTag.Yield;
     constructor(trace?: string | undefined);
@@ -195,7 +205,7 @@ export declare class DeferWith<R, E, A> extends IO<R, E, A> {
 /**
  * @internal
  */
-export declare class Race<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3> extends IO<R & R1 & R2 & R3, E2 | E3, A2 | A3> {
+export declare class Race<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3> extends IO<R | R1 | R2 | R3, E2 | E3, A2 | A3> {
     readonly left: IO<R, E, A>;
     readonly right: IO<R1, E1, A1>;
     readonly leftWins: (exit: Fiber<E, A>, fiber: Fiber<E1, A1>) => IO<R2, E2, A2>;
@@ -245,7 +255,7 @@ export declare class Supervise<R, E, A> extends IO<R, E, A> {
 /**
  * @internal
  */
-export declare class FiberRefModify<A, B> extends IO<unknown, never, B> {
+export declare class FiberRefModify<A, B> extends IO<never, never, B> {
     readonly fiberRef: FiberRef<unknown>;
     readonly f: (a: A) => readonly [B, A];
     readonly trace?: string | undefined;
@@ -260,7 +270,7 @@ export declare class FiberRefLocally<V, R, E, A> extends IO<R, E, A> {
     readonly _tag = IOTag.FiberRefLocally;
     constructor(localValue: V, fiberRef: FiberRef<V>, io: IO<R, E, A>, trace?: string | undefined);
 }
-export declare class FiberRefDelete extends IO<unknown, never, void> {
+export declare class FiberRefDelete extends IO<never, never, void> {
     readonly fiberRef: FiberRef<unknown>;
     readonly trace?: string | undefined;
     readonly _tag = IOTag.FiberRefDelete;
@@ -273,7 +283,7 @@ export declare class FiberRefWith<A, P, R, E, B> extends IO<R, E, B> {
     readonly _tag = IOTag.FiberRefWith;
     constructor(fiberRef: FiberRef<A>, f: (a: A) => IO<R, E, B>, trace?: string | undefined);
 }
-export declare class FiberRefModifyAll<A> extends IO<unknown, never, A> {
+export declare class FiberRefModifyAll<A> extends IO<never, never, A> {
     readonly f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs) => readonly [A, FiberRefs];
     readonly trace?: string | undefined;
     readonly _tag = IOTag.FiberRefModifyAll;
@@ -304,14 +314,14 @@ export declare class GetRuntimeConfig<R, E, A> extends IO<R, E, A> {
     readonly _tag = IOTag.GetRuntimeConfig;
     constructor(f: (_: RuntimeConfig) => IO<R, E, A>, trace?: string | undefined);
 }
-export declare class Ensuring<R, E, A, R1> extends IO<R & R1, E, A> {
+export declare class Ensuring<R, E, A, R1> extends IO<R | R1, E, A> {
     readonly io: IO<R, E, A>;
     readonly finalizer: IO<R1, never, any>;
     readonly trace?: string | undefined;
     readonly _tag = IOTag.Ensuring;
     constructor(io: IO<R, E, A>, finalizer: IO<R1, never, any>, trace?: string | undefined);
 }
-export declare class Logged extends IO<unknown, never, void> {
+export declare class Logged extends IO<never, never, void> {
     readonly message: () => string;
     readonly cause: Cause<any>;
     readonly overrideLogLevel: Maybe<LogLevel>;
@@ -321,7 +331,7 @@ export declare class Logged extends IO<unknown, never, void> {
     readonly _tag = IOTag.Logged;
     constructor(message: () => string, cause: Cause<any>, overrideLogLevel: Maybe<LogLevel>, trace?: string | undefined, overrideRef1?: FiberRef<unknown> | null, overrideValue1?: unknown | null);
 }
-export declare class SetRuntimeConfig extends IO<unknown, never, void> {
+export declare class SetRuntimeConfig extends IO<never, never, void> {
     readonly runtimeConfig: RuntimeConfig;
     readonly trace?: string | undefined;
     readonly _tag = IOTag.SetRuntimeConfig;

package/IO/runtime.d.ts

@@ -1,49 +1,62 @@
-import { Environment } from "@fncts/base/data/Environment";
+import { Environment } from "@fncts/base/data/Environment/definition";
 import { RuntimeConfig } from "@fncts/io/RuntimeConfig";
 import { IO, URIO } from "@fncts/io/IO/definition";
-import { Exit } from "@fncts/base/data/Exit";
-import { FiberId } from "@fncts/base/data/FiberId";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { TraceElement } from "@fncts/base/data/TraceElement/definition";
 import { InterruptStatus } from "@fncts/io/InterruptStatus";
-import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { FiberRef } from "@fncts/io/FiberRef/definition";
-import { Cons } from "@fncts/base/collection/immutable/List";
-import { FiberScope } from "@fncts/io/FiberScope/definition";
+import { Cons } from "@fncts/base/collection/immutable/List/definition";
+import { FiberScope } from "@fncts/io/FiberScope";
 import { Supervisor } from "@fncts/io/Supervisor/definition";
-import { Nothing } from "@fncts/base/data/Maybe";
+import { Nothing } from "@fncts/base/data/Maybe/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
+import { FiberContext } from "@fncts/io/Fiber";
 export declare class Runtime<R> {
     readonly environment: Environment<R>;
     readonly runtimeConfig: RuntimeConfig;
     constructor(environment: Environment<R>, runtimeConfig: RuntimeConfig);
-    unsafeRunWith: <E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>, k: (exit: import("@fncts/base/data/Exit").Exit<E, A>) => any, __tsplusTrace?: string) => (fiberId: FiberId) => (f: (exit: import("@fncts/base/data/Exit").Exit<E, A>) => any) => void;
+    unsafeRunFiber: <E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>, __tsplusTrace?: string) => FiberContext<E, A>;
+    unsafeRunWith: <E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>, k: (exit: import("@fncts/base/data/Exit.js").Exit<E, A>) => any, __tsplusTrace?: string) => (fiberId: FiberId) => (f: (exit: import("@fncts/base/data/Exit.js").Exit<E, A>) => any) => void;
     unsafeRunAsync: <E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>, __tsplusTrace?: string) => void;
-    unsafeRunAsyncWith: <E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>, k: (exit: import("@fncts/base/data/Exit").Exit<E, A>) => any, __tsplusTrace?: string) => void;
-    unsafeRunPromiseExit: <E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>, __tsplusTrace?: string) => Promise<import("@fncts/base/data/Exit").Exit<E, A>>;
+    unsafeRunAsyncWith: <E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>, k: (exit: import("@fncts/base/data/Exit.js").Exit<E, A>) => any, __tsplusTrace?: string) => void;
+    unsafeRunPromiseExit: <E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>, __tsplusTrace?: string) => Promise<import("@fncts/base/data/Exit.js").Exit<E, A>>;
+    unsafeRunSyncExit: <E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>, __tsplusTrace?: string) => import("@fncts/base/data/Exit.js").Exit<E, A>;
 }
 /**
  * @tsplus static fncts.io.IOOps runtime
  * @tsplus location "@fncts/io/IO/runtime"
  */
 export declare function runtime<R>(__tsplusTrace?: string): URIO<R, Runtime<R>>;
-export declare const defaultRuntimeConfig: import("../RuntimeConfig").RuntimeConfig;
-export declare const defaultRuntime: Runtime<unknown>;
+export declare const defaultRuntimeConfig: import("../RuntimeConfig.js").RuntimeConfig;
+export declare const defaultRuntime: Runtime<never>;
+/**
+ * @tsplus fluent fncts.io.IO unsafeRunFiber
+ * @tsplus location "@fncts/io/IO/runtime"
+ */
+export declare const unsafeRunFiber: <E, A>(io: import("@fncts/io/IO/definition").IO<never, E, A>, __tsplusTrace?: string) => FiberContext<E, A>;
 /**
  * @tsplus fluent fncts.io.IO unsafeRunAsync
  * @tsplus location "@fncts/io/IO/runtime"
  */
-export declare const unsafeRunAsync: <E, A>(io: import("@fncts/io/IO/definition").IO<unknown, E, A>, __tsplusTrace?: string) => void;
+export declare const unsafeRunAsync: <E, A>(io: import("@fncts/io/IO/definition").IO<never, E, A>, __tsplusTrace?: string) => void;
 /**
  * @tsplus fluent fncts.io.IO unsafeRunAsyncWith
  * @tsplus location "@fncts/io/IO/runtime"
  */
-export declare const unsafeRunAsyncWith: <E, A>(io: import("@fncts/io/IO/definition").IO<unknown, E, A>, k: (exit: import("@fncts/base/data/Exit").Exit<E, A>) => any, __tsplusTrace?: string) => void;
+export declare const unsafeRunAsyncWith: <E, A>(io: import("@fncts/io/IO/definition").IO<never, E, A>, k: (exit: import("@fncts/base/data/Exit.js").Exit<E, A>) => any, __tsplusTrace?: string) => void;
 /**
  * @tsplus fluent fncts.io.IO unsafeRunPromiseExit
  * @tsplus location "@fncts/io/IO/runtime"
  */
-export declare const unsafeRunPromiseExit: <E, A>(io: import("@fncts/io/IO/definition").IO<unknown, E, A>, __tsplusTrace?: string) => Promise<import("@fncts/base/data/Exit").Exit<E, A>>;
+export declare const unsafeRunPromiseExit: <E, A>(io: import("@fncts/io/IO/definition").IO<never, E, A>, __tsplusTrace?: string) => Promise<import("@fncts/base/data/Exit.js").Exit<E, A>>;
 /**
  * @tsplus fluent fncts.io.IO unsafeRunWith
  * @tsplus location "@fncts/io/IO/runtime"
  */
-export declare const unsafeRunWith: <E, A>(io: import("@fncts/io/IO/definition").IO<unknown, E, A>, k: (exit: import("@fncts/base/data/Exit").Exit<E, A>) => any, __tsplusTrace?: string) => (fiberId: FiberId) => (f: (exit: import("@fncts/base/data/Exit").Exit<E, A>) => any) => void;
+export declare const unsafeRunWith: <E, A>(io: import("@fncts/io/IO/definition").IO<never, E, A>, k: (exit: import("@fncts/base/data/Exit.js").Exit<E, A>) => any, __tsplusTrace?: string) => (fiberId: FiberId) => (f: (exit: import("@fncts/base/data/Exit.js").Exit<E, A>) => any) => void;
+/**
+ * @tsplus getter fncts.io.IO unsafeRunSyncExit
+ * @tsplus location "@fncts/io/IO/runtime"
+ */
+export declare const unsafeRunSyncExit: <E, A>(io: import("@fncts/io/IO/definition").IO<never, E, A>, __tsplusTrace?: string) => import("@fncts/base/data/Exit.js").Exit<E, A>;

package/IOEnv/definition.d.ts

@@ -1,8 +1,7 @@
-import { Has } from "@fncts/base/typeclass/Has";
 import { Clock } from "@fncts/io/Clock/definition";
 import { Random } from "@fncts/io/Random/definition";
 import { Console } from "@fncts/io/Console";
-export declare type IOEnv = Has<Clock> & Has<Console> & Has<Random>;
+export declare type IOEnv = Clock | Console | Random;
 /**
  * @tsplus type fncts.io.IOEnvOps
  */
@@ -13,4 +12,4 @@ export declare const IOEnv: IOEnvOps;
  * @tsplus static fncts.io.IOEnvOps environment
  * @tsplus location "@fncts/io/IOEnv/definition"
  */
-export declare const environment: import("@fncts/base/data/Environment").Environment<import("@fncts/base/typeclass").Has<import("../Clock").Clock> & import("@fncts/base/typeclass").Has<import("../Random").Random> & import("@fncts/base/typeclass").Has<Console>>;
+export declare const environment: import("@fncts/base/data/Environment").Environment<import("../Clock").Clock | Console | import("../Random").Random>;

package/IOEnv/live.d.ts

@@ -3,4 +3,4 @@ import { Console } from "@fncts/io/Console";
  * @tsplus static fncts.io.IOEnvOps Live
  * @tsplus location "@fncts/io/IOEnv/live"
  */
-export declare const live: import("../Layer").Layer<unknown, never, import("@fncts/base/typeclass").Has<import("../Clock").Clock> & import("@fncts/base/typeclass").Has<import("../Random").Random> & import("@fncts/base/typeclass").Has<Console>>;
+export declare const live: import("../Layer").Layer<never, never, import("../Clock").Clock | Console | import("../Random").Random>;

package/IOEnv/services.d.ts

@@ -1,5 +1,5 @@
 import { FiberRef } from "@fncts/io/FiberRef/definition";
-import { Environment } from "@fncts/base/data/Environment";
+import { Environment } from "@fncts/base/data/Environment/definition";
 import { IOEnv } from "@fncts/io/IOEnv";
 import type { Patch } from "@fncts/base/data/Patch";
 /**

package/IOSpec.d.ts

@@ -2,22 +2,21 @@ import { DefaultRunnableSpec } from "@fncts/test/control/DefaultRunnableSpec";
 import { suite, testIO } from "@fncts/test/api";
 import { Ref } from "@fncts/io/Ref";
 import { strictEqualTo, isTrue, isFalse, fails, isEmpty, isNothing, isUnit, isJust, isRight, isLeft, isLessThanOrEqualTo, isOnlyInterrupted, isInterrupted } from "@fncts/test/control/Assertion";
-import { List } from "@fncts/base/collection/immutable/List";
+import { List } from "@fncts/base/collection/immutable/List/definition";
 import { IO } from "@fncts/io/IO";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Future } from "@fncts/io/Future";
-import { Cause } from "@fncts/base/data/Cause";
-import { Exit } from "@fncts/base/data/Exit";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { UIO } from "@fncts/io/IO/definition";
 import { Clock } from "@fncts/io/Clock";
-import { Has } from "@fncts/base/typeclass/Has";
-import { Just, Nothing } from "@fncts/base/data/Maybe";
-import { Either } from "@fncts/base/data/Either";
+import { Just, Nothing } from "@fncts/base/data/Maybe/definition";
+import { Either } from "@fncts/base/data/Either/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
-import { HashSet } from "@fncts/base/collection/immutable/HashSet";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 import { Live } from "@fncts/test/control/Live";
 declare class IOSpec extends DefaultRunnableSpec {
-    spec: import("@fncts/test/control/Spec.js").Spec<import("@fncts/base/typeclass.js").Has<Live>, import("@fncts/test/data/TestFailure.js").AssertionFailure | import("@fncts/test/data/TestFailure.js").RuntimeFailure<import("@fncts/test/data/TestFailure.js").AssertionFailure | import("@fncts/test/data/TestFailure.js").RuntimeFailure<import("@fncts/base/collection/immutable/Conc.js").Conc<number>> | import("@fncts/test/data/TestFailure.js").RuntimeFailure<import("@fncts/base/collection/immutable/Conc.js").Conc<void>>>>;
+    spec: import("@fncts/test/control/Spec.js").Spec<Live, import("@fncts/test/data/TestFailure.js").AssertionFailure | import("@fncts/test/data/TestFailure.js").RuntimeFailure<import("@fncts/test/data/TestFailure.js").AssertionFailure | import("@fncts/test/data/TestFailure.js").RuntimeFailure<import("@fncts/base/collection/immutable/Conc.js").Conc<number>> | import("@fncts/test/data/TestFailure.js").RuntimeFailure<import("@fncts/base/collection/immutable/Conc.js").Conc<void>>>>;
 }
 declare const _default: IOSpec;
 export default _default;

package/Layer/MemoMap.d.ts

@@ -1,13 +1,12 @@
 import { Ref } from "@fncts/io/Ref";
-import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { FIO, IO, UIO } from "@fncts/io/IO/definition";
 import { Finalizer } from "@fncts/io/Scope/Finalizer";
 import { Scope } from "@fncts/io/Scope/definition";
 import { Layer } from "@fncts/io/Layer";
-import { Environment } from "@fncts/base/data/Environment";
+import { Environment } from "@fncts/base/data/Environment/definition";
 import { Future } from "@fncts/io/Future";
-import { Exit } from "@fncts/base/data/Exit";
-import { Has } from "@fncts/base/typeclass/Has";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import type { Fresh } from "@fncts/io/Layer/definition";
 /**
  * A `MemoMap` memoizes dependencies.
@@ -20,26 +19,26 @@ export declare class MemoMap {
      * returns it. Otherwise, obtains the dependency, stores it in the memo map,
      * and adds a finalizer to the outer `Managed`.
      */
-    getOrElseMemoize: <R, E, A>(scope: Scope, layer: import("@fncts/io/Layer/definition").Layer<R, E, A>) => import("../IO").IO<R, E, import("@fncts/base/data/Environment").Environment<A>>;
+    getOrElseMemoize: <R, E, A>(scope: Scope, layer: import("@fncts/io/Layer/definition").Layer<R, E, A>, __tsplusTrace?: string) => import("../IO").IO<R, E, import("@fncts/base/data/Environment").Environment<A>>;
 }
 /**
  * @tsplus fluent fncts.io.Layer isFresh
  * @tsplus location "@fncts/io/Layer/MemoMap"
  */
 export declare function isFresh<R, E, A>(self: Layer<R, E, A>): self is Fresh<R, E, A>;
-export declare function makeMemoMap(): UIO<MemoMap>;
+export declare function makeMemoMap(__tsplusTrace?: string): UIO<MemoMap>;
 /**
  * @tsplus getter fncts.io.Layer build
  * @tsplus location "@fncts/io/Layer/MemoMap"
  */
-export declare function build<R, E, A>(self: Layer<R, E, A>): IO<R & Has<Scope>, E, Environment<A>>;
+export declare function build<R, E, A>(self: Layer<R, E, A>, __tsplusTrace?: string): IO<R | Scope, E, Environment<A>>;
 /**
  * @tsplus fluent fncts.io.Layer build
  * @tsplus location "@fncts/io/Layer/MemoMap"
  */
-export declare function build_<R, E, A>(self: Layer<R, E, A>, scope: Scope): IO<R, E, Environment<A>>;
+export declare function build_<R, E, A>(self: Layer<R, E, A>, scope: Scope, __tsplusTrace?: string): IO<R, E, Environment<A>>;
 /**
  * @tsplus fluent fncts.io.Layer scope
  * @tsplus location "@fncts/io/Layer/MemoMap"
  */
-export declare function scope<R, E, A>(layer: Layer<R, E, A>, scope: Scope): IO<unknown, never, (_: MemoMap) => IO<R, E, Environment<A>>>;
+export declare function scope<R, E, A>(layer: Layer<R, E, A>, scope: Scope, __tsplusTrace?: string): IO<never, never, (_: MemoMap) => IO<R, E, Environment<A>>>;