@fncts/base 0.0.13 → 0.0.16

package/collection/immutable/ImmutableArray/api.d.ts

@@ -231,25 +231,25 @@ export declare function findLastMap_<A, B>(as: ImmutableArray<A>, f: (a: A) => M
 export declare function findLastMapWithIndex_<A, B>(as: ImmutableArray<A>, f: (i: number, a: A) => Maybe<B>): Maybe<B>;
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeftWithIndex
- * @tsplus fluent fncts.base.MutableArray foldLeftWithIndex
+ * @tsplus fluent fncts.MutableArray foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldLeftWithIndex_<A, B>(self: ImmutableArray<A>, b: B, f: (i: number, b: B, a: A) => B): B;
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeft
- * @tsplus fluent fncts.base.MutableArray foldLeft
+ * @tsplus fluent fncts.MutableArray foldLeft
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldLeft_<A, B>(self: ImmutableArray<A>, b: B, f: (b: B, a: A) => B): B;
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeftWhile
- * @tsplus fluent fncts.base.MutableArray foldLeftWhile
+ * @tsplus fluent fncts.MutableArray foldLeftWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldLeftWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (b: B, a: A) => B): B;
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeftWithIndexWhile
- * @tsplus fluent fncts.base.MutableArray foldLeftWithIndexWhile
+ * @tsplus fluent fncts.MutableArray foldLeftWithIndexWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldLeftWithIndexWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (i: number, b: B, a: A) => B): B;
@@ -296,7 +296,7 @@ export declare function foldRightWithIndexWhile_<A, B>(self: ImmutableArray<A>,
 export declare function forEach_<A, B>(self: ImmutableArray<A>, f: (a: A) => B): void;
 /**
  * @tsplus fluent fncts.ImmutableArray get
- * @tsplus fluent fncts.base.MutableArray get
+ * @tsplus fluent fncts.MutableArray get
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function get_<A>(self: ImmutableArray<A>, i: number): Maybe<A>;
@@ -422,7 +422,7 @@ export declare function partitionMap_<A, B, C>(self: ImmutableArray<A>, f: (a: A
 export declare function prepend_<A, B>(self: ImmutableArray<A>, head: B): ImmutableArray<A | B>;
 /**
  * @tsplus fluent fncts.ImmutableArray prependAll
- * @tsplus fluent fncts.base.MutableArray prependAll
+ * @tsplus fluent fncts.MutableArray prependAll
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function prependAll_<A>(self: ImmutableArray<A>, a: A): ImmutableArray<A>;

package/collection/immutable/ImmutableArray/constructors.d.ts

@@ -1,7 +1,7 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 /**
- * @tsplus getter fncts.base.ReadonlyArray asImmutableArray
- * @tsplus getter fncts.base.Array asImmutableArray
+ * @tsplus getter fncts.ReadonlyArray asImmutableArray
+ * @tsplus getter fncts.Array asImmutableArray
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/constructors"
  */
 export declare function asImmutableArray<A>(self: ReadonlyArray<A>): ImmutableArray<A>;

package/collection/immutable/ImmutableArray/definition.d.ts

@@ -23,4 +23,8 @@ export declare class ImmutableArray<A> implements Equatable, Hashable, Iterable<
     get [Symbol.hash](): number;
     [Symbol.iterator](): IterableIterator<A>;
 }
+/**
+ * @tsplus static fncts.ImmutableArrayOps is
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/definition"
+ */
 export declare function isImmutableArray(u: unknown): u is ImmutableArray<unknown>;

package/collection/immutable/ImmutableArray/derivations.d.ts

@@ -0,0 +1,14 @@
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import { Guard } from "@fncts/base/typeclass/Guard";
+import { Decoder } from "@fncts/base/data/Decoder";
+import type { Check } from "@fncts/typelevel/Check";
+/**
+ * @tsplus derive fncts.Guard[fncts.ImmutableArray]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/derivations"
+ */
+export declare function deriveGuard<A extends ImmutableArray<any>>(...[element]: [A] extends [ImmutableArray<infer A>] ? [element: Guard<A>] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.ImmutableArray]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/derivations"
+ */
+export declare function deriveDecoder<A extends ImmutableArray<any>>(...[array, elem]: [A] extends [ImmutableArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True ? [array: Decoder<Array<_A>>, elem: Decoder<_A>] : never : never): Decoder<A>;

package/collection/immutable/ImmutableArray.d.ts

@@ -1,6 +1,7 @@
 export * from "./ImmutableArray/api.js";
 export * from "./ImmutableArray/constructors.js";
 export * from "./ImmutableArray/definition.js";
+export * from "./ImmutableArray/derivations.js";
 export * from "./ImmutableArray/instances.js";
 export * from "./ImmutableArray/api/chunksOf.js";
 export * from "./ImmutableArray/api/slice.js";

package/collection/immutable/ImmutableNonEmptyArray/constructors.d.ts

@@ -6,8 +6,8 @@ export declare function allocWithHead<A>(head: A, length: number): Array<A> & {
     0: A;
 };
 /**
- * @tsplus getter fncts.base.ReadonlyArray unsafeAsNonEmptyArray
- * @tsplus getter fncts.base.Array unsafeAsNonEmptyArray
+ * @tsplus getter fncts.ReadonlyArray unsafeAsNonEmptyArray
+ * @tsplus getter fncts.Array unsafeAsNonEmptyArray
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors"
  */
 export declare function unsafeAsNonEmptyArray<A>(self: ReadonlyArray<A>): ImmutableNonEmptyArray<A>;

package/collection/immutable/ImmutableNonEmptyArray/definition.d.ts

@@ -17,13 +17,13 @@ export declare class ImmutableNonEmptyArray<A> extends ImmutableArray<A> {
     constructor(_array: ReadonlyNonEmptyArray<A>);
 }
 /**
- * @tsplus type fncts.base.NonEmptyArray
+ * @tsplus type fncts.NonEmptyArray
  */
 export interface NonEmptyArray<T> extends Array<T> {
     0: T;
 }
 /**
- * @tsplus type fncts.base.ReadonlyNonEmptyArray
+ * @tsplus type fncts.ReadonlyNonEmptyArray
  */
 export interface ReadonlyNonEmptyArray<T> extends ReadonlyArray<T> {
     readonly 0: T;

package/collection/immutable/ImmutableNonEmptyArray/derivations.d.ts

@@ -0,0 +1,14 @@
+import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+import { Guard } from "@fncts/base/typeclass/Guard";
+import { Decoder } from "@fncts/base/data/Decoder";
+import type { Check } from "@fncts/typelevel/Check";
+/**
+ * @tsplus derive fncts.Guard[fncts.ImmutableNonEmptyArray]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/derivations"
+ */
+export declare function deriveGuard<A extends ImmutableNonEmptyArray<any>>(...[elem]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? [elem: Guard<_A>] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.ImmutableNonEmptyArray]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/derivations"
+ */
+export declare function deriveDecoder<A extends ImmutableNonEmptyArray<any>>(...[array, elem]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableNonEmptyArray<_A>>> extends Check.True ? [array: Decoder<Array<_A>>, elem: Decoder<_A>] : never : never): Decoder<A>;

package/collection/immutable/ImmutableNonEmptyArray.d.ts

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

package/collection/immutable/List/definition.d.ts

@@ -1,5 +1,5 @@
 /**
- * @tsplus type fncts.base.List.Cons
+ * @tsplus type fncts.List.Cons
  * @tsplus companion fncts.ConsOps
  */
 export declare class Cons<A> implements Iterable<A> {
@@ -10,7 +10,7 @@ export declare class Cons<A> implements Iterable<A> {
     [Symbol.iterator](): Iterator<A>;
 }
 /**
- * @tsplus type fncts.base.List.Nil
+ * @tsplus type fncts.List.Nil
  * @tsplus companion fncts.NilOps
  */
 export declare class Nil<A> implements Iterable<A> {

package/collection/immutable/Vector/definition.d.ts

@@ -47,7 +47,7 @@ export declare class Vector<A> implements Iterable<A> {
     [Symbol.equals](that: unknown): boolean;
 }
 /**
- * @tsplus type fncts.base.MutableVector
+ * @tsplus type fncts.MutableVector
  */
 export interface MutableVector<A> {
     readonly _typeId: VectorTypeId;

package/collection/immutable/Vector/internal.d.ts

@@ -106,7 +106,7 @@ export declare function incrementDepth(bits: number): number;
 export declare function decrementDepth(bits: number): number;
 /**
  * Appends the value to the Vector by _mutating_ the Vector and its content.
- * @tsplus fluent fncts.base.MutableVector push
+ * @tsplus fluent fncts.MutableVector push
  * @tsplus location "@fncts/base/collection/immutable/Vector/internal"
  */
 export declare function push<A>(l: MutableVector<A>, value: A): MutableVector<A>;

package/collection/immutable.d.ts

@@ -0,0 +1,10 @@
+export type {} from "./immutable/Conc.js";
+export type {} from "./immutable/HashMap.js";
+export type {} from "./immutable/HashSet.js";
+export type {} from "./immutable/ImmutableArray.js";
+export type {} from "./immutable/ImmutableNonEmptyArray.js";
+export type {} from "./immutable/List.js";
+export type {} from "./immutable/Queue.js";
+export type {} from "./immutable/RoseTree.js";
+export type {} from "./immutable/SortedMap.js";
+export type {} from "./immutable/Vector.js";

package/collection/mutable/HashMap.d.ts

@@ -17,6 +17,7 @@ export declare class HashMap<K, V> implements Iterable<readonly [K, V]> {
     private contentSize;
     get size(): number;
     has(key: K): boolean;
+    unsafeGet(key: K): V | undefined;
     get(key: K): Maybe<V>;
     set(key: K, value: V): Maybe<V>;
     delete(key: K): Maybe<V>;

package/collection/mutable.d.ts

@@ -0,0 +1,4 @@
+export type {} from "./mutable/HashMap.js";
+export type {} from "./mutable/HashSet.js";
+export type {} from "./mutable/internal.js";
+export type {} from "./mutable/ListBuffer.js";

package/collection/weak.d.ts

@@ -0,0 +1,2 @@
+export type {} from "./weak/IterableWeakMap.js";
+export type {} from "./weak/IterableWeakSet.js";

package/collection.d.ts

@@ -0,0 +1,5 @@
+export type {} from "./collection/compat.js";
+export type {} from "./collection/immutable.js";
+export type {} from "./collection/Iterable.js";
+export type {} from "./collection/mutable.js";
+export type {} from "./collection/weak.js";

package/control/Z/api.d.ts

@@ -37,12 +37,12 @@ export declare function bimap_<W, S1, S2, R, E, A, G, B>(pab: Z<W, S1, S2, R, E,
  * @tsplus fluent fncts.control.Z catchAll
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function catchAll_<W, S1, S2, R, E, A, S3, R1, E1, B>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: E) => Z<W, S1, S3, R1, E1, B>): Z<W, S1, S3, R & R1, E1, A | B>;
+export declare function catchAll_<W, S1, S2, R, E, A, S3, R1, E1, B>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: E) => Z<W, S1, S3, R1, E1, B>): Z<W, S1, S3, R | R1, E1, A | B>;
 /**
  * @tsplus fluent fncts.control.Z catchJust
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function catchJust_<W, S1, S2, R, E, A, S3, R1, E1, B>(fa: Z<W, S1, S2, R, E, A>, f: (e: E) => Maybe<Z<W, S1, S3, R1, E1, B>>): Z<W, S1, S2 | S3, R & R1, E | E1, A | B>;
+export declare function catchJust_<W, S1, S2, R, E, A, S3, R1, E1, B>(fa: Z<W, S1, S2, R, E, A>, f: (e: E) => Maybe<Z<W, S1, S3, R1, E1, B>>): Z<W, S1, S2 | S3, R | R1, E | E1, A | B>;
 /**
  * @tsplus fluent fncts.control.Z flatMap
  * @tsplus location "@fncts/base/control/Z/api"
@@ -108,22 +108,22 @@ export declare function erase<W, S1, S2, R, E, A>(wa: Z<W, S1, S2, R, E, A>): Z<
  * @tsplus static fncts.control.ZOps fail
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never>;
+export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never>;
 /**
  * @tsplus static fncts.control.ZOps failNow
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function failNow<E>(e: E, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never>;
+export declare function failNow<E>(e: E, __tsplusTrace?: string): Z<never, unknown, never, never, E, never>;
 /**
  * @tsplus static fncts.control.ZOps failCause
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never>;
+export declare function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never>;
 /**
  * @tsplus static fncts.control.ZOps failCauseNow
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never>;
+export declare function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never>;
 /**
  * @tsplus getter fncts.control.Z flatten
  * @tsplus location "@fncts/base/control/Z/api"
@@ -134,12 +134,12 @@ export declare function flatten<W, S1, S2, R, E, A, W1, S3, R1, E1>(mma: Z<W, S1
  * @tsplus static fncts.control.ZOps get
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function get<S>(): Z<never, S, S, unknown, never, S>;
+export declare function get<S>(): Z<never, S, S, never, never, S>;
 /**
  * @tsplus static fncts.control.ZOps gets
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function gets<S, A>(f: (s: S) => A): Z<never, S, S, unknown, never, A>;
+export declare function gets<S, A>(f: (s: S) => A): Z<never, S, S, never, never, A>;
 /**
  * @tsplus static fncts.control.ZOps getsZ
  * @tsplus location "@fncts/base/control/Z/api"
@@ -149,12 +149,12 @@ export declare function getsZ<S, W, R, E, A>(f: (s: S) => Z<W, S, S, R, E, A>):
  * @tsplus static fncts.control.ZOps halt
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Z<never, unknown, never, unknown, never, never>;
+export declare function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Z<never, unknown, never, never, never, never>;
 /**
  * @tsplus static fncts.control.ZOps haltNow
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function haltNow(defect: unknown, __tsplusTrace?: string): Z<never, unknown, never, unknown, never, never>;
+export declare function haltNow(defect: unknown, __tsplusTrace?: string): Z<never, unknown, never, never, never, never>;
 /**
  * @tsplus getter fncts.control.Z listen
  * @tsplus location "@fncts/base/control/Z/api"
@@ -201,17 +201,17 @@ export declare function match_<W, S1, S2, R, E, A, B, C>(fa: Z<W, S1, S2, R, E,
  * @tsplus fluent fncts.control.Z matchZ
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function matchZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S1 & S5, S3 | S4, R & R1 & R2, E1 | E2, B | C>;
+export declare function matchZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C>;
 /**
  * @tsplus fluent fncts.control.Z matchCauseZ
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function matchCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: Cause<E>) => Z<W1, S0, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S0 & S1, S3 | S4, R & R1 & R2, E1 | E2, B | C>;
+export declare function matchCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: Cause<E>) => Z<W1, S0, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S0 & S1, S3 | S4, R | R1 | R2, E1 | E2, B | C>;
 /**
  * @tsplus fluent fncts.control.Z matchLogZ
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function matchLogZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (ws: Conc<W>, e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S1 & S5, S3 | S4, R & R1 & R2, E1 | E2, B | C>;
+export declare function matchLogZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (ws: Conc<W>, e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C>;
 /**
  * Recovers from errors by accepting one computation to execute for the case
  * of an error, and one computation to execute for the case of success. More powerful
@@ -227,25 +227,25 @@ export declare function matchLogCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1,
  * @tsplus static fncts.control.ZOps modify
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<never, S1, S2, unknown, never, A>;
+export declare function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<never, S1, S2, never, never, A>;
 /**
  * Constructs a computation that may fail from the specified modify function.
  * @tsplus static fncts.control.ZOps modifyEither
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A, S2]>): Z<never, S1, S2, unknown, E, A>;
+export declare function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A, S2]>): Z<never, S1, S2, never, E, A>;
 /**
  * @tsplus fluent fncts.control.Z orElse
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function orElse_<W, S1, S2, R, E, A, W1, S3, R1, E1, A1>(fa: Z<W, S1, S2, R, E, A>, fb: Lazy<Z<W1, S1, S3, R1, E1, A1>>): Z<W | W1, S1, S2 | S3, R & R1, E | E1, A | A1>;
+export declare function orElse_<W, S1, S2, R, E, A, W1, S3, R1, E1, A1>(fa: Z<W, S1, S2, R, E, A>, fb: Lazy<Z<W1, S1, S3, R1, E1, A1>>): Z<W | W1, S1, S2 | S3, R | R1, E | E1, A | A1>;
 /**
  * Executes this computation and returns its value, if it succeeds, but
  * otherwise executes the specified computation.
  * @tsplus fluent fncts.control.Z orElseEither
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function orElseEither_<W, S1, S2, R, E, A, S3, S4, R1, E1, A1>(fa: Z<W, S1, S2, R, E, A>, that: Lazy<Z<W, S3, S4, R1, E1, A1>>): Z<W, S1 & S3, S2 | S4, R & R1, E1, Either<A, A1>>;
+export declare function orElseEither_<W, S1, S2, R, E, A, S3, S4, R1, E1, A1>(fa: Z<W, S1, S2, R, E, A>, that: Lazy<Z<W, S3, S4, R1, E1, A1>>): Z<W, S1 & S3, S2 | S4, R | R1, E1, Either<A, A1>>;
 /**
  * @tsplus fluent fncts.control.Z provideEnvironment
  * @tsplus location "@fncts/base/control/Z/api"
@@ -256,7 +256,7 @@ export declare function provideEnvironment_<W, S1, S2, R, E, A>(fa: Z<W, S1, S2,
  * @tsplus static fncts.control.ZOps put
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function put<S>(s: S): Z<never, unknown, S, unknown, never, void>;
+export declare function put<S>(s: S): Z<never, unknown, S, never, never, void>;
 /**
  * Repeats this computation the specified number of times (or until the first failure)
  * passing the updated state to each successive repetition.
@@ -275,12 +275,12 @@ export declare function repeatUntil_<W, S1, S2 extends S1, R, E, A>(ma: Z<W, S1,
  * @tsplus static fncts.control.ZOps succeed
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function succeed<A, W = never, S1 = unknown, S2 = never>(effect: Lazy<A>, __tsplusTrace?: string): Z<W, S1, S2, unknown, never, A>;
+export declare function succeed<A, W = never, S1 = unknown, S2 = never>(effect: Lazy<A>, __tsplusTrace?: string): Z<W, S1, S2, never, never, A>;
 /**
  * @tsplus static fncts.control.ZOps succeedNow
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function succeedNow<A, W = never, S1 = unknown, S2 = never>(a: A, __tsplusTrace?: string): Z<W, S1, S2, unknown, never, A>;
+export declare function succeedNow<A, W = never, S1 = unknown, S2 = never>(a: A, __tsplusTrace?: string): Z<W, S1, S2, never, never, A>;
 /**
  * @tsplus fluent fncts.control.Z tap
  * @tsplus location "@fncts/base/control/Z/api"
@@ -290,12 +290,12 @@ export declare function tap_<W, S1, S2, R, E, A, W1, S3, R1, E1, B>(ma: Z<W, S1,
  * @tsplus static fncts.control.ZOps tell
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function tell<W>(w: W): Z<W, unknown, never, unknown, never, void>;
+export declare function tell<W>(w: W): Z<W, unknown, never, never, never, void>;
 /**
  * @tsplus static fncts.control.ZOps tellAll
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function tellAll<W>(ws: Conc<W>): Z<W, unknown, never, unknown, never, void>;
+export declare function tellAll<W>(ws: Conc<W>): Z<W, unknown, never, never, never, void>;
 /**
  * Like `map`, but also allows the state to be modified.
  * @tsplus fluent fncts.control.Z transform
@@ -306,13 +306,13 @@ export declare function transform_<W, S1, S2, R, E, A, S3, B>(ma: Z<W, S1, S2, R
  * @tsplus static fncts.control.ZOps unit
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare const unit: Z<never, unknown, never, unknown, never, void>;
+export declare const unit: Z<never, unknown, never, never, never, void>;
 /**
  * Constructs a computation from the specified update function.
  * @tsplus static fncts.control.ZOps update
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function update<S1, S2>(f: (s: S1) => S2): Z<never, S1, S2, unknown, never, void>;
+export declare function update<S1, S2>(f: (s: S1) => S2): Z<never, S1, S2, never, never, void>;
 /**
  * @tsplus fluent fncts.control.Z write
  * @tsplus location "@fncts/base/control/Z/api"

package/control/Z/definition.d.ts

@@ -32,7 +32,7 @@ export declare abstract class Z<W, S1, S2, R, E, A> {
     readonly _W: () => W;
     readonly _S1: (_: S1) => void;
     readonly _S2: () => S2;
-    readonly _R: (_: R) => void;
+    readonly _R: () => R;
     readonly _E: () => E;
     readonly _A: () => A;
 }
@@ -71,12 +71,12 @@ export declare const enum ZTag {
     Listen = "Listen",
     MapLog = "MapLog"
 }
-export declare class SucceedNow<A> extends Z<never, unknown, never, unknown, never, A> {
+export declare class SucceedNow<A> extends Z<never, unknown, never, never, never, A> {
     readonly value: A;
     readonly _tag = ZTag.SucceedNow;
     constructor(value: A);
 }
-export declare class Succeed<A> extends Z<never, unknown, never, unknown, never, A> {
+export declare class Succeed<A> extends Z<never, unknown, never, never, never, A> {
     readonly effect: () => A;
     readonly _tag = ZTag.Succeed;
     constructor(effect: () => A);
@@ -86,12 +86,12 @@ export declare class Defer<W, S1, S2, R, E, A> extends Z<W, S1, S2, R, E, A> {
     readonly _tag = ZTag.Defer;
     constructor(make: () => Z<W, S1, S2, R, E, A>);
 }
-export declare class Fail<E> extends Z<never, unknown, never, unknown, E, never> {
+export declare class Fail<E> extends Z<never, unknown, never, never, E, never> {
     readonly cause: Cause<E>;
     readonly _tag = ZTag.Fail;
     constructor(cause: Cause<E>);
 }
-export declare class Modify<S1, S2, A> extends Z<never, S1, S2, unknown, never, A> {
+export declare class Modify<S1, S2, A> extends Z<never, S1, S2, never, never, A> {
     readonly run: (s1: S1) => readonly [A, S2];
     readonly _tag = ZTag.Modify;
     constructor(run: (s1: S1) => readonly [A, S2]);
@@ -120,7 +120,7 @@ export declare class Provide<W, S1, S2, R, E, A> extends Z<W, S1, S2, never, E,
     readonly _tag = ZTag.Provide;
     constructor(ma: Z<W, S1, S2, R, E, A>, env: Environment<R>);
 }
-export declare class Tell<W> extends Z<W, unknown, never, unknown, never, void> {
+export declare class Tell<W> extends Z<W, unknown, never, never, never, void> {
     readonly log: Conc<W>;
     readonly _tag = ZTag.Tell;
     constructor(log: Conc<W>);

package/control/Z/runtime.d.ts

@@ -35,22 +35,22 @@ export declare function unsafeRunReader_<W, R, A>(ma: Z<W, unknown, never, R, ne
  * @tsplus fluent fncts.control.Z unsafeRunState
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A>, s: S1): S2;
+export declare function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): S2;
 /**
  * Runs this computation with the specified initial state, returning the
  * result and discarding the updated state.
  * @tsplus fluent fncts.control.Z unsafeRunStateResult
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A>, s: S1): A;
+export declare function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): A;
 /**
  * Runs this computation returning either the result or error
  * @tsplus getter fncts.control.Z unsafeRunExit
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, unknown, E, A>): Exit<E, A>;
+export declare function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, never, E, A>): Exit<E, A>;
 /**
  * @tsplus getter fncts.control.Z unsafeRunWriter
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunWriter<W, A>(ma: Z<W, unknown, unknown, unknown, never, A>): readonly [Conc<W>, A];
+export declare function unsafeRunWriter<W, A>(ma: Z<W, unknown, unknown, never, never, A>): readonly [Conc<W>, A];

package/control.d.ts

@@ -0,0 +1,3 @@
+export type {} from "./control/Eval.js";
+export type {} from "./control/LazyValue.js";
+export type {} from "./control/Z.js";

package/data/DecodeError/definition.d.ts

@@ -139,3 +139,9 @@ export declare class UnionError extends DecodeError {
     constructor(label: string, errors: Vector<DecodeError>);
     render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
 }
+export declare class EmptyError extends DecodeError {
+    readonly actual: unknown;
+    readonly _tag = "EmptyError";
+    constructor(actual: unknown);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}

package/data/DecodeError/instances.d.ts

@@ -0,0 +1 @@
+export {};

package/data/DecodeError.d.ts

@@ -1 +1,2 @@
 export * from "./DecodeError/definition.js";
+export * from "./DecodeError/instances.js";

package/data/Environment/definition.d.ts

@@ -13,12 +13,11 @@ export declare type EnvSymbol = typeof EnvSymbol;
  * @tsplus companion fncts.EnvironmentOps
  */
 export declare class Environment<R> implements Hashable, Equatable {
-    readonly map: HashMap<Tag<any>, readonly [unknown, number]>;
-    readonly index: number;
+    readonly map: HashMap<Tag<any>, unknown>;
     cache: HashMap<Tag<any>, unknown>;
     readonly _typeId: EnvSymbol;
     readonly [EnvSymbol]: (_: never) => R;
-    constructor(map: HashMap<Tag<any>, readonly [unknown, number]>, index: number, cache?: HashMap<Tag<any>, unknown>);
+    constructor(map: HashMap<Tag<any>, unknown>, cache?: HashMap<Tag<any>, unknown>);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }

package/data/Maybe/definition.d.ts

@@ -18,7 +18,7 @@ export interface MaybeF extends HKT {
  * @tsplus companion fncts.MaybeOps
  */
 export declare class Maybe<A> {
-    readonly _A: () => A;
+    _A: () => A;
     readonly _typeId: MaybeTypdId;
 }
 /**
@@ -44,7 +44,9 @@ export declare class Nothing extends Maybe<never> {
 /**
  * @tsplus unify fncts.Maybe
  */
-export declare function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [Maybe<infer A>] ? A : never>;
+export declare function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [{
+    _A: () => infer A;
+}] ? A : never>;
 /**
  * @tsplus static fncts.MaybeOps isMaybe
  * @tsplus location "@fncts/base/data/Maybe/definition"

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>(): Tag<T>;
+export declare function makeTag<T>(id: string): Tag<T>;

package/data/Tag/definition.d.ts

@@ -9,10 +9,11 @@ export declare type TagTypeId = typeof TagTypeId;
  * @tsplus companion fncts.TagOps
  */
 export declare class Tag<in out T> implements Hashable, Equatable {
+    readonly id: string;
     _T: (_: T) => T;
     readonly _typeId: TagTypeId;
     private static counter;
-    readonly id: number;
+    constructor(id: string);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }

package/data/string/api.d.ts

@@ -139,7 +139,7 @@ export declare function under_(s: string, f: (chars: Array<string>) => Array<str
 export declare const under: (f: (chars: Array<string>) => Array<string>) => (s: string) => string;
 /**
  * Join newline-separated strings together.
- * @tsplus getter fncts.base.ImmutableArray unlines
+ * @tsplus getter fncts.ImmutableArray unlines
  * @tsplus location "@fncts/base/data/string/api"
  */
 export declare function unlines(as: ReadonlyArray<string>): string;

package/data.d.ts

@@ -0,0 +1,33 @@
+export type {} from "./data/bigint.js";
+export type {} from "./data/boolean.js";
+export type {} from "./data/Branded.js";
+export type {} from "./data/Byte.js";
+export type {} from "./data/CaseClass.js";
+export type {} from "./data/Cause.js";
+export type {} from "./data/Const.js";
+export type {} from "./data/DecodeError.js";
+export type {} from "./data/Decoder.js";
+export type {} from "./data/Duration.js";
+export type {} from "./data/Either.js";
+export type {} from "./data/Environment.js";
+export type {} from "./data/exceptions.js";
+export type {} from "./data/ExecutionStrategy.js";
+export type {} from "./data/Exit.js";
+export type {} from "./data/FiberId.js";
+export type {} from "./data/function.js";
+export type {} from "./data/Identity.js";
+export type {} from "./data/Interval.js";
+export type {} from "./data/Intervals.js";
+export type {} from "./data/Maybe.js";
+export type {} from "./data/Newtype.js";
+export type {} from "./data/number.js";
+export type {} from "./data/object.js";
+export type {} from "./data/Patch.js";
+export type {} from "./data/Predicate.js";
+export type {} from "./data/Refinement.js";
+export type {} from "./data/string.js";
+export type {} from "./data/Tag.js";
+export type {} from "./data/These.js";
+export type {} from "./data/Trace.js";
+export type {} from "./data/TraceElement.js";
+export type {} from "./data/Zipped.js";