@fncts/base 0.0.31 → 0.0.33

package/_src/collection/mutable.ts

@@ -1,6 +1,9 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./mutable/*.ts }
-export type {} from "./mutable/HashMap.js";
-export type {} from "./mutable/HashSet.js";
 export type {} from "./mutable/internal.js";
+export type {} from "./mutable/Queue.js";
 export type {} from "./mutable/ListBuffer.js";
+export type {} from "./mutable/HashSet.js";
+export type {} from "./mutable/HashMap.js";
+export type {} from "./mutable/ArrayDeque.js";
 // codegen:end

package/_src/collection/weak.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./weak/*.ts }
-export type {} from "./weak/IterableWeakMap.js";
 export type {} from "./weak/IterableWeakSet.js";
+export type {} from "./weak/IterableWeakMap.js";
 // codegen:end

package/_src/collection.ts

@@ -1,7 +1,8 @@
-// codegen:start { preset: type-barrel, include: ./collection/*.ts }
-export type {} from "./collection/compat.js";
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: type-barrel, include: ./collection/*.ts, exclude: collection/internal.ts }
+export type {} from "./collection/weak.js";
+export type {} from "./collection/mutable.js";
 export type {} from "./collection/immutable.js";
+export type {} from "./collection/compat.js";
 export type {} from "./collection/Iterable.js";
-export type {} from "./collection/mutable.js";
-export type {} from "./collection/weak.js";
 // codegen:end

package/_src/control/Eval/api.ts

@@ -114,6 +114,7 @@ export function gen<T extends GenEval<any>, A>(
   });
 }
 
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: api/*.ts }
 export * from "./api/sequenceArray.js";
 // codegen:end

package/_src/control/Eval.ts

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

package/_src/control/InterruptiblePromise.ts

@@ -0,0 +1,23 @@
+/**
+ * @tsplus type fncts.InterruptiblePromise
+ * @tsplus companion fncts.InterruptiblePromiseOps
+ */
+export interface InterruptiblePromise<A> extends Promise<A> {
+  interrupt: () => void;
+}
+
+/**
+ * @tsplus static fncts.InterruptiblePromiseOps __call
+ */
+export function make<A>(
+  executor: (resolve: (value: A | PromiseLike<A>) => void, reject: (reason?: unknown) => void) => (() => void) | void,
+): InterruptiblePromise<A> {
+  const promise: InterruptiblePromise<A> = new Promise((resolve, reject) => {
+    const canceller   = executor(resolve, reject);
+    promise.interrupt = () => {
+      canceller?.();
+      reject(new InterruptedException());
+    };
+  }) as InterruptiblePromise<A>;
+  return promise;
+}

package/_src/control/Pure/api.ts

@@ -8,7 +8,7 @@ import { identity, tuple } from "../../data/function.js";
 export function absolve<W, S1, S2, R, E, E1, A>(
   fa: Pure<W, S1, S2, R, E, Either<E1, A>>,
 ): Pure<W, S1, S2, R, E | E1, A> {
-  return fa.flatMap((ea) => ea.match(Pure.failNow, Pure.succeedNow));
+  return fa.flatMap((ea) => ea.match({ Left: Pure.failNow, Right: Pure.succeedNow }));
 }
 
 /**
@@ -350,7 +350,10 @@ export function matchPure<S5, S2, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(
   onSuccess: (a: A) => Pure<W2, S2, S4, R2, E2, C>,
 ) {
   return <W, S1, R>(fa: Pure<W, S1, S2, R, E, A>): Pure<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C> => {
-    return fa.matchCausePure((cause) => cause.failureOrCause.match(onFailure, Pure.failCauseNow), onSuccess);
+    return fa.matchCausePure(
+      (cause) => cause.failureOrCause.match({ Left: onFailure, Right: Pure.failCauseNow }),
+      onSuccess,
+    );
   };
 }
 
@@ -378,7 +381,7 @@ export function matchLogPure<W, S5, S2, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2,
 ) {
   return <S1, R>(fa: Pure<W, S1, S2, R, E, A>): Pure<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C> => {
     return fa.matchLogCausePure(
-      (ws, cause) => cause.failureOrCause.match((e) => onFailure(ws, e), Pure.failCauseNow),
+      (ws, cause) => cause.failureOrCause.match({ Left: (e) => onFailure(ws, e), Right: Pure.failCauseNow }),
       onSuccess,
     );
   };
@@ -428,7 +431,7 @@ export function modifyEither<S1, S2, E, A>(
 ): Pure<never, S1, S2, never, E, A> {
   return Pure.get<S1>()
     .map(f)
-    .flatMap((r) => r.match(Pure.failNow, ([a, s2]) => Pure.succeedNow(a).mapState(() => s2)));
+    .flatMap((r) => r.match({ Left: Pure.failNow, Right: ([a, s2]) => Pure.succeedNow(a).mapState(() => s2) }));
 }
 
 /**

package/_src/control/Pure.ts

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

package/_src/control.ts

@@ -1,6 +1,8 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./control/*.ts }
-export type {} from "./control/CompletablePromise.js";
-export type {} from "./control/Eval.js";
-export type {} from "./control/LazyValue.js";
 export type {} from "./control/Pure.js";
+export type {} from "./control/LazyValue.js";
+export type {} from "./control/InterruptiblePromise.js";
+export type {} from "./control/Eval.js";
+export type {} from "./control/CompletablePromise.js";
 // codegen:end

package/_src/data/Branded/definition.ts

@@ -23,17 +23,18 @@ export declare namespace Brand {
     : never;
 
   export type Unbranded<P> = P extends infer Q & Brands<P> ? Q : P;
-  export type Brands<P> = P extends Valid<any, any>
-    ? Union.IntersectionOf<
-        {
-          [K in keyof P[Brand.valid]]: P extends P[Brand.valid][K]
-            ? K extends string
-              ? Valid<P[Brand.valid][K], K>
-              : never
-            : never;
-        }[keyof P[Brand.valid]]
-      >
-    : unknown;
+  export type Brands<P> =
+    P extends Valid<any, any>
+      ? Union.IntersectionOf<
+          {
+            [K in keyof P[Brand.valid]]: P extends P[Brand.valid][K]
+              ? K extends string
+                ? Valid<P[Brand.valid][K], K>
+                : never
+              : never;
+          }[keyof P[Brand.valid]]
+        >
+      : unknown;
 }
 
 /**
@@ -42,7 +43,10 @@ export declare namespace Brand {
  * @tsplus derive nominal
  */
 export class Validation<in out A, in out K extends string> {
-  constructor(readonly validate: Refinement<A, A & Brand.Valid<A, K>>, readonly name: K) {}
+  constructor(
+    readonly validate: Refinement<A, A & Brand.Valid<A, K>>,
+    readonly name: K,
+  ) {}
 }
 
 /**

package/_src/data/Branded.ts

@@ -1,3 +1,4 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Branded/*.ts }
 export * from "./Branded/definition.js";
 // codegen:end

package/_src/data/CaseClass.ts

@@ -45,6 +45,7 @@ export const CaseClass: CaseConstructor = class<T extends Record<PropertyKey, an
   get [Symbol.hash](): number {
     let h = hash0;
     for (const k of this[keysSymbol]) {
+      // @ts-expect-error
       h = Hashable.combine(h, Hashable.unknown(this[k]!));
     }
     return h;
@@ -67,6 +68,7 @@ export const CaseClass: CaseConstructor = class<T extends Record<PropertyKey, an
       while (result && i < len) {
         result =
           this[keysSymbol][i] === thatKeys[i] &&
+          // @ts-expect-error
           Equatable.strictEquals(this[this[keysSymbol]![i]!] as {}, (that as T)[thatKeys[i]!]);
         i++;
       }

package/_src/data/Cause/api/linearize.ts

@@ -1,4 +1,4 @@
-import { Fail, Halt, Interrupt, Sequential,Stackless } from "../definition.js";
+import { Fail, Halt, Interrupt, Sequential, Stackless } from "../definition.js";
 
 /**
  * @tsplus getter fncts.Cause linearize

package/_src/data/Cause/api.ts

@@ -285,7 +285,10 @@ class FCEStackFrameThenLeft<E, A> {
 class FCEStackFrameThenRight<E, A> {
   readonly _tag = "FCEStackFrameThenRight";
 
-  constructor(readonly cause: Sequential<Either<E, A>>, readonly leftResult: Either<Cause<E>, A>) {}
+  constructor(
+    readonly cause: Sequential<Either<E, A>>,
+    readonly leftResult: Either<Cause<E>, A>,
+  ) {}
 }
 
 class FCEStackFrameBothLeft<E, A> {
@@ -297,7 +300,10 @@ class FCEStackFrameBothLeft<E, A> {
 class FCEStackFrameBothRight<E, A> {
   readonly _tag = "FCEStackFrameBothRight";
 
-  constructor(readonly cause: Parallel<Either<E, A>>, readonly leftResult: Either<Cause<E>, A>) {}
+  constructor(
+    readonly cause: Parallel<Either<E, A>>,
+    readonly leftResult: Either<Cause<E>, A>,
+  ) {}
 }
 
 type FCEStackFrame<E, A> =
@@ -333,10 +339,10 @@ export function flipCauseEither<E, A>(self: Cause<Either<E, A>>): Either<Cause<E
           result = Either.left(c);
           break pushing;
         case CauseTag.Fail:
-          result = c.value.match(
-            (l) => Either.left(Cause.fail(l, Trace.none)),
-            (r) => Either.right(r),
-          );
+          result = c.value.match({
+            Left: (l) => Either.left(Cause.fail(l, Trace.none)),
+            Right: (r) => Either.right(r),
+          });
           break pushing;
         case CauseTag.Sequential:
           stack.push(new FCEStackFrameThenLeft(c));
@@ -418,7 +424,10 @@ class FCOStackFrameThenLeft<E> {
 class FCOStackFrameThenRight<E> {
   readonly _tag = "FCOStackFrameThenRight";
 
-  constructor(readonly cause: Sequential<Maybe<E>>, readonly leftResult: Maybe<Cause<E>>) {}
+  constructor(
+    readonly cause: Sequential<Maybe<E>>,
+    readonly leftResult: Maybe<Cause<E>>,
+  ) {}
 }
 
 class FCOStackFrameBothLeft<E> {
@@ -430,7 +439,10 @@ class FCOStackFrameBothLeft<E> {
 class FCOStackFrameBothRight<E> {
   readonly _tag = "FCOStackFrameBothRight";
 
-  constructor(readonly cause: Parallel<Maybe<E>>, readonly leftResult: Maybe<Cause<E>>) {}
+  constructor(
+    readonly cause: Parallel<Maybe<E>>,
+    readonly leftResult: Maybe<Cause<E>>,
+  ) {}
 }
 
 type FCOStackFrame<E> =
@@ -859,18 +871,18 @@ export function stripSomeDefects(p: Predicate<unknown>) {
         l.isJust() && r.isJust()
           ? Just(Sequential(l.value, r.value))
           : l.isJust()
-          ? Just(l.value)
-          : r.isJust()
-          ? Just(r.value)
-          : Nothing(),
+            ? Just(l.value)
+            : r.isJust()
+              ? Just(r.value)
+              : Nothing(),
       Both: (l, r) =>
         l.isJust() && r.isJust()
           ? Just(Sequential(l.value, r.value))
           : l.isJust()
-          ? Just(l.value)
-          : r.isJust()
-          ? Just(r.value)
-          : Nothing(),
+            ? Just(l.value)
+            : r.isJust()
+              ? Just(r.value)
+              : Nothing(),
       Stackless: (causeOption, stackless) => causeOption.map((cause) => Stackless(cause, stackless)),
     });
   };
@@ -886,10 +898,10 @@ function sequenceCauseEitherEval<E, A>(self: Cause<Either<E, A>>): Eval<Either<C
     }
     case CauseTag.Fail: {
       return Eval.now(
-        self.value.match(
-          (e) => Either.left(Cause.fail(e, Trace.none)),
-          (a) => Either.right(a),
-        ),
+        self.value.match({
+          Left: (e) => Either.left(Cause.fail(e, Trace.none)),
+          Right: (a) => Either.right(a),
+        }),
       );
     }
     case CauseTag.Halt: {
@@ -965,8 +977,8 @@ function sequenceCauseMaybeEval<E>(self: Cause<Maybe<E>>): Eval<Maybe<Cause<E>>>
               ? Maybe.just(Cause.sequential(lefts.value, rights.value))
               : lefts
             : rights._tag === MaybeTag.Just
-            ? rights
-            : Maybe.nothing();
+              ? rights
+              : Maybe.nothing();
         },
       );
     }
@@ -981,8 +993,8 @@ function sequenceCauseMaybeEval<E>(self: Cause<Maybe<E>>): Eval<Maybe<Cause<E>>>
               ? Maybe.just(Cause.parallel(lefts.value, rights.value))
               : lefts
             : rights._tag === MaybeTag.Just
-            ? rights
-            : Maybe.nothing();
+              ? rights
+              : Maybe.nothing();
         },
       );
     }
@@ -1038,6 +1050,7 @@ export function squashWith<E>(f: (e: E) => unknown) {
  *
  * @tsplus static fncts.CauseOps sequential
  * @tsplus static fncts.Cause.SequentialOps __call
+ * @tsplus operator fncts.Cause +
  */
 export function sequential<E, E1>(left: Cause<E>, right: Cause<E1>): Cause<E | E1> {
   return left.isEmpty ? right : right.isEmpty ? left : new Sequential<E | E1>(left, right);

package/_src/data/Cause/definition.ts

@@ -81,7 +81,10 @@ export class Fail<E> implements Equatable {
   };
   readonly _tag = CauseTag.Fail;
 
-  constructor(readonly value: E, readonly trace: Trace) {}
+  constructor(
+    readonly value: E,
+    readonly trace: Trace,
+  ) {}
 
   get [Symbol.hash](): number {
     return Hashable.combine(Hashable.string(this._tag), Hashable.unknown(this.value));
@@ -119,7 +122,10 @@ export class Halt implements Equatable {
   };
   readonly _tag = CauseTag.Halt;
 
-  constructor(readonly value: unknown, readonly trace: Trace) {}
+  constructor(
+    readonly value: unknown,
+    readonly trace: Trace,
+  ) {}
 
   get [Symbol.hash](): number {
     return Hashable.combine(Hashable.string(this._tag), Hashable.unknown(this.value));
@@ -157,7 +163,10 @@ export class Interrupt implements Equatable {
   };
   readonly _tag = CauseTag.Interrupt;
 
-  constructor(readonly id: FiberId, readonly trace: Trace) {}
+  constructor(
+    readonly id: FiberId,
+    readonly trace: Trace,
+  ) {}
 
   get [Symbol.hash](): number {
     return Hashable.combine(Hashable.string(this._tag), Hashable.unknown(this.id));
@@ -196,7 +205,10 @@ export class Sequential<E> implements Equatable {
   };
   readonly _tag = CauseTag.Sequential;
 
-  constructor(readonly left: Cause<E>, readonly right: Cause<E>) {}
+  constructor(
+    readonly left: Cause<E>,
+    readonly right: Cause<E>,
+  ) {}
 
   get [Symbol.hash](): number {
     return hashCode(this);
@@ -230,7 +242,10 @@ export class Parallel<E> implements Equatable {
   };
   readonly _tag = CauseTag.Parallel;
 
-  constructor(readonly left: Cause<E>, readonly right: Cause<E>) {}
+  constructor(
+    readonly left: Cause<E>,
+    readonly right: Cause<E>,
+  ) {}
 
   get [Symbol.hash](): number {
     return hashCode(this);
@@ -264,7 +279,10 @@ export class Stackless<E> implements Equatable {
   };
   readonly _tag = CauseTag.Stackless;
 
-  constructor(readonly cause: Cause<E>, readonly stackless: boolean) {}
+  constructor(
+    readonly cause: Cause<E>,
+    readonly stackless: boolean,
+  ) {}
 
   get [Symbol.hash](): number {
     return this.cause[Symbol.hash];
@@ -280,7 +298,11 @@ export class Stackless<E> implements Equatable {
 }
 
 export class Unified {
-  constructor(readonly fiberId: FiberId, readonly message: ReadonlyArray<string>, readonly trace: Conc<string>) {}
+  constructor(
+    readonly fiberId: FiberId,
+    readonly message: ReadonlyArray<string>,
+    readonly trace: Conc<string>,
+  ) {}
 }
 
 /*

package/_src/data/Cause.ts

@@ -1,11 +1,13 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Cause/*.ts }
-export * from "./Cause/api.js";
 export * from "./Cause/definition.js";
+export * from "./Cause/api.js";
 // codegen:end
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Cause/api/*.ts }
-export * from "./Cause/api/fold.js";
-export * from "./Cause/api/isEmpty.js";
-export * from "./Cause/api/linearize.js";
-export * from "./Cause/api/prettyPrint.js";
 export * from "./Cause/api/unified.js";
+export * from "./Cause/api/prettyPrint.js";
+export * from "./Cause/api/linearize.js";
+export * from "./Cause/api/isEmpty.js";
+export * from "./Cause/api/fold.js";
 // codegen:end

package/_src/data/Const.ts

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

package/_src/data/Date.ts

@@ -1,3 +1,4 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Date/*.ts }
 export * from "./Date/definition.js";
 // codegen:end

package/_src/data/Datum/api.ts

@@ -336,15 +336,15 @@ export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
       Initial: () => [Initial(), Initial()],
       Pending: () => [Pending(), Pending()],
       Refresh: (a) =>
-        f(a).match(
-          (b) => [Refresh(b), Initial()],
-          (c) => [Initial(), Refresh(c)],
-        ),
+        f(a).match({
+          Left: (b) => [Refresh(b), Initial()],
+          Right: (c) => [Initial(), Refresh(c)],
+        }),
       Replete: (a) =>
-        f(a).match(
-          (b) => [Replete(b), Initial()],
-          (c) => [Initial(), Replete(c)],
-        ),
+        f(a).match({
+          Left: (b) => [Replete(b), Initial()],
+          Right: (c) => [Initial(), Replete(c)],
+        }),
     });
   };
 }

package/_src/data/DatumEither/api.ts

@@ -303,16 +303,16 @@ export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
       Pending: () => [self.unsafeCoerce(), self.unsafeCoerce()],
       RefreshLeft: () => [self.unsafeCoerce(), self.unsafeCoerce()],
       RefreshRight: (a) =>
-        f(a).match(
-          (b) => [DatumEither.refreshRight(b), DatumEither.initial()],
-          (c) => [DatumEither.initial(), DatumEither.refreshRight(c)],
-        ),
+        f(a).match({
+          Left: (b) => [DatumEither.refreshRight(b), DatumEither.initial()],
+          Right: (c) => [DatumEither.initial(), DatumEither.refreshRight(c)],
+        }),
       RepleteLeft: () => [self.unsafeCoerce(), self.unsafeCoerce()],
       RepleteRight: (a) =>
-        f(a).match(
-          (b) => [DatumEither.repleteRight(b), DatumEither.initial()],
-          (c) => [DatumEither.initial(), DatumEither.repleteRight(c)],
-        ),
+        f(a).match({
+          Left: (b) => [DatumEither.repleteRight(b), DatumEither.initial()],
+          Right: (c) => [DatumEither.initial(), DatumEither.repleteRight(c)],
+        }),
     });
   };
 }

package/_src/data/DatumEither.ts

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

package/_src/data/DecodeError/definition.ts

@@ -12,7 +12,10 @@ export abstract class DecodeError {
 
 export class RequiredKeyError extends DecodeError {
   readonly _tag = "RequiredKey";
-  constructor(readonly key: string, readonly error: DecodeError) {
+  constructor(
+    readonly key: string,
+    readonly error: DecodeError,
+  ) {
     super();
   }
   render = Eval.defer(this.error.render.map((error) => RoseTree(`on required key ${this.key}`, Vector(error))));
@@ -20,7 +23,10 @@ export class RequiredKeyError extends DecodeError {
 
 export class OptionalKeyError extends DecodeError {
   readonly _tag = "OptionalKey";
-  constructor(readonly key: PropertyKey, readonly error: DecodeError) {
+  constructor(
+    readonly key: PropertyKey,
+    readonly error: DecodeError,
+  ) {
     super();
   }
   render = Eval.defer(this.error.render.map((error) => RoseTree(`on optional key ${show(this.key)}`, Vector(error))));
@@ -28,7 +34,10 @@ export class OptionalKeyError extends DecodeError {
 
 export class RequiredIndexError<I, E extends DecodeError> extends DecodeError {
   readonly _tag = "RequiredIndex";
-  constructor(readonly index: I, readonly error: E) {
+  constructor(
+    readonly index: I,
+    readonly error: E,
+  ) {
     super();
   }
   render = Eval.defer(this.error.render.map((error) => RoseTree(`on required index ${this.index}`, Vector(error))));
@@ -36,7 +45,10 @@ export class RequiredIndexError<I, E extends DecodeError> extends DecodeError {
 
 export class OptionalIndexError<I, E extends DecodeError> extends DecodeError {
   readonly _tag = "RequiredIndex";
-  constructor(readonly index: I, readonly error: E) {
+  constructor(
+    readonly index: I,
+    readonly error: E,
+  ) {
     super();
   }
   render = Eval.defer(this.error.render.map((error) => RoseTree(`on optional index ${this.index}`, Vector(error))));
@@ -52,7 +64,10 @@ export class LazyError<E extends DecodeError> extends DecodeError {
 
 export class MemberError extends DecodeError {
   readonly _tag = "Member";
-  constructor(readonly label: string, readonly error: DecodeError) {
+  constructor(
+    readonly label: string,
+    readonly error: DecodeError,
+  ) {
     super();
   }
   render = Eval.defer(this.error.render.map((error) => RoseTree(`on member ${this.label}`, Vector(error))));
@@ -69,7 +84,10 @@ function startsWithVowel(s: string): boolean {
 
 export class CompoundError<E extends DecodeError> extends DecodeError {
   readonly _tag = "Compound";
-  constructor(readonly name: string, readonly errors: Vector<E>) {
+  constructor(
+    readonly name: string,
+    readonly errors: Vector<E>,
+  ) {
     super();
   }
   render = Eval.defer(
@@ -136,7 +154,10 @@ export class BooleanError extends DecodeError {
 
 export class PrimitiveError extends DecodeError {
   readonly _tag = "Primitive";
-  constructor(readonly actual: unknown, readonly name: string) {
+  constructor(
+    readonly actual: unknown,
+    readonly name: string,
+  ) {
     super();
   }
   render = Eval(RoseTree(cannotDecode(this.actual, this.name)));
@@ -144,7 +165,10 @@ export class PrimitiveError extends DecodeError {
 
 export class LiteralError<A extends Literal> extends DecodeError {
   readonly _tag = "Literal";
-  constructor(readonly actual: unknown, readonly literals: Vector<A>) {
+  constructor(
+    readonly actual: unknown,
+    readonly literals: Vector<A>,
+  ) {
     super();
   }
   render = Eval(
@@ -205,7 +229,10 @@ function cannotDecode(u: unknown, expected: string): string {
 
 export class BrandedError extends DecodeError {
   readonly _tag = "BrandedError";
-  constructor(readonly name: string, readonly brands: Vector<string>) {
+  constructor(
+    readonly name: string,
+    readonly brands: Vector<string>,
+  ) {
     super();
   }
   render = Eval(
@@ -218,7 +245,10 @@ export class BrandedError extends DecodeError {
 
 export class UnionError extends DecodeError {
   readonly _tag = "UnionError";
-  constructor(readonly label: string, readonly errors: Vector<DecodeError>) {
+  constructor(
+    readonly label: string,
+    readonly errors: Vector<DecodeError>,
+  ) {
     super();
   }
   render = Eval.defer(

package/_src/data/DecodeError.ts

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