@fncts/base 0.0.32 → 0.0.34

package/data/Either/api.d.ts

@@ -11,7 +11,7 @@ import { Left, Right } from "./definition.js";
  * @tsplus pipeable fncts.Either ap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function ap<A, E2>(fa: Either<E2, A>): <E1, B>(self: import("./definition.js").Either<E1, (a: A) => B>) => import("./definition.js").Either<E2 | E1, B>;
+export declare function ap<A, E2>(fa: Either<E2, A>): <E1, B>(self: import("./definition.js").Either<E1, (a: A) => B>) => Either<E1 | E2, B>;
 /**
  * @tsplus pipeable fncts.Either bimap
  * @tsplus location "@fncts/base/data/Either/api"
@@ -21,37 +21,37 @@ export declare function bimap<E1, A, E2, B>(f: (e: E1) => E2, g: (a: A) => B): (
  * @tsplus pipeable fncts.Either catchAll
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function catchAll<E1, E2, B>(f: (e: E1) => Either<E2, B>): <A>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E2, B | A>;
+export declare function catchAll<E1, E2, B>(f: (e: E1) => Either<E2, B>): <A>(self: Either<E1, A>) => Either<E2, A | B>;
 /**
  * @tsplus pipeable fncts.Either catchJust
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function catchJust<E1, E2, B>(f: (e: E1) => Maybe<Either<E2, B>>): <A>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E1 | E2, B | A>;
+export declare function catchJust<E1, E2, B>(f: (e: E1) => Maybe<Either<E2, B>>): <A>(self: Either<E1, A>) => Either<E1 | E2, A | B>;
 /**
  * @tsplus pipeable fncts.Either catchMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function catchMap<E, B>(f: (e: E) => B): <A>(self: import("./definition.js").Either<E, A>) => import("./definition.js").Either<never, B | A>;
+export declare function catchMap<E, B>(f: (e: E) => B): <A>(self: Either<E, A>) => Either<never, A | B>;
 /**
  * @tsplus pipeable fncts.Either flatMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function flatMap<A, E2, B>(f: (a: A) => Either<E2, B>): <E1>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E2 | E1, B>;
+export declare function flatMap<A, E2, B>(f: (a: A) => Either<E2, B>): <E1>(self: Either<E1, A>) => Either<E1 | E2, B>;
 /**
  * @tsplus pipeable fncts.Either foldLeft
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): <E>(self: import("./definition.js").Either<E, A>) => B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): <E>(self: Either<E, A>) => B;
 /**
  * @tsplus pipeable fncts.Either foldRight
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): <E>(self: import("./definition.js").Either<E, A>) => B;
+export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): <E>(self: Either<E, A>) => B;
 /**
  * @tsplus pipeable fncts.Either foldMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): <E>(self: import("./definition.js").Either<E, A>) => M;
+export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): <E>(self: Either<E, A>) => M;
 /**
  * @tsplus getter fncts.Either getLeft
  * @tsplus location "@fncts/base/data/Either/api"
@@ -66,7 +66,7 @@ export declare function getRight<E, A>(self: Either<E, A>): Maybe<A>;
  * @tsplus pipeable fncts.Either getOrElse
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function getOrElse<E, B>(orElse: (e: E) => B): <A>(self: import("./definition.js").Either<E, A>) => B | A;
+export declare function getOrElse<E, B>(orElse: (e: E) => B): <A>(self: Either<E, A>) => A | B;
 /**
  * @tsplus static fncts.EitherOps isEither
  * @tsplus location "@fncts/base/data/Either/api"
@@ -89,12 +89,12 @@ export declare function isRight<E, A>(self: Either<E, A>): self is Right<A>;
  * @tsplus pipeable fncts.Either map
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function map<A, B>(f: (a: A) => B): <E>(self: import("./definition.js").Either<E, A>) => import("./definition.js").Either<E, B>;
+export declare function map<A, B>(f: (a: A) => B): <E>(self: Either<E, A>) => Either<E, B>;
 /**
  * @tsplus pipeable fncts.Either mapLeft
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function mapLeft<E1, E2>(f: (e: E1) => E2): <A>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E2, A>;
+export declare function mapLeft<E1, E2>(f: (e: E1) => E2): <A>(self: Either<E1, A>) => Either<E2, A>;
 /**
  * @tsplus getter fncts.Either value
  * @tsplus location "@fncts/base/data/Either/api"
@@ -104,7 +104,7 @@ export declare function merge<E, A>(self: Either<E, A>): E | A;
  * @tsplus pipeable fncts.Either orElse
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function orElse<E2, B>(that: Lazy<Either<E2, B>>): <E1, A>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E2 | E1, B | A>;
+export declare function orElse<E2, B>(that: Lazy<Either<E2, B>>): <E1, A>(self: Either<E1, A>) => Either<E1 | E2, A | B>;
 /**
  * @tsplus getter fncts.Either swap
  * @tsplus location "@fncts/base/data/Either/api"
@@ -120,12 +120,12 @@ export declare const traverse_: P.Traversable<EitherF>["traverse"];
  * @tsplus pipeable fncts.Either zipWith
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function zipWith<A, E2, B, C>(fb: Either<E2, B>, f: (a: A, b: B) => C): <E1>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E2 | E1, C>;
+export declare function zipWith<A, E2, B, C>(fb: Either<E2, B>, f: (a: A, b: B) => C): <E1>(self: Either<E1, A>) => Either<E1 | E2, C>;
 /**
  * @tsplus pipeable fncts.Either zip
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function zip<E1, B>(that: Either<E1, B>): <E, A>(self: import("./definition.js").Either<E, A>) => import("./definition.js").Either<E1 | E, import("../Zipped.js").Zipped.Make<A, B>>;
+export declare function zip<E1, B>(that: Either<E1, B>): <E, A>(self: Either<E, A>) => Either<E | E1, Zipped.Make<A, B>>;
 /**
  * @tsplus pipeable fncts.Either filterMap
  * @tsplus location "@fncts/base/data/Either/api"
@@ -151,5 +151,5 @@ export declare function partition<E, A>(p: Predicate<A>, /** @tsplus auto */ M:
  * @tsplus location "@fncts/base/data/Either/api"
  */
 export declare function toMaybe<E, A>(self: Either<E, A>): Maybe<A>;
-export * from "./api/align.js";
 export * from "./api/alignWith.js";
+export * from "./api/align.js";

package/data/Either/constructors.d.ts

@@ -21,7 +21,7 @@ export declare function right<E = never, A = never>(a: A, __tsplusTrace?: string
  * @tsplus pipeable fncts.Maybe toEither
  * @tsplus location "@fncts/base/data/Either/constructors"
  */
-export declare function fromMaybe<E>(nothing: Lazy<E>): <A>(self: import("../Maybe.js").Maybe<A>) => Either<E, A>;
+export declare function fromMaybe<E>(nothing: Lazy<E>): <A>(self: Maybe<A>) => Either<E, A>;
 /**
  * @tsplus static fncts.EitherOps fromNullable
  * @tsplus location "@fncts/base/data/Either/constructors"

package/data/Either/definition.d.ts

@@ -22,10 +22,11 @@ type IOTypeId = typeof IOTypeId;
  * @tsplus type fncts.Either
  * @tsplus companion fncts.EitherOps
  */
-export declare class Either<E, A> {
+export declare abstract class Either<E, A> {
     readonly [EitherTypeId]: EitherTypeId;
     readonly [IOTypeId]: IOTypeId;
     readonly trace?: string | undefined;
+    readonly _ioOpCode: null;
     [EitherVariance]: {
         readonly _E: (_: never) => E;
         readonly _A: (_: never) => A;

package/data/Either.d.ts

@@ -1,5 +1,5 @@
-export * from "./Either/api.js";
-export * from "./Either/constructors.js";
-export * from "./Either/definition.js";
-export * from "./Either/destructors.js";
 export * from "./Either/instances.js";
+export * from "./Either/destructors.js";
+export * from "./Either/definition.js";
+export * from "./Either/constructors.js";
+export * from "./Either/api.js";

package/data/EitherT/api.d.ts

@@ -47,7 +47,7 @@ export declare function bimap<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>)
  * @tsplus static fncts.EitherTOps flatMap
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>): <K, Q, W, X, I, S, R, FE, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(f: (a: A) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "K", K, K1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "Q", Q, Q1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "W", W, W1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "X", X, X1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "I", I, I1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "S", S, S1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "R", R, R1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "E", FE, FE1>, import("../Either.js").Either<E1, B>>) => <E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<F, FC, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "K", [K, K1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "Q", [Q, Q1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "W", [W, W1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "X", [X, X1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "I", [I, I1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "S", [S, S1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "R", [R, R1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "E", [FE, FE1]>, E1 | E, B>;
+export declare function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>): <K, Q, W, X, I, S, R, FE, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(f: (a: A) => HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", FE, FE1>, Either<E1, B>>) => <E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<F, FC, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "K", [K, K1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "Q", [Q, Q1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "W", [W, W1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "X", [X, X1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "I", [I, I1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "S", [S, S1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "R", [R, R1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "E", [FE, FE1]>, E1 | E, B>;
 /**
  * @tsplus static fncts.EitherTOps zipWith
  * @tsplus location "@fncts/base/data/EitherT/api"

package/data/Encoder.d.ts

@@ -1,2 +1,2 @@
-export * from "./Encoder/api.js";
 export * from "./Encoder/definition.js";
+export * from "./Encoder/api.js";

package/data/Environment/ServiceNotFoundError.d.ts

@@ -0,0 +1,5 @@
+import { Tag } from "@fncts/base/data/Tag/definition";
+export declare class ServiceNotFoundError extends Error {
+    readonly tag: Tag<any, any>;
+    constructor(tag: Tag<any, any>);
+}

package/data/Environment/api.d.ts

@@ -1,28 +1,28 @@
 import { Tag } from "@fncts/base/data/Tag/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 /**
  * @tsplus pipeable fncts.Environment add
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function add<H extends S, S = H>(service: H, tag: Tag<S>): <R>(self: import("./definition").Environment<R>) => import("./definition").Environment<S | R>;
+export declare function add<H extends S, S = H>(service: H, tag: Tag<S>): <R>(self: Environment<R>) => Environment<R | S>;
+export declare function add<H extends S, S = H, I = S>(service: H, tag: Tag<S, I>): <R>(self: Environment<R>) => Environment<R | I>;
 /**
  * @tsplus static fncts.EnvironmentOps empty
  * @tsplus location "@fncts/base/data/Environment/api"
  */
 export declare const empty: import("./definition").Environment<never>;
-type Tags<R> = R extends infer S ? Tag<S> : never;
+type Tags<R> = R extends infer S ? Tag<any, S> : never;
 /**
  * @tsplus pipeable fncts.Environment get
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function get<R, T extends Tags<R>>(tag: T): (self: Environment<R>) => T extends import("../Tag").Tag<infer S> ? S : never;
+export declare function get<R, T extends Tags<R>>(tag: T): (self: Environment<R>) => Tag.Service<T>;
 /**
  * @tsplus pipeable fncts.Environment getMaybe
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function getMaybe<S>(tag: Tag<S>): <R extends import("../../typeclass").Has<S>>(self: import("./definition").Environment<R>) => Maybe<S>;
+export declare function getMaybe<S, I>(tag: Tag<S, I>): <R>(self: Environment<R>) => Maybe<S>;
 /**
  * @tsplus static fncts.EnvironmentOps __call
  * @tsplus location "@fncts/base/data/Environment/api"
@@ -33,12 +33,12 @@ export declare function make(): Environment<never>;
  * @tsplus pipeable fncts.Environment union
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function union<R1>(that: Environment<R1>): <R>(self: import("./definition").Environment<R>) => import("./definition").Environment<R & R1>;
+export declare function union<R1>(that: Environment<R1>): <R>(self: Environment<R>) => Environment<R & R1>;
 /**
  * @tsplus pipeable fncts.Environment unsafeGet
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function unsafeGet<S>(tag: Tag<S>): <R>(self: import("./definition").Environment<R>) => S;
+export declare function unsafeGet<S, I>(tag: Tag<S, I>): <R>(self: Environment<R>) => S;
 /**
  * @tsplus pipeable fncts.Environment update
  * @tsplus location "@fncts/base/data/Environment/api"

package/data/Environment.d.ts

@@ -1,2 +1,3 @@
-export * from "./Environment/api.js";
 export * from "./Environment/definition.js";
+export * from "./Environment/api.js";
+export * from "./Environment/ServiceNotFoundError.js";

package/data/EnvironmentPatch.d.ts

@@ -59,7 +59,7 @@ export declare function concrete(_: EnvironmentPatch<any, any>): asserts _ is Co
  * @tsplus pipeable fncts.Environment.Patch __call
  * @tsplus location "@fncts/base/data/EnvironmentPatch"
  */
-export declare function apply<In>(environment: Environment<In>): <Out>(patch: EnvironmentPatch<In, Out>) => import("./Environment").Environment<Out>;
+export declare function apply<In>(environment: Environment<In>): <Out>(patch: EnvironmentPatch<In, Out>) => Environment<Out>;
 /**
  * @tsplus pipeable fncts.Environment.Patch combine
  * @tsplus location "@fncts/base/data/EnvironmentPatch"

package/data/Equatable.d.ts

@@ -1,3 +1,3 @@
-export * from "./Equatable/api.js";
-export * from "./Equatable/definition.js";
 export * from "./Equatable/fast-equals.js";
+export * from "./Equatable/definition.js";
+export * from "./Equatable/api.js";

package/data/Exit/api.d.ts

@@ -6,32 +6,32 @@ import { Cause } from "@fncts/base/data/Cause/definition";
  * @tsplus pipeable fncts.Exit ap
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function ap<E, A>(that: Exit<E, A>): <G, B>(self: import("./definition.js").Exit<G, (a: A) => B>) => import("./definition.js").Exit<E | G, B>;
+export declare function ap<E, A>(that: Exit<E, A>): <G, B>(self: import("./definition.js").Exit<G, (a: A) => B>) => Exit<E | G, B>;
 /**
  * @tsplus pipeable fncts.Exit zipLeft
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipLeft<G, B>(that: Exit<G, B>): <E, A>(self: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, A>;
+export declare function zipLeft<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, A>;
 /**
  * @tsplus pipeable fncts.Exit zipRight
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipRight<G, B>(that: Exit<G, B>): <E, A>(self: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, B>;
+export declare function zipRight<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, B>;
 /**
  * @tsplus pipeable fncts.Exit zipLeftConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipLeftConcurrent<G, B>(that: Exit<G, B>): <E, A>(self: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, A>;
+export declare function zipLeftConcurrent<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, A>;
 /**
  * @tsplus pipeable fncts.Exit zipRightConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipRightConcurrent<G, B>(that: Exit<G, B>): <E, A>(self: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, B>;
+export declare function zipRightConcurrent<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, B>;
 /**
  * @tsplus pipeable fncts.Exit flatMap
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function flatMap<A, G, B>(f: (a: A) => Exit<G, B>): <E>(ma: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, B>;
+export declare function flatMap<A, G, B>(f: (a: A) => Exit<G, B>): <E>(ma: Exit<E, A>) => Exit<E | G, B>;
 /**
  * @tsplus pipeable fncts.Exit bimap
  * @tsplus location "@fncts/base/data/Exit/api"
@@ -56,17 +56,17 @@ export declare function flatten<E, G, A>(mma: Exit<E, Exit<G, A>>): Exit<E | G,
  * @tsplus pipeable fncts.Exit map
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function map<A, B>(f: (a: A) => B): <E>(fa: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<E, B>;
+export declare function map<A, B>(f: (a: A) => B): <E>(fa: Exit<E, A>) => Exit<E, B>;
 /**
  * @tsplus pipeable fncts.Exit mapError
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function mapError<E1, E2>(f: (e: E1) => E2): <A>(self: import("./definition.js").Exit<E1, A>) => import("./definition.js").Exit<E2, A>;
+export declare function mapError<E1, E2>(f: (e: E1) => E2): <A>(self: Exit<E1, A>) => Exit<E2, A>;
 /**
  * @tsplus pipeable fncts.Exit mapErrorCause
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function mapErrorCause<E1, E2>(f: (e: Cause<E1>) => Cause<E2>): <A>(self: import("./definition.js").Exit<E1, A>) => import("./definition.js").Exit<E2, A>;
+export declare function mapErrorCause<E1, E2>(f: (e: Cause<E1>) => Cause<E2>): <A>(self: Exit<E1, A>) => Exit<E2, A>;
 /**
  * @tsplus pipeable fncts.Exit match
  * @tsplus location "@fncts/base/data/Exit/api"
@@ -76,22 +76,22 @@ export declare function match<E, A, B, C>(onFailure: (e: Cause<E>) => B, onSucce
  * @tsplus pipeable fncts.Exit zipWith
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipWith<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, C>;
+export declare function zipWith<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: Exit<EA, A>) => Exit<EA | EB, C>;
 /**
  * @tsplus pipeable fncts.Exit zip
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zip<EB, B>(that: Exit<EB, B>): <EA, A>(self: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, readonly [A, B]>;
+export declare function zip<EB, B>(that: Exit<EB, B>): <EA, A>(self: Exit<EA, A>) => Exit<EA | EB, readonly [A, B]>;
 /**
  * @tsplus pipeable fncts.Exit zipWithConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipWithConcurrent<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, C>;
+export declare function zipWithConcurrent<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: Exit<EA, A>) => Exit<EA | EB, C>;
 /**
  * @tsplus pipeable fncts.Exit zipConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipConcurrent<EB, B>(that: Exit<EB, B>): <EA, A>(self: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, readonly [A, B]>;
+export declare function zipConcurrent<EB, B>(that: Exit<EB, B>): <EA, A>(self: Exit<EA, A>) => Exit<EA | EB, readonly [A, B]>;
 /**
  * @tsplus pipeable fncts.Exit zipWithCause
  * @tsplus location "@fncts/base/data/Exit/api"
@@ -105,7 +105,7 @@ export declare function zipWithCause<E, A, G, B, C>(fb: Exit<G, B>, f: (a: A, b:
 export declare function value<E, A>(self: Exit<E, A>): A | undefined;
 /**
  * Returns the Exit's Success value if it exists, or throws the pretty-printed Cause if it doesn't
- * @tsplus getter fncts.Exit valueOrThrow
+ * @tsplus getter fncts.Exit getOrThrow
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function valueOrThrow<E, A>(self: Exit<E, A>): A;
+export declare function getOrThrow<E, A>(self: Exit<E, A>): A;

package/data/Exit/definition.d.ts

@@ -29,6 +29,7 @@ export declare class Failure<E> {
     readonly cause: Cause<E>;
     readonly trace?: string | undefined;
     readonly [ExitTypeId]: ExitTypeId;
+    readonly _ioOpCode: null;
     [ExitVariance]: {
         readonly _E: (_: never) => E;
         readonly _A: (_: never) => never;
@@ -47,6 +48,7 @@ export declare class Success<A> implements P.Hashable, P.Equatable {
     readonly value: A;
     readonly trace?: string | undefined;
     readonly [ExitTypeId]: ExitTypeId;
+    readonly _ioOpCode: null;
     [ExitVariance]: {
         readonly _E: (_: never) => never;
         readonly _A: (_: never) => A;

package/data/Exit.d.ts

@@ -1,3 +1,3 @@
-export * from "./Exit/api.js";
-export * from "./Exit/constructors.js";
 export * from "./Exit/definition.js";
+export * from "./Exit/constructors.js";
+export * from "./Exit/api.js";

package/data/FiberId.d.ts

@@ -1,3 +1,3 @@
-export * from "./FiberId/api.js";
-export * from "./FiberId/constructors.js";
 export * from "./FiberId/definition.js";
+export * from "./FiberId/constructors.js";
+export * from "./FiberId/api.js";

package/data/Guard.d.ts

@@ -1,2 +1,2 @@
-export * from "./Guard/api.js";
 export * from "./Guard/definition.js";
+export * from "./Guard/api.js";

package/data/Hashable.d.ts

@@ -1,2 +1,2 @@
-export * from "./Hashable/definition.js";
 export * from "./Hashable/hash.js";
+export * from "./Hashable/definition.js";

package/data/Identity/api.d.ts

@@ -4,7 +4,7 @@ import { Zipped } from "@fncts/base/data/Zipped";
  * @tsplus pipeable fncts.Identity ap
  * @tsplus location "@fncts/base/data/Identity/api"
  */
-export declare function ap<A>(fa: Identity<A>): <B>(fab: import("./definition").Identity<(a: A) => B>) => import("./definition").Identity<B>;
+export declare function ap<A>(fa: Identity<A>): <B>(fab: import("./definition").Identity<(a: A) => B>) => Identity<B>;
 /**
  * @tsplus pipeable fncts.Identity map
  * @tsplus location "@fncts/base/data/Identity/api"
@@ -25,7 +25,7 @@ export declare function zipWith<A, B, C>(fb: Identity<B>, f: (a: A, b: B) => C):
  * @tsplus pipeable fncts.Identity zip
  * @tsplus location "@fncts/base/data/Identity/api"
  */
-export declare function zip<B>(fb: Identity<B>): <A>(fa: import("./definition").Identity<A>) => import("./definition").Identity<import("../Zipped").Zipped.Make<A, B>>;
+export declare function zip<B>(fb: Identity<B>): <A>(fa: Identity<A>) => Identity<Zipped.Make<A, B>>;
 /**
  * @tsplus getter fncts.Identity getIdentity
  * @tsplus macro identity

package/data/Identity.d.ts

@@ -1,3 +1,3 @@
-export * from "./Identity/api.js";
-export * from "./Identity/definition.js";
 export * from "./Identity/instances.js";
+export * from "./Identity/definition.js";
+export * from "./Identity/api.js";

package/data/Maybe/api.d.ts

@@ -10,7 +10,7 @@ import type { Nullable } from "@fncts/base/types";
  * @tsplus pipeable fncts.Maybe ap
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function ap<A>(fa: Maybe<A>): <B>(self: import("./definition.js").Maybe<(a: A) => B>) => import("./definition.js").Maybe<B>;
+export declare function ap<A>(fa: Maybe<A>): <B>(self: import("./definition.js").Maybe<(a: A) => B>) => Maybe<B>;
 /**
  * Applies `f` to the value contained in `Maybe` if it is `Just` and returns the result,
  * otherwise returns `Nothing`.
@@ -75,7 +75,7 @@ export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: Mon
  * @tsplus pipeable fncts.Maybe getOrElse
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function getOrElse<B>(orElse: Lazy<B>): <A>(self: import("./definition.js").Maybe<A>) => B | A;
+export declare function getOrElse<B>(orElse: Lazy<B>): <A>(self: Maybe<A>) => A | B;
 /**
  * Applies `f` to the value contained in `Maybe` if it is `Just`, otherwise returns `Nothing`.
  * @tsplus pipeable fncts.Maybe map
@@ -92,7 +92,7 @@ export declare function mapNullable<A, B>(f: (a: A) => Nullable<B>): (self: Mayb
  * @tsplus pipeable fncts.Maybe orElse
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function orElse<B>(fb: Lazy<Maybe<B>>): <A>(self: import("./definition.js").Maybe<A>) => import("./definition.js").Maybe<B | A>;
+export declare function orElse<B>(fb: Lazy<Maybe<B>>): <A>(self: Maybe<A>) => Maybe<A | B>;
 /**
  * Extracts the value from `Maybe` if it is `Just`, otherwise returns `undefined`
  * @tsplus getter fncts.Maybe value
@@ -108,4 +108,4 @@ export declare function zipWith<A, B, C>(fb: Maybe<B>, f: (a: A, b: B) => C): (s
  * @tsplus pipeable fncts.Maybe zip
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function zip<B>(that: Maybe<B>): <A>(self: import("./definition.js").Maybe<A>) => import("./definition.js").Maybe<import("../Zipped.js").Zipped.Make<A, B>>;
+export declare function zip<B>(that: Maybe<B>): <A>(self: Maybe<A>) => Maybe<Zipped.Make<A, B>>;

package/data/Maybe/definition.d.ts

@@ -25,6 +25,7 @@ export declare abstract class Maybe<A> {
     [MaybeVariance]: {
         readonly _A: (_: never) => A;
     };
+    readonly _ioOpCode: null;
     readonly [MaybeTypeId]: MaybeTypeId;
     readonly [IOTypeId]: IOTypeId;
     readonly trace?: string | undefined;

package/data/Maybe.d.ts

@@ -1,5 +1,5 @@
-export * from "./Maybe/api.js";
-export * from "./Maybe/constructors.js";
-export * from "./Maybe/definition.js";
-export * from "./Maybe/destructors.js";
 export * from "./Maybe/instances.js";
+export * from "./Maybe/destructors.js";
+export * from "./Maybe/definition.js";
+export * from "./Maybe/constructors.js";
+export * from "./Maybe/api.js";

package/data/Newtype.d.ts

@@ -33,4 +33,4 @@ export interface NewtypeIso<N extends NewtypeHKT, C = N["type"]["_C"]> {
  * @tsplus static fncts.NewtypeOps __call
  * @tsplus location "@fncts/base/data/Newtype"
  */
-export declare const newtype: <N extends NewtypeHKT>() => NewtypeIso<N, N["type"]["_C"]>;
+export declare const newtype: <N extends NewtypeHKT>() => NewtypeIso<N>;

package/data/Ord/api.d.ts

@@ -1,3 +1,3 @@
-export * from "./api/contramap.js";
-export * from "./api/max.js";
 export * from "./api/min.js";
+export * from "./api/max.js";
+export * from "./api/contramap.js";

package/data/Ord.d.ts

@@ -1,3 +1,3 @@
-export * from "./Ord/api.js";
-export * from "./Ord/definition.js";
 export * from "./Ord/instances.js";
+export * from "./Ord/definition.js";
+export * from "./Ord/api.js";

package/data/Predicate.d.ts

@@ -1,2 +1,2 @@
-export * from "./Predicate/api.js";
 export * from "./Predicate/definition.js";
+export * from "./Predicate/api.js";

package/data/Refinement/api.d.ts

@@ -11,13 +11,13 @@ export declare function and<A, B extends A>(that: Predicate<B>): (self: Refineme
  * @tsplus pipeable fncts.Refinement contramap
  * @tsplus location "@fncts/base/data/Refinement/api"
  */
-export declare function contramap<A extends C, C>(f: (c: C) => A): <B extends A>(self: import("./definition").Refinement<A, B>) => import("./definition").Refinement<C, B>;
+export declare function contramap<A extends C, C>(f: (c: C) => A): <B extends A>(self: Refinement<A, B>) => Refinement<C, B>;
 /**
  * @tsplus pipeable fncts.Refinement or
  * @tsplus pipeable-operator fncts.Refinement ||
  * @tsplus location "@fncts/base/data/Refinement/api"
  */
-export declare function or<A, C extends A>(that: Refinement<A, C>): <B extends A>(self: import("./definition").Refinement<A, B>) => import("./definition").Refinement<A, C | B>;
+export declare function or<A, C extends A>(that: Refinement<A, C>): <B extends A>(self: Refinement<A, B>) => Refinement<A, B | C>;
 /**
  * @tsplus fluent fncts.Refinement invert
  * @tsplus location "@fncts/base/data/Refinement/api"

package/data/Refinement.d.ts

@@ -1,2 +1,2 @@
-export * from "./Refinement/api.js";
 export * from "./Refinement/definition.js";
+export * from "./Refinement/api.js";

package/data/Struct.d.ts

@@ -1,2 +1,2 @@
-export * from "./Struct/api.js";
 export * from "./Struct/definition.js";
+export * from "./Struct/api.js";

package/data/Tag/constructors.d.ts

@@ -3,4 +3,4 @@ import { Tag } from "@fncts/base/data/Tag/definition";
  * @tsplus static fncts.TagOps __call
  * @tsplus location "@fncts/base/data/Tag/constructors"
  */
-export declare function makeTag<T>(/** @fncts id */ id?: string): Tag<T>;
+export declare function makeTag<T, I = T>(/** @fncts id */ id?: string): Tag<T, I>;

package/data/Tag/definition.d.ts

@@ -4,20 +4,36 @@ export declare const TagVariance: unique symbol;
 export type TagVariance = typeof TagVariance;
 export declare const TagTypeId: unique symbol;
 export type TagTypeId = typeof TagTypeId;
+declare const IOTypeId: unique symbol;
+type IOTypeId = typeof IOTypeId;
 /**
  * Tag Encodes capabilities of reading and writing a service T into a generic environment
  *
  * @tsplus type fncts.Tag
  * @tsplus companion fncts.TagOps
  */
-export declare class Tag<in out T> implements Hashable, Equatable {
+export declare class Tag<in out T, in out Identifier = T> implements Hashable, Equatable {
     readonly id: string;
+    readonly _ioOpCode: null;
+    readonly _tag = "Tag";
     readonly [TagTypeId]: TagTypeId;
+    readonly [IOTypeId]: IOTypeId;
+    readonly trace?: string | undefined;
     [TagVariance]: {
         readonly _T: (_: T) => T;
+        readonly _Identifier: (_: Identifier) => Identifier;
     };
     constructor(id: string);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }
+export declare namespace Tag {
+    type Service<T> = T extends Tag<infer A, any> ? A : never;
+    type Identifier<T> = T extends Tag<any, infer A> ? A : never;
+}
 export declare function isTag(u: unknown): u is Tag<unknown>;
+/**
+ * @tsplus unify fncts.Tag
+ */
+export declare function unifyIO<X extends Tag<any, any>>(self: X): X;
+export {};

package/data/Tag.d.ts

@@ -1,2 +1,2 @@
-export * from "./Tag/constructors.js";
 export * from "./Tag/definition.js";
+export * from "./Tag/constructors.js";