@fncts/base 0.0.32 → 0.0.34

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

package/_src/data/Decoder/api.ts

@@ -181,6 +181,7 @@ export function struct<A extends Record<string, any>>(fields: {
         errors.push(new RequiredKeyError(key, new MissingKeyError(key)));
         errored = true;
       } else {
+        // @ts-expect-error
         const res = (fields[key] as Decoder<any>).decode(input[key as string]);
         res.match2(
           (e) => {
@@ -237,7 +238,9 @@ export function partial<A extends Record<string, any>>(fields: {
     const errors: Array<RequiredKeyError | OptionalKeyError> = [];
     const decoded = {} as A;
     for (const key in fields) {
+      // @ts-expect-error
       if (key in input && typeof input[key as string] !== "undefined") {
+        // @ts-expect-error
         const res = (fields[key] as Decoder<any>).decode(input[key as string]);
         res.match2(
           (e) => {
@@ -288,8 +291,10 @@ export function deriveStruct<A extends Record<string, any>>(
   let first = true;
   for (const k in requiredFields) {
     if (first) {
+      // @ts-expect-error
       label += ` ${k}: ${(requiredFields[k] as Decoder<any>).label}`;
     } else {
+      // @ts-expect-error
       label += `, ${k}: ${(requiredFields[k] as Decoder<any>).label}`;
     }
     first = false;
@@ -322,6 +327,7 @@ export function deriveStruct<A extends Record<string, any>>(
         errors.push(new RequiredKeyError(key, new MissingKeyError(key)));
         errored = true;
       } else {
+        // @ts-expect-error
         const res = (requiredFields[key] as Decoder<any>).decode(input[key]);
         res.match2(
           (e) => {
@@ -339,7 +345,9 @@ export function deriveStruct<A extends Record<string, any>>(
     }
     if (optionalFields) {
       for (const key in optionalFields) {
+        // @ts-expect-error
         if (key in input && typeof input[key as string] !== "undefined") {
+          // @ts-expect-error
           const res = (optionalFields[key] as Decoder<any>).decode(input[key as string]);
           res.match2(
             (e) => {
@@ -460,6 +468,7 @@ export function deriveRecord<A extends Record<string, any>>(
     const res     = {};
     for (const k in asRecord) {
       if (keyGuard.is(k)) {
+        // @ts-expect-error
         const valueResult = valueDecoder.decode(asRecord[k]);
         valueResult.match2(
           (e) => {
@@ -468,6 +477,7 @@ export function deriveRecord<A extends Record<string, any>>(
           },
           (warning, a) => {
             missing.delete(k);
+            // @ts-expect-error
             res[k] = a;
             if (warning.isJust()) {
               errors.push(new (k in requiredKeysRecord ? RequiredKeyError : OptionalKeyError)(k, warning.value));
@@ -682,5 +692,5 @@ export function deriveTuple<A extends ReadonlyArray<unknown>>(
  * @tsplus static fncts.DecoderOps tuple
  */
 export function tuple<A extends ReadonlyArray<unknown>>(...components: { [K in keyof A]: Decoder<A[K]> }): Decoder<A> {
-  return deriveTuple(components as [never]).unsafeCoerce()
+  return deriveTuple(components as [never]).unsafeCoerce();
 }

package/_src/data/Decoder/definition.ts

@@ -17,7 +17,10 @@ export interface DecoderF extends HKT {
  */
 export class Decoder<in out A> {
   readonly [DecoderTypeId]: DecoderTypeId = DecoderTypeId;
-  constructor(readonly decode: (input: unknown) => These<DecodeError, A>, readonly label: string) {}
+  constructor(
+    readonly decode: (input: unknown) => These<DecodeError, A>,
+    readonly label: string,
+  ) {}
 }
 
 /**

package/_src/data/Decoder.ts

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

package/_src/data/Duration/api.ts

@@ -47,13 +47,6 @@ export function product(multiplicand: number) {
   };
 }
 
-/**
- * @tsplus operator fncts.Duration *
- */
-export function multiplyInverted(multiplicand: number, self: Duration) {
-  return new Duration(Math.round(self.milliseconds) * multiplicand);
-}
-
 /**
  * @tsplus pipeable-operator fncts.Duration +
  */
@@ -93,3 +86,33 @@ export function lessThanOrEqualTo(that: Duration) {
     return self.milliseconds <= that.milliseconds;
   };
 }
+
+/**
+ * @tsplus fluent fncts.Duration greaterThanOrEqualTo
+ * @tsplus pipeable-operator fncts.Duration >=
+ */
+export function greaterThanOrEqualTo(that: Duration) {
+  return (self: Duration): boolean => {
+    return self.milliseconds >= that.milliseconds;
+  };
+}
+
+/**
+ * @tsplus fluent fncts.Duration lessThan
+ * @tsplus pipeable-operator fncts.Duration <
+ */
+export function lessThan(that: Duration) {
+  return (self: Duration): boolean => {
+    return self.milliseconds < that.milliseconds;
+  };
+}
+
+/**
+ * @tsplus fluent fncts.Duration greaterThan
+ * @tsplus pipeable-operator fncts.Duration >
+ */
+export function greaterThan(that: Duration) {
+  return (self: Duration): boolean => {
+    return self.milliseconds > that.milliseconds;
+  };
+}

package/_src/data/Duration.ts

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

package/_src/data/Either/api/alignWith.ts

@@ -15,7 +15,7 @@ export function alignWith<A, E2, B, C>(fb: Either<E2, B>, f: (_: These<A, B>) =>
         ? self
         : Right(f(These.right(fb.right)))
       : fb._tag === EitherTag.Left
-      ? Right(f(These.left(self.right)))
-      : Right(f(These.both(self.right, fb.right)));
+        ? Right(f(These.left(self.right)))
+        : Right(f(These.both(self.right, fb.right)));
   };
 }

package/_src/data/Either/api.ts

@@ -294,7 +294,8 @@ export function toMaybe<E, A>(self: Either<E, A>): Maybe<A> {
   });
 }
 
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: api/*.ts }
-export * from "./api/align.js";
 export * from "./api/alignWith.js";
+export * from "./api/align.js";
 // codegen:end

package/_src/data/Either/definition.ts

@@ -26,10 +26,11 @@ type IOTypeId = typeof IOTypeId;
  * @tsplus type fncts.Either
  * @tsplus companion fncts.EitherOps
  */
-export class Either<E, A> {
+export abstract class Either<E, A> {
   readonly [EitherTypeId]: EitherTypeId = EitherTypeId;
   readonly [IOTypeId]: IOTypeId         = IOTypeId;
   readonly trace?: string | undefined   = undefined;
+  readonly _ioOpCode                    = null;
   declare [EitherVariance]: {
     readonly _E: (_: never) => E;
     readonly _A: (_: never) => A;
@@ -44,7 +45,10 @@ const leftHash = Hashable.string(EitherTag.Left);
  */
 export class Left<E> extends Either<E, never> {
   readonly _tag = EitherTag.Left;
-  constructor(readonly left: E, readonly trace?: string) {
+  constructor(
+    readonly left: E,
+    readonly trace?: string,
+  ) {
     super();
   }
 
@@ -65,7 +69,10 @@ const rightHash = Hashable.string(EitherTag.Right);
  */
 export class Right<A> extends Either<never, A> {
   readonly _tag = EitherTag.Right;
-  constructor(readonly right: A, readonly trace?: string) {
+  constructor(
+    readonly right: A,
+    readonly trace?: string,
+  ) {
     super();
   }
 

package/_src/data/Either.ts

@@ -1,7 +1,8 @@
-// codegen:start {preset: barrel, include: Either/*.ts}
-export * from "./Either/api.js";
-export * from "./Either/constructors.js";
-export * from "./Either/definition.js";
-export * from "./Either/destructors.js";
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: barrel, include: Either/*.ts}
 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";
 // codegen:end

package/_src/data/Encoder/api.ts

@@ -118,11 +118,13 @@ export function deriveStruct<A extends Record<string, any>>(
   return Encoder((inp) => {
     const encoded = {};
     for (const field of Object.keys(requiredFields)) {
+      // @ts-expect-error
       encoded[field] = (requiredFields[field] as Encoder<unknown>).encode(inp[field]);
     }
     if (optionalFields) {
       for (const field of Object.keys(optionalFields)) {
         if (field in inp && typeof inp[field] !== undefined) {
+          // @ts-expect-error
           encoded[field] = (optionalFields[field] as Encoder<unknown>).encode(inp[field]);
         }
       }
@@ -140,6 +142,7 @@ export function struct<A extends Record<string, any>>(fields: {
   return Encoder((inp) => {
     const encoded = {};
     for (const field of Object.keys(fields)) {
+      // @ts-expect-error
       encoded[field] = fields[field]!.encode(inp[field]);
     }
     return encoded;
@@ -156,6 +159,7 @@ export function partial<A extends Record<string, any>>(fields: {
     const encoded = {};
     for (const field of Object.keys(fields)) {
       if (field in inp && typeof inp[field] !== undefined) {
+        // @ts-expect-error
         encoded[field] = fields[field]!.encode(inp[field]!);
       }
     }
@@ -238,6 +242,7 @@ export function deriveDictionary<A extends Record<string, any>>(
   return Encoder((inp) => {
     const encoded = {};
     for (const k of Object.keys(inp)) {
+      // @ts-expect-error
       encoded[k] = value.encode(inp[k]);
     }
     return encoded;
@@ -260,6 +265,7 @@ export function deriveRecord<A extends Record<string, any>>(
   return Encoder((inp) => {
     const encoded = {};
     for (const k of Object.keys(requiredKeys)) {
+      // @ts-expect-error
       encoded[k] = value.encode(inp[k]);
     }
     return encoded;
@@ -371,5 +377,5 @@ export function deriveTuple<A extends ReadonlyArray<unknown>>(
  * @tsplus static fncts.EncoderOps tuple
  */
 export function tuple<A extends ReadonlyArray<unknown>>(...components: { [K in keyof A]: Encoder<A[K]> }): Encoder<A> {
-  return deriveTuple(components as [never]).unsafeCoerce()
+  return deriveTuple(components as [never]).unsafeCoerce();
 }

package/_src/data/Encoder.ts

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

package/_src/data/Environment/ServiceNotFoundError.ts

@@ -0,0 +1,5 @@
+export class ServiceNotFoundError extends Error {
+  constructor(readonly tag: Tag<any, any>) {
+    super(`Service not found: ${tag.id}`);
+  }
+}

package/_src/data/Environment/api.ts

@@ -1,6 +1,13 @@
+import { ServiceNotFoundError } from "@fncts/base/data/Environment/ServiceNotFoundError";
+
 /**
  * @tsplus pipeable fncts.Environment add
  */
+export function add<H extends S, S = H>(service: H, tag: Tag<S>): <R>(self: Environment<R>) => Environment<R | S>;
+export function add<H extends S, S = H, I = S>(
+  service: H,
+  tag: Tag<S, I>,
+): <R>(self: Environment<R>) => Environment<R | I>;
 export function add<H extends S, S = H>(service: H, tag: Tag<S>) {
   return <R>(self: Environment<R>): Environment<R | S> => {
     return new Environment(self.map.set(tag, service));
@@ -12,13 +19,13 @@ export function add<H extends S, S = H>(service: H, tag: Tag<S>) {
  */
 export const empty = Environment();
 
-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
  */
 export function get<R, T extends Tags<R>>(tag: T) {
-  return (self: Environment<R>): T extends Tag<infer S> ? S : never => {
+  return (self: Environment<R>): Tag.Service<T> => {
     return unsafeCoerce(self.unsafeGet(tag));
   };
 }
@@ -26,8 +33,8 @@ export function get<R, T extends Tags<R>>(tag: T) {
 /**
  * @tsplus pipeable fncts.Environment getMaybe
  */
-export function getMaybe<S>(tag: Tag<S>) {
-  return <R extends Has<S>>(self: Environment<R>): Maybe<S> => {
+export function getMaybe<S, I>(tag: Tag<S, I>) {
+  return <R>(self: Environment<R>): Maybe<S> => {
     return self.cache.get(tag) as Maybe<S>;
   };
 }
@@ -52,7 +59,7 @@ export function union<R1>(that: Environment<R1>) {
 /**
  * @tsplus pipeable fncts.Environment unsafeGet
  */
-export function unsafeGet<S>(tag: Tag<S>) {
+export function unsafeGet<S, I>(tag: Tag<S, I>) {
   return <R>(self: Environment<R>): S => {
     return self.cache.get(tag).match(
       () => {
@@ -65,7 +72,7 @@ export function unsafeGet<S>(tag: Tag<S>) {
             service = curService as S;
           }
         }
-        if (service === null) throw new Error("Defect in Environment: Could not find tag in map");
+        if (service === null) throw new ServiceNotFoundError(tag);
         else {
           self.cache = self.cache.set(tag, service);
           return service;

package/_src/data/Environment/definition.ts

@@ -15,7 +15,10 @@ export class Environment<R> implements Hashable, Equatable {
   declare [EnvironmentVariance]: {
     _R: (_: never) => R;
   };
-  constructor(readonly map: HashMap<Tag<any>, unknown>, public cache: HashMap<Tag<any>, unknown> = HashMap.empty()) {}
+  constructor(
+    readonly map: HashMap<Tag<any>, unknown>,
+    public cache: HashMap<Tag<any>, unknown> = HashMap.empty(),
+  ) {}
 
   get [Symbol.hash](): number {
     return Hashable.unknown(this.cache);

package/_src/data/Environment.ts

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

package/_src/data/EnvironmentPatch.ts

@@ -26,14 +26,20 @@ export abstract class EnvironmentPatch<In, Out> {
 
 export class AddService<Env, Service> extends EnvironmentPatch<Env, Env & Has<Service>> {
   readonly _tag = EnvironmentPatchTag.AddService;
-  constructor(readonly service: Service, readonly tag: Tag<Service>) {
+  constructor(
+    readonly service: Service,
+    readonly tag: Tag<Service>,
+  ) {
     super();
   }
 }
 
 export class Combine<In, Out, Out2> extends EnvironmentPatch<In, Out2> {
   readonly _tag = EnvironmentPatchTag.Combine;
-  constructor(readonly first: EnvironmentPatch<In, Out>, readonly second: EnvironmentPatch<Out, Out2>) {
+  constructor(
+    readonly first: EnvironmentPatch<In, Out>,
+    readonly second: EnvironmentPatch<Out, Out2>,
+  ) {
     super();
   }
 }
@@ -51,7 +57,10 @@ export class RemoveService<Env, Service> extends EnvironmentPatch<Env & Has<Serv
 
 export class UpdateService<Env, Service> extends EnvironmentPatch<Env & Has<Service>, Env & Has<Service>> {
   readonly _tag = EnvironmentPatchTag.UpdateService;
-  constructor(readonly update: (_: Service) => Service, readonly tag: Tag<Service>) {
+  constructor(
+    readonly update: (_: Service) => Service,
+    readonly tag: Tag<Service>,
+  ) {
     super();
   }
 }

package/_src/data/Eq/derivations.ts

@@ -43,6 +43,7 @@ export function deriveStruct<A extends Record<string, any>>(
   return Eq({
     equals: (y) => (x) => {
       for (const field in requiredFields) {
+        // @ts-expect-error
         if (!(requiredFields[field] as Eq<any>).equals(y[field])(x[field])) {
           return false;
         }

package/_src/data/Equatable.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Equatable/*.ts }
-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";
 // codegen:end

package/_src/data/Exit/api.ts

@@ -223,9 +223,9 @@ export 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
  */
-export function valueOrThrow<E, A>(self: Exit<E, A>): A {
+export function getOrThrow<E, A>(self: Exit<E, A>): A {
   if (self.isFailure()) {
     throw new IOError(self.cause);
   }

package/_src/data/Exit/definition.ts

@@ -35,13 +35,17 @@ const _successHash = Hashable.string("fncts.Exit.Success");
  */
 export class Failure<E> {
   readonly [ExitTypeId]: ExitTypeId = ExitTypeId;
+  readonly _ioOpCode                = null;
   declare [ExitVariance]: {
     readonly _E: (_: never) => E;
     readonly _A: (_: never) => never;
   };
   readonly [IOTypeId]: IOTypeId = IOTypeId;
   readonly _tag                 = ExitTag.Failure;
-  constructor(readonly cause: Cause<E>, readonly trace?: string) {}
+  constructor(
+    readonly cause: Cause<E>,
+    readonly trace?: string,
+  ) {}
 
   get [Symbol.hash](): number {
     return Hashable.combine(_failureHash, Hashable.unknown(this.cause));
@@ -57,13 +61,17 @@ export class Failure<E> {
  */
 export class Success<A> implements P.Hashable, P.Equatable {
   readonly [ExitTypeId]: ExitTypeId = ExitTypeId;
+  readonly _ioOpCode                = null;
   declare [ExitVariance]: {
     readonly _E: (_: never) => never;
     readonly _A: (_: never) => A;
   };
   readonly [IOTypeId]: IOTypeId = IOTypeId;
   readonly _tag                 = ExitTag.Success;
-  constructor(readonly value: A, readonly trace?: string) {}
+  constructor(
+    readonly value: A,
+    readonly trace?: string,
+  ) {}
 
   get [Symbol.hash](): number {
     return Hashable.combine(_successHash, Hashable.unknown(this.value));

package/_src/data/Exit.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Exit/*.ts }
-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";
 // codegen:end

package/_src/data/FiberId/definition.ts

@@ -19,7 +19,11 @@ const _hashRuntime = Hashable.string("fncts.FiberId.Runtime");
 export class Runtime implements Hashable, Equatable {
   readonly [FiberIdTypeId]: FiberIdTypeId = FiberIdTypeId;
   readonly _tag = "Runtime";
-  constructor(readonly id: number, readonly startTime: number, readonly location?: string) {}
+  constructor(
+    readonly id: number,
+    readonly startTime: number,
+    readonly location?: string,
+  ) {}
   get [Symbol.hash]() {
     return Hashable.combine(Hashable.combine(_hashRuntime, Hashable.number(this.id)), Hashable.unknown(this.location));
   }

package/_src/data/FiberId.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: FiberId/*.ts }
-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";
 // codegen:end

package/_src/data/Guard/api.ts

@@ -161,6 +161,7 @@ export function deriveStruct<A extends Record<string, any>>(
       return false;
     }
     for (const key in requiredFields) {
+      // @ts-expect-error
       if (!(key in u) || !(requiredFields[key] as Guard<any>).is(u[key])) {
         return false;
       }
@@ -295,6 +296,7 @@ export function deriveRecord<A extends Record<string, any>>(
       return false;
     }
     for (const k of Object.keys(record)) {
+      // @ts-expect-error
       if (requiredKeysSet.has(k) && !value.is(record[k])) {
         return false;
       }
@@ -315,6 +317,7 @@ export function deriveDictionary<A extends Record<string, any>>(
       return false;
     }
     for (const k of Object.keys(u)) {
+      // @ts-expect-error
       if (!value.is(u[k])) {
         return false;
       }

package/_src/data/Guard.ts

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