@fncts/base 0.0.21 → 0.0.23

package/data/Encoder/api.d.ts

@@ -1,6 +1,10 @@
-import { Guard } from "@fncts/base/typeclass/Guard";
-import type { Brand } from "../Branded.js";
+import { Guard } from "@fncts/base/data/Guard";
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { Brand, Validation } from "../Branded.js";
 import type { Check } from "@fncts/typelevel";
+import type { Literal } from "@fncts/typelevel/Any";
 import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
 import { Encoder } from "./definition.js";
 /**
@@ -8,41 +12,70 @@ import { Encoder } from "./definition.js";
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
 export declare function makeEncoder<A>(encode: (inp: A) => unknown): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps unknown
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare const unknown: Encoder<unknown>;
 /**
  * @tsplus implicit
+ * @tsplus static fncts.EncoderOps boolean
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
 export declare const boolean: Encoder<boolean>;
 /**
  * @tsplus implicit
+ * @tsplus static fncts.EncoderOps number
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
 export declare const number: Encoder<number>;
 /**
  * @tsplus implicit
+ * @tsplus static fncts.EncoderOps string
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare const string: Encoder<string>;
+/**
+ * @tsplus implicit
+ * @tsplus static fncts.EncoderOps bigint
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
-export declare const string: Encoder<number>;
+export declare const bigint: Encoder<bigint>;
 /**
  * @tsplus implicit
+ * @tsplus static fncts.EncoderOps null
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
 export declare const _null: Encoder<null>;
 /**
  * @tsplus implicit
+ * @tsplus static fncts.EncoderOps undefined
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
-export declare const date: Encoder<Date>;
+export declare const _undefined: Encoder<undefined>;
 /**
- * @tsplus derive fncts.Encoder<_> 10
+ * @tsplus implicit
+ * @tsplus static fncts.EncoderOps date
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
-export declare function deriveValidation<A extends Brand.Valid<any, any>>(...[base]: Check<Brand.IsValidated<A>> extends Check.True ? [base: Encoder<Brand.Unbranded<A>>] : never): Encoder<A>;
+export declare const date: Encoder<Date>;
 /**
  * @tsplus derive fncts.Encoder lazy
+ * @tsplus static fncts.EncoderOps lazy
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
 export declare function deriveLazy<A>(fn: (_: Encoder<A>) => Encoder<A>): Encoder<A>;
+export declare function deriveLiteral<A extends string | number | boolean>(...[value]: Check<Check.IsLiteral<A> & Check.Not<Check.IsUnion<A>>> extends Check.True ? [value: A] : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps literal
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function literal<A extends Literal>(value: A): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps nullable
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function nullable<A>(/** @tsplus implicit local */ base: Encoder<A>): Encoder<A | null | undefined>;
 /**
  * @tsplus derive fncts.Encoder<_> 20
  * @tsplus location "@fncts/base/data/Encoder/api"
@@ -59,6 +92,20 @@ export declare function deriveStruct<A extends Record<string, any>>(...[required
         }
     ])
 ] : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps struct
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function struct<A extends Record<string, any>>(fields: {
+    [K in keyof A]: Encoder<A[K]>;
+}): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps partial
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function partial<A extends Record<string, any>>(fields: {
+    [K in keyof A]: Encoder<A[K]>;
+}): Encoder<Partial<A>>;
 /**
  * @tsplus derive fncts.Encoder<|> 30
  * @tsplus location "@fncts/base/data/Encoder/api"
@@ -71,3 +118,97 @@ export declare function deriveUnion<A extends Array<unknown>>(...elements: {
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
 export declare function deriveEmptyRecord<A extends {}>(..._: Check<Check.IsEqual<A, {}>> extends Check.True ? [] : never): Encoder<A>;
+/**
+ * @tsplus derive fncts.Encoder[fncts.Array]<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveArray<A extends Array<any>>(...[element]: [A] extends [Array<infer _A>] ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps array
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function array<A>(/** @tsplus implicit local */ base: Encoder<A>): Encoder<Array<A>>;
+/**
+ * @tsplus derive fncts.Encoder[fncts.ReadonlyArray]<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveReadonlyArray<A extends ReadonlyArray<any>>(...[element]: [A] extends [ReadonlyArray<infer _A>] ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps readonlyArray
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function readonlyArray<A>(/** @tsplus implicit local */ base: Encoder<A>): Encoder<ReadonlyArray<A>>;
+/**
+ * @tsplus derive fncts.Encoder<_> 15
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveDictionary<A extends Record<string, any>>(...[value]: Check<Check.IsDictionary<A>> extends Check.True ? [value: Encoder<A[keyof A]>] : never): Encoder<A>;
+/**
+ * @tsplus derive fncts.Encoder<_> 15
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveRecord<A extends Record<string, any>>(...[value, requiredKeys]: Check<Check.IsRecord<A>> extends Check.True ? [
+    value: Encoder<A[keyof A]>,
+    requiredKeys: {
+        [K in keyof A]: 0;
+    }
+] : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps record
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function record<A>(codomain: Encoder<A>): Encoder<Record<string, A>>;
+/**
+ * @tsplus derive fncts.Encoder[fncts.ImmutableArray]<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveImmutableArray<A extends ImmutableArray<any>>(...[element]: [A] extends [ImmutableArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps immutableArray
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function immutableArray<A>(base: Encoder<A>): Encoder<ImmutableArray<A>>;
+/**
+ * @tsplus derive fncts.Encoder[fncts.ImmutableNonEmptyArray]<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveImmutableNonEmptyArray<A extends ImmutableNonEmptyArray<any>>(...[element]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableNonEmptyArray<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps immutableNonEmptyArray
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function immutableNonEmptyArray<A>(base: Encoder<A>): Encoder<ImmutableNonEmptyArray<A>>;
+/**
+ * @tsplus derive fncts.Encoder[fncts.Conc]<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveConc<A extends Conc<any>>(...[element]: [A] extends [Conc<infer _A>] ? Check<Check.IsEqual<A, Conc<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps conc
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function conc<A>(base: Encoder<A>): Encoder<Conc<A>>;
+/**
+ * @tsplus derive fncts.Encoder<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveValidation<A extends Brand.Valid<any, any>>(...[base]: Check<Brand.IsValidated<A>> extends Check.True ? [base: Encoder<Brand.Unbranded<A>>] : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps validation
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function validation<A, B extends ReadonlyArray<Validation<A, any>>>(..._validations: B): (base: Encoder<A>) => Encoder<A & { [K in keyof B]: B[K] extends Validation<any, infer S extends string> ? Brand.Valid<A, S> : never; }[number]>;
+/**
+ * @tsplus derive fncts.Encoder<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveTuple<A extends ReadonlyArray<unknown>>(...[components]: Check<Check.IsTuple<A>> extends Check.True ? [components: {
+    [K in keyof A]: Encoder<A[K]>;
+}] : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps tuple
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function tuple<A extends ReadonlyArray<unknown>>(...components: {
+    [K in keyof A]: Encoder<A[K]>;
+}): Encoder<A>;

package/data/Encoder/definition.d.ts

@@ -1,3 +1,4 @@
+import { HKT } from "@fncts/typelevel/HKT";
 export declare const EncoderTypeId: unique symbol;
 export type EncoderTypeId = typeof EncoderTypeId;
 /**
@@ -7,6 +8,9 @@ export type EncoderTypeId = typeof EncoderTypeId;
  */
 export declare class Encoder<in out A> {
     readonly encode: (inp: A) => unknown;
-    readonly _typeId: EncoderTypeId;
+    readonly [EncoderTypeId]: EncoderTypeId;
     constructor(encode: (inp: A) => unknown);
 }
+export interface EncoderF extends HKT {
+    readonly type: Encoder<this["A"]>;
+}

package/data/Environment/api.d.ts

@@ -34,11 +34,6 @@ export declare function make(): Environment<never>;
  * @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>;
-/**
- * @tsplus getter fncts.Environment clean
- * @tsplus location "@fncts/base/data/Environment/api"
- */
-export declare function clean<R>(self: Environment<R>): Environment<R>;
 /**
  * @tsplus pipeable fncts.Environment unsafeGet
  * @tsplus location "@fncts/base/data/Environment/api"

package/data/Environment/definition.d.ts

@@ -1,14 +1,12 @@
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { Tag } from "@fncts/base/data/Tag/definition";
 import type { EnvironmentPatch } from "@fncts/base/data/EnvironmentPatch";
-/**
- * @tsplus static fncts.prelude.builtin.SymbolOps env
- * @tsplus location "@fncts/base/data/Environment/definition"
- */
-export declare const EnvSymbol: unique symbol;
-export type EnvSymbol = typeof EnvSymbol;
+export declare const EnvironmentVariance: unique symbol;
+export type EnvironmentVariance = typeof EnvironmentVariance;
+export declare const EnvironmentTypeId: unique symbol;
+export type EnvironmentTypeId = typeof EnvironmentTypeId;
 /**
  * @tsplus type fncts.Environment
  * @tsplus companion fncts.EnvironmentOps
@@ -16,8 +14,10 @@ export type EnvSymbol = typeof EnvSymbol;
 export declare class Environment<R> implements Hashable, Equatable {
     readonly map: HashMap<Tag<any>, unknown>;
     cache: HashMap<Tag<any>, unknown>;
-    readonly _typeId: EnvSymbol;
-    readonly [EnvSymbol]: (_: never) => R;
+    readonly [EnvironmentTypeId]: EnvironmentTypeId;
+    [EnvironmentVariance]: {
+        _R: (_: never) => R;
+    };
     constructor(map: HashMap<Tag<any>, unknown>, cache?: HashMap<Tag<any>, unknown>);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;

package/data/EnvironmentPatch.d.ts

@@ -9,6 +9,8 @@ export declare const enum EnvironmentPatchTag {
     Combine = 3,
     Empty = 4
 }
+export declare const EnvironmentPatchVariance: unique symbol;
+export type EnvironmentPatchVariance = typeof EnvironmentPatchVariance;
 export declare const EnvironmentPatchTypeId: unique symbol;
 export type EnvironmentPatchTypeId = typeof EnvironmentPatchTypeId;
 /**
@@ -16,9 +18,11 @@ export type EnvironmentPatchTypeId = typeof EnvironmentPatchTypeId;
  * @tsplus companion fncts.Environment.PatchOps
  */
 export declare abstract class EnvironmentPatch<In, Out> {
-    readonly _typeId: EnvironmentPatchTypeId;
-    readonly _R: (_: In) => void;
-    readonly _A: () => Out;
+    readonly [EnvironmentPatchTypeId]: EnvironmentPatchTypeId;
+    [EnvironmentPatchVariance]: {
+        readonly _R: (_: In) => void;
+        readonly _A: (_: never) => Out;
+    };
 }
 export declare class AddService<Env, Service> extends EnvironmentPatch<Env, Env & Has<Service>> {
     readonly service: Service;

package/{typeclass → data}/Eq/definition.d.ts

@@ -2,7 +2,7 @@
  * @tsplus type fncts.Eq
  */
 export interface Eq<A> {
-    readonly equals: (x: A, y: A) => boolean;
+    readonly equals: (y: A) => (x: A) => boolean;
 }
 /**
  * @tsplus type fncts.EqOps
@@ -12,6 +12,6 @@ export interface EqOps {
 export declare const Eq: EqOps;
 /**
  * @tsplus static fncts.EqOps __call
- * @tsplus location "@fncts/base/typeclass/Eq/definition"
+ * @tsplus location "@fncts/base/data/Eq/definition"
  */
-export declare function mkEq<A>(E: Eq<A>): Eq<A>;
+export declare function makeEq<A>(E: Eq<A>): Eq<A>;

package/{typeclass → data}/Eq/derivations.d.ts

@@ -1,14 +1,14 @@
 import type { Check } from "@fncts/typelevel/Check";
 import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
-import { Eq } from "@fncts/base/typeclass/Eq/definition";
+import { Eq } from "@fncts/base/data/Eq";
 /**
  * @tsplus derive fncts.Eq lazy
- * @tsplus location "@fncts/base/typeclass/Eq/derivations"
+ * @tsplus location "@fncts/base/data/Eq/derivations"
  */
 export declare function deriveLazy<A>(fn: (_: Eq<A>) => Eq<A>): Eq<A>;
 /**
  * @tsplus derive fncts.Eq<_> 20
- * @tsplus location "@fncts/base/typeclass/Eq/derivations"
+ * @tsplus location "@fncts/base/data/Eq/derivations"
  */
 export declare function deriveStruct<A extends Record<string, any>>(...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True ? [
     ...[

package/{typeclass → data}/Equatable/api.d.ts

@@ -1,11 +1,11 @@
 /**
  * @tsplus static fncts.EquatableOps deepEquals
- * @tsplus location "@fncts/base/typeclass/Equatable/api"
+ * @tsplus location "@fncts/base/data/Equatable/api"
  */
 export declare const deepEquals: (a: any, b: any, meta?: any) => boolean;
 /**
  * @tsplus static fncts.EquatableOps strictEquals
  * @tsplus operator fncts.Equatable ==
- * @tsplus location "@fncts/base/typeclass/Equatable/api"
+ * @tsplus location "@fncts/base/data/Equatable/api"
  */
 export declare function strictEquals<A>(a: A, b: unknown): boolean;

package/{typeclass → data}/Equatable/definition.d.ts

@@ -1,6 +1,6 @@
 /**
  * @tsplus static fncts.builtin.SymbolOps equals
- * @tsplus location "@fncts/base/typeclass/Equatable/definition"
+ * @tsplus location "@fncts/base/data/Equatable/definition"
  */
 export declare const equalsSymbol: unique symbol;
 /**

package/data/Exit/api.d.ts

@@ -6,27 +6,27 @@ 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>(fa: Exit<E, A>): <G, B>(fab: 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>) => import("./definition.js").Exit<E | G, B>;
 /**
- * @tsplus pipeable fncts.Exit apFirst
+ * @tsplus pipeable fncts.Exit zipLeft
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function apFirst<G, B>(fb: Exit<G, B>): <E, A>(fa: 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: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, A>;
 /**
- * @tsplus pipeable fncts.Exit apSecond
+ * @tsplus pipeable fncts.Exit zipRight
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function apSecond<G, B>(fb: Exit<G, B>): <E, A>(fa: 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: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, B>;
 /**
- * @tsplus pipeable fncts.Exit apFirstC
+ * @tsplus pipeable fncts.Exit zipLeftConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function apFirstC<G, B>(fb: Exit<G, B>): <E, A>(fa: 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: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, A>;
 /**
- * @tsplus pipeable fncts.Exit apSecondC
+ * @tsplus pipeable fncts.Exit zipRightConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function apSecondC<G, B>(fb: Exit<G, B>): <E, A>(fa: 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: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, B>;
 /**
  * @tsplus pipeable fncts.Exit flatMap
  * @tsplus location "@fncts/base/data/Exit/api"
@@ -43,10 +43,10 @@ export declare function bimap<E1, A, E2, B>(f: (e: E1) => E2, g: (a: A) => B): (
  */
 export declare function collectAll<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>>;
 /**
- * @tsplus static fncts.ExitOps collectAllC
+ * @tsplus static fncts.ExitOps collectAllConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function collectAllC<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>>;
+export declare function collectAllConcurrent<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>>;
 /**
  * @tsplus getter fncts.Exit flatten
  * @tsplus location "@fncts/base/data/Exit/api"
@@ -83,15 +83,15 @@ export declare function zipWith<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) =>
  */
 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]>;
 /**
- * @tsplus pipeable fncts.Exit zipWithC
+ * @tsplus pipeable fncts.Exit zipWithConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipWithC<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: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, C>;
 /**
- * @tsplus pipeable fncts.Exit zipC
+ * @tsplus pipeable fncts.Exit zipConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipC<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: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, readonly [A, B]>;
 /**
  * @tsplus pipeable fncts.Exit zipWithCause
  * @tsplus location "@fncts/base/data/Exit/api"

package/data/Exit/definition.d.ts

@@ -1,6 +1,8 @@
 import { Cause } from "@fncts/base/data/Cause/definition";
-import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Hashable } from "@fncts/base/data/Hashable";
 import * as P from "../../typeclass.js";
+export declare const ExitVariance: unique symbol;
+export type ExitVariance = typeof ExitVariance;
 export declare const ExitTypeId: unique symbol;
 export type ExitTypeId = typeof ExitTypeId;
 /**
@@ -23,9 +25,11 @@ export declare const enum ExitTag {
  */
 export declare class Failure<E> {
     readonly cause: Cause<E>;
-    readonly _E: () => E;
-    readonly _A: () => never;
-    readonly _typeId: ExitTypeId;
+    readonly [ExitTypeId]: ExitTypeId;
+    [ExitVariance]: {
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => never;
+    };
     readonly _tag = ExitTag.Failure;
     constructor(cause: Cause<E>);
     get [Symbol.hash](): number;
@@ -37,9 +41,11 @@ export declare class Failure<E> {
  */
 export declare class Success<A> implements P.Hashable, P.Equatable {
     readonly value: A;
-    readonly _E: () => never;
-    readonly _A: () => A;
-    readonly _typeId: ExitTypeId;
+    readonly [ExitTypeId]: ExitTypeId;
+    [ExitVariance]: {
+        readonly _E: (_: never) => never;
+        readonly _A: (_: never) => A;
+    };
     readonly _tag = ExitTag.Success;
     constructor(value: A);
     get [Symbol.hash](): number;

package/data/FiberId/constructors.d.ts

@@ -1,4 +1,3 @@
-import { TraceElement } from "@fncts/base/data/TraceElement/definition";
 import { None, Runtime } from "./definition.js";
 /**
  * @tsplus static fncts.FiberIdOps none
@@ -9,7 +8,7 @@ export declare const none: None;
  * @tsplus static fncts.FiberIdOps unsafeMake
  * @tsplus location "@fncts/base/data/FiberId/constructors"
  */
-export declare function unsafeMake(location: TraceElement): Runtime;
+export declare function unsafeMake(__tsplusTrace?: string): Runtime;
 /**
  * @tsplus static fncts.FiberIdOps synthetic
  * @tsplus location "@fncts/base/data/FiberId/constructors"

package/data/FiberId/definition.d.ts

@@ -1,11 +1,10 @@
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
-import { TraceElement } from "@fncts/base/data/TraceElement/definition";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 export declare const FiberIdTypeId: unique symbol;
 export type FiberIdTypeId = typeof FiberIdTypeId;
 export declare class None implements Hashable, Equatable {
-    readonly _typeId: FiberIdTypeId;
+    readonly [FiberIdTypeId]: FiberIdTypeId;
     readonly _tag = "None";
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;
@@ -13,16 +12,16 @@ export declare class None implements Hashable, Equatable {
 export declare class Runtime implements Hashable, Equatable {
     readonly id: number;
     readonly startTime: number;
-    readonly location: TraceElement;
-    readonly _typeId: FiberIdTypeId;
+    readonly location?: string | undefined;
+    readonly [FiberIdTypeId]: FiberIdTypeId;
     readonly _tag = "Runtime";
-    constructor(id: number, startTime: number, location: TraceElement);
+    constructor(id: number, startTime: number, location?: string | undefined);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }
 export declare class Composite implements Hashable, Equatable {
     readonly fiberIds: HashSet<Runtime>;
-    readonly _typeId: FiberIdTypeId;
+    readonly [FiberIdTypeId]: FiberIdTypeId;
     readonly _tag = "Composite";
     constructor(fiberIds: HashSet<Runtime>);
     [Symbol.equals](that: unknown): boolean;
@@ -49,16 +48,19 @@ export declare namespace FiberId {
 export declare function isFiberId(u: unknown): u is FiberId;
 /**
  * @tsplus static fncts.FiberIdOps isNone
+ * @tsplus fluent fncts.FiberId isNone
  * @tsplus location "@fncts/base/data/FiberId/definition"
  */
 export declare function isNone(fiberId: FiberId): fiberId is None;
 /**
  * @tsplus static fncts.FiberIdOps isRuntime
+ * @tsplus fluent fncts.FiberId isRuntime
  * @tsplus location "@fncts/base/data/FiberId/definition"
  */
 export declare function isRuntime(fiberId: FiberId): fiberId is Runtime;
 /**
  * @tsplus static fncts.FiberIdOps isComposite
+ * @tsplus fluent fncts.FiberId isComposite
  * @tsplus location "@fncts/base/data/FiberId/definition"
  */
 export declare function isComposite(fiberId: FiberId): fiberId is Composite;