@fncts/base 0.0.31 → 0.0.33

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

@@ -97,20 +97,20 @@ export function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>
  * @tsplus getter fncts.Either getLeft
  */
 export function getLeft<E, A>(self: Either<E, A>): Maybe<E> {
-  return self.match(
-    (e) => Just(e),
-    (_a) => Nothing(),
-  );
+  return self.match({
+    Left: (e) => Just(e),
+    Right: (_a) => Nothing(),
+  });
 }
 
 /**
  * @tsplus getter fncts.Either getRight
  */
 export function getRight<E, A>(self: Either<E, A>): Maybe<A> {
-  return self.match(
-    (_e) => Nothing(),
-    (a) => Just(a),
-  );
+  return self.match({
+    Left: (_e) => Nothing(),
+    Right: (a) => Just(a),
+  });
 }
 
 /**
@@ -118,7 +118,7 @@ export function getRight<E, A>(self: Either<E, A>): Maybe<A> {
  */
 export function getOrElse<E, B>(orElse: (e: E) => B) {
   return <A>(self: Either<E, A>): A | B => {
-    return self.match(orElse, identity);
+    return self.match({ Left: orElse, Right: identity });
   };
 }
 
@@ -172,7 +172,7 @@ export function mapLeft<E1, E2>(f: (e: E1) => E2) {
  * @tsplus getter fncts.Either value
  */
 export function merge<E, A>(self: Either<E, A>): E | A {
-  return self.match(identity, identity);
+  return self.match({ Left: identity, Right: identity });
 }
 
 /**
@@ -201,10 +201,10 @@ export function _traverse<E, A>(self: Either<E, A>) {
     <K, Q, W, X, I, S, R, E1, B>(
       f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>,
     ): HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, Either<E, B>> =>
-      self.match(
-        (e) => G.pure(Left(e)),
-        (a) => f(a).pipe(G.map((b) => Right(b))),
-      );
+      self.match({
+        Left: (e) => G.pure(Left(e)),
+        Right: (a) => f(a).pipe(G.map((b) => Right(b))),
+      });
 }
 
 export const traverse_: P.Traversable<EitherF>["traverse"] = (A) => (f) => (self) => self.traverse(A)(f);
@@ -288,13 +288,14 @@ export function partition<E, A>(p: Predicate<A>, /** @tsplus auto */ M: P.Monoid
  * @tsplus getter fncts.Either toMaybe
  */
 export function toMaybe<E, A>(self: Either<E, A>): Maybe<A> {
-  return self.match(
-    () => Nothing(),
-    (a) => Just(a),
-  );
+  return self.match({
+    Left: () => Nothing(),
+    Right: (a) => Just(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

@@ -44,7 +44,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 +68,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/destructors.ts

@@ -3,14 +3,14 @@ import { EitherTag } from "./definition.js";
 /**
  * @tsplus pipeable fncts.Either match
  */
-export function match<E, A, B, C>(left: (e: E) => B, right: (a: A) => C) {
+export function match<E, A, B, C>(cases: { Left: (e: E) => B; Right: (a: A) => C }) {
   return (self: Either<E, A>): B | C => {
     self.concrete();
     switch (self._tag) {
       case EitherTag.Left:
-        return left(self.left);
+        return cases.Left(self.left);
       case EitherTag.Right:
-        return right(self.right);
+        return cases.Right(self.right);
     }
   };
 }

package/_src/data/Either/instances.ts

@@ -20,18 +20,18 @@ export function getEq<E, A>(EE: P.Eq<E>, EA: P.Eq<A>): P.Eq<Either<E, A>> {
   return P.Eq({
     equals: (y) => (x) =>
       x === y ||
-      x.match(
-        (e1) =>
-          y.match(
-            (e2) => EE.equals(e2)(e1),
-            () => false,
-          ),
-        (a1) =>
-          y.match(
-            () => false,
-            (a2) => EA.equals(a2)(a1),
-          ),
-      ),
+      x.match({
+        Left: (e1) =>
+          y.match({
+            Left: (e2) => EE.equals(e2)(e1),
+            Right: () => false,
+          }),
+        Right: (a1) =>
+          y.match({
+            Left: () => false,
+            Right: (a2) => EA.equals(a2)(a1),
+          }),
+      }),
   });
 }
 

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/EitherT/api.ts

@@ -122,10 +122,10 @@ export function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>) {
   >) =>
     F.flatMap(
       (either) =>
-        either.match(
-          (e) => F.pure(Either.left(e)),
-          (a) => f(a),
-        ) as HKT.Kind<
+        either.match({
+          Left: (e) => F.pure(Either.left(e)),
+          Right: (a) => f(a),
+        }) as HKT.Kind<
           F,
           FC,
           HKT.Intro<F, "K", K, K1>,
@@ -225,9 +225,9 @@ export function orElse<F>(F: P.Monad<HKT.F1<F>>) {
     that: Lazy<HKT.FK1<F, Either<E1, B>>>,
   ): ((self: HKT.FK1<F, Either<E, A>>) => HKT.FK1<F, Either<E | E1, A | B>>) =>
     F.flatMap((either) =>
-      either.match(
-        () => that(),
-        () => F.pure(either),
-      ),
+      either.match({
+        Left: () => that(),
+        Right: () => F.pure(either),
+      }),
     );
 }

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/constructors.ts

@@ -18,7 +18,7 @@ export function fail<E = never, A = never>(e: E, __tsplusTrace?: string): Exit<E
  * @tsplus static fncts.ExitOps fromEither
  */
 export function fromEither<E = never, A = never>(e: Either<E, A>): Exit<E, A> {
-  return e.match(fail, succeed);
+  return e.match({ Left: fail, Right: succeed });
 }
 
 /**

package/_src/data/Exit/definition.ts

@@ -41,7 +41,10 @@ export class Failure<E> {
   };
   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));
@@ -63,7 +66,10 @@ export class Success<A> implements P.Hashable, P.Equatable {
   };
   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/Global.ts

@@ -0,0 +1,17 @@
+const globalStoreId = Symbol.for("fncts.GlobalStore");
+
+if (!(globalStoreId in globalThis)) {
+  (globalThis as any)[globalStoreId] = new Map();
+}
+
+const globalStore = (globalThis as any)[globalStoreId] as Map<unknown, any>;
+
+/**
+ * @since 1.0.0
+ */
+export const globalValue = <A>(id: unknown, compute: () => A): A => {
+  if (!globalStore.has(id)) {
+    globalStore.set(id, compute());
+  }
+  return globalStore.get(id)!;
+};