@typed/fx 0.0.1

package/esm/Finalizer/Finalizer.d.ts

@@ -0,0 +1,39 @@
+import { Branded } from 'hkt-ts/Branded';
+import { NonNegativeInteger } from 'hkt-ts/number';
+import { Exit } from '@/Exit/Exit.js';
+import { Fx } from '@/Fx/Fx.js';
+export interface Finalizer<R = never, E = never> {
+    (exit: Exit<any, any>): Fx<R, E, any>;
+}
+export declare type FinalizerKey = Branded<{
+    readonly FinalizerKey: FinalizerKey;
+}, symbol>;
+export declare const FinalizerKey: {
+    <E extends symbol>(e: E): Branded<{
+        readonly FinalizerKey: FinalizerKey;
+    }, E>;
+    makeEq(A: import("hkt-ts/Typeclass/Eq").Eq<symbol>): import("hkt-ts/Typeclass/Eq").Eq<FinalizerKey>;
+    makeOrd(A: import("hkt-ts/Typeclass/Ord").Ord<symbol>): import("hkt-ts/Typeclass/Ord").Ord<FinalizerKey>;
+    makeBounded(A: import("hkt-ts/Typeclass/Bounded").Bounded<symbol>): import("hkt-ts/Typeclass/Bounded").Bounded<FinalizerKey>;
+    makeIdentity(A: import("hkt-ts/Typeclass/Identity").Identity<symbol>): import("hkt-ts/Typeclass/Identity").Identity<FinalizerKey>;
+    makeConcat(A: import("hkt-ts/Typeclass/Concat").Concat<symbol>): import("hkt-ts/Typeclass/Concat").Concat<FinalizerKey>;
+    makeAssociative(A: import("hkt-ts/Typeclass/Associative").Associative<symbol>): import("hkt-ts/Typeclass/Associative").Associative<FinalizerKey>;
+    makeCommutative(A: import("hkt-ts/Typeclass/Commutative").Commutative<symbol>): import("hkt-ts/Typeclass/Commutative").Commutative<FinalizerKey>;
+    makeInverse(A: import("hkt-ts/Typeclass/Inverse").Inverse<symbol>): import("hkt-ts/Typeclass/Inverse").Inverse<FinalizerKey>;
+};
+export declare type FinalizationStrategy = SequentialStrategy | ConcurrentStrategy | ConcurrentNStrategy;
+export interface SequentialStrategy {
+    readonly strategy: 'Sequential';
+}
+export declare const SequentialStrategy: SequentialStrategy;
+export interface ConcurrentStrategy {
+    readonly strategy: 'Concurrent';
+}
+export declare const ConcurrentStrategy: ConcurrentStrategy;
+export interface ConcurrentNStrategy {
+    readonly strategy: 'ConcurrentN';
+    readonly concurrency: NonNegativeInteger;
+}
+export declare const ConcurrentNStrategy: (concurency: NonNegativeInteger) => ConcurrentNStrategy;
+export declare function finalizationStrategyToConcurrency(strategy: FinalizationStrategy): NonNegativeInteger;
+//# sourceMappingURL=Finalizer.d.ts.map

package/esm/Finalizer/Finalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Finalizer.d.ts","sourceRoot":"","sources":["../../src/Finalizer/Finalizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAElD,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AACrC,OAAO,EAAE,EAAE,EAAE,MAAM,YAAY,CAAA;AAE/B,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK;IAC7C,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAA;CACtC;AAED,oBAAY,YAAY,GAAG,OAAO,CAAC;IAAE,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAA;CAAE,EAAE,MAAM,CAAC,CAAA;AACnF,eAAO,MAAM,YAAY;;+BADmC,YAAY;;;;;;;;;;CACrB,CAAA;AAEnD,oBAAY,oBAAoB,GAAG,kBAAkB,GAAG,kBAAkB,GAAG,mBAAmB,CAAA;AAEhG,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAA;CAChC;AACD,eAAO,MAAM,kBAAkB,EAAE,kBAA+C,CAAA;AAEhF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAA;CAChC;AACD,eAAO,MAAM,kBAAkB,EAAE,kBAA+C,CAAA;AAEhF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAA;IAChC,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAA;CACzC;AAED,eAAO,MAAM,mBAAmB,eAAgB,kBAAkB,KAAG,mBAGnE,CAAA;AAEF,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,oBAAoB,GAC7B,kBAAkB,CAUpB"}

package/esm/Finalizer/Finalizer.js

@@ -0,0 +1,19 @@
+import { Branded } from 'hkt-ts/Branded';
+import { NonNegativeInteger } from 'hkt-ts/number';
+export const FinalizerKey = Branded();
+export const SequentialStrategy = { strategy: 'Sequential' };
+export const ConcurrentStrategy = { strategy: 'Concurrent' };
+export const ConcurrentNStrategy = (concurency) => ({
+    strategy: 'ConcurrentN',
+    concurrency: concurency,
+});
+export function finalizationStrategyToConcurrency(strategy) {
+    if (strategy.strategy === 'Sequential') {
+        return NonNegativeInteger(1);
+    }
+    if (strategy.strategy === 'Concurrent') {
+        return NonNegativeInteger(Number.MAX_SAFE_INTEGER);
+    }
+    return strategy.concurrency;
+}
+//# sourceMappingURL=Finalizer.js.map

package/esm/Finalizer/Finalizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Finalizer.js","sourceRoot":"","sources":["../../src/Finalizer/Finalizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAUlD,MAAM,CAAC,MAAM,YAAY,GAAG,OAAO,EAAgB,CAAA;AAOnD,MAAM,CAAC,MAAM,kBAAkB,GAAuB,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAA;AAKhF,MAAM,CAAC,MAAM,kBAAkB,GAAuB,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAA;AAOhF,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,UAA8B,EAAuB,EAAE,CAAC,CAAC;IAC3F,QAAQ,EAAE,aAAa;IACvB,WAAW,EAAE,UAAU;CACxB,CAAC,CAAA;AAEF,MAAM,UAAU,iCAAiC,CAC/C,QAA8B;IAE9B,IAAI,QAAQ,CAAC,QAAQ,KAAK,YAAY,EAAE;QACtC,OAAO,kBAAkB,CAAC,CAAC,CAAC,CAAA;KAC7B;IAED,IAAI,QAAQ,CAAC,QAAQ,KAAK,YAAY,EAAE;QACtC,OAAO,kBAAkB,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAA;KACnD;IAED,OAAO,QAAQ,CAAC,WAAW,CAAA;AAC7B,CAAC"}

package/esm/Finalizer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Finalizer.js';
+//# sourceMappingURL=index.d.ts.map

package/esm/Finalizer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Finalizer/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA"}

package/esm/Finalizer/index.js

@@ -0,0 +1,2 @@
+export * from './Finalizer.js';
+//# sourceMappingURL=index.js.map

package/esm/Finalizer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/Finalizer/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA"}

package/esm/Future/Future.d.ts

@@ -0,0 +1,23 @@
+import { Atomic } from '@/Atomic/Atomic.js';
+import { Disposable } from '@/Disposable/Disposable.js';
+import type { Fx } from '@/Fx/Fx.js';
+export interface Future<R, E, A> {
+    readonly state: Atomic<FutureState<R, E, A>>;
+}
+export declare type AnyFuture = Future<any, any, any> | Future<never, never, any> | Future<never, any, any> | Future<any, never, any>;
+export declare type FutureState<R, E, A> = Pending<R, E, A> | Resolved<R, E, A>;
+export interface Pending<R, E, A> {
+    readonly tag: 'Pending';
+    readonly observers: ReadonlySet<Observer<R, E, A>>;
+}
+export declare function Pending<R, E, A>(): Future<R, E, A>;
+export declare function addObserver<R, E, A>(future: Future<R, E, A>, observer: Observer<R, E, A>): Disposable;
+export interface Observer<R, E, A> {
+    (fx: Fx<R, E, A>): void;
+}
+export interface Resolved<R, E, A> {
+    readonly tag: 'Resolved';
+    readonly fx: Fx<R, E, A>;
+}
+export declare function Resolved<R, E, A>(fx: Fx<R, E, A>): Future<R, E, A>;
+//# sourceMappingURL=Future.d.ts.map

package/esm/Future/Future.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Future.d.ts","sourceRoot":"","sources":["../../src/Future/Future.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,YAAY,CAAA;AAEpC,MAAM,WAAW,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;CAC7C;AAED,oBAAY,SAAS,GACjB,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,GACrB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,GACzB,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,GACvB,MAAM,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,CAAA;AAE3B,oBAAY,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;AAEvE,MAAM,WAAW,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;IAC9B,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAA;IACvB,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;CACnD;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAIlD;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACjC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACvB,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAC1B,UAAU,CAaZ;AAeD,MAAM,WAAW,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;IAC/B,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAA;CACxB;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;IAC/B,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAA;IACxB,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CACzB;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAIlE"}

package/esm/Future/Future.js

@@ -0,0 +1,36 @@
+import { Atomic } from '@/Atomic/Atomic.js';
+import { Disposable } from '@/Disposable/Disposable.js';
+export function Pending() {
+    return {
+        state: Atomic({ tag: 'Pending', observers: new Set() }),
+    };
+}
+export function addObserver(future, observer) {
+    return future.state.modify((state) => {
+        if (state.tag === 'Resolved') {
+            return [Disposable.None, state];
+        }
+        const updated = {
+            ...state,
+            observers: new Set([...state.observers, observer]),
+        };
+        return [Disposable(() => removeObserver(future, observer)), updated];
+    });
+}
+function removeObserver(future, observer) {
+    return future.state.modify((state) => {
+        if (state.tag === 'Resolved') {
+            return [undefined, state];
+        }
+        return [
+            undefined,
+            { ...state, observer: new Set([...state.observers].filter((x) => x !== observer)) },
+        ];
+    });
+}
+export function Resolved(fx) {
+    return {
+        state: Atomic({ tag: 'Resolved', fx }),
+    };
+}
+//# sourceMappingURL=Future.js.map

package/esm/Future/Future.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Future.js","sourceRoot":"","sources":["../../src/Future/Future.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAoBvD,MAAM,UAAU,OAAO;IACrB,OAAO;QACL,KAAK,EAAE,MAAM,CAAuB,EAAE,GAAG,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,GAAG,EAAE,EAAE,CAAC;KAC9E,CAAA;AACH,CAAC;AAED,MAAM,UAAU,WAAW,CACzB,MAAuB,EACvB,QAA2B;IAE3B,OAAO,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK,EAA+C,EAAE;QAChF,IAAI,KAAK,CAAC,GAAG,KAAK,UAAU,EAAE;YAC5B,OAAO,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;SAChC;QAED,MAAM,OAAO,GAAyB;YACpC,GAAG,KAAK;YACR,SAAS,EAAE,IAAI,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;SACnD,CAAA;QAED,OAAO,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,CAAA;IACtE,CAAC,CAAC,CAAA;AACJ,CAAC;AAED,SAAS,cAAc,CAAU,MAAuB,EAAE,QAA2B;IACnF,OAAO,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE;QACnC,IAAI,KAAK,CAAC,GAAG,KAAK,UAAU,EAAE;YAC5B,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;SAC1B;QAED,OAAO;YACL,SAAS;YACT,EAAE,GAAG,KAAK,EAAE,QAAQ,EAAE,IAAI,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,EAAE;SACpF,CAAA;IACH,CAAC,CAAC,CAAA;AACJ,CAAC;AAWD,MAAM,UAAU,QAAQ,CAAU,EAAe;IAC/C,OAAO;QACL,KAAK,EAAE,MAAM,CAAuB,EAAE,GAAG,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC;KAC7D,CAAA;AACH,CAAC"}

package/esm/Future/MutableFutureQueue.d.ts

@@ -0,0 +1,16 @@
+import { Future } from './Future.js';
+import { Fx } from '@/Fx/Fx.js';
+/**
+ * A Future Queue is a synchronously-used, mutable, Queue for managing Futures that need to be handled in FIFO ordering.
+ */
+export interface MutableFutureQueue<R, E, A> {
+    readonly size: () => number;
+    readonly next: (value: Fx<R, E, A>) => boolean;
+    readonly all: (value: Fx<R, E, A>) => boolean;
+    readonly waitFor: (amount: number) => ReadonlyArray<Future<R, E, A>>;
+}
+/**
+ * Constructs a FutureQueue
+ */
+export declare function MutableFutureQueue<R, E, A>(): MutableFutureQueue<R, E, A>;
+//# sourceMappingURL=MutableFutureQueue.d.ts.map

package/esm/Future/MutableFutureQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MutableFutureQueue.d.ts","sourceRoot":"","sources":["../../src/Future/MutableFutureQueue.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAW,MAAM,aAAa,CAAA;AAG7C,OAAO,EAAE,EAAE,EAAE,MAAM,YAAY,CAAA;AAE/B;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,MAAM,CAAA;IAC3B,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,OAAO,CAAA;IAC9C,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,OAAO,CAAA;IAC7C,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;CACrE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAqCzE"}

package/esm/Future/MutableFutureQueue.js

@@ -0,0 +1,36 @@
+import { pipe } from 'hkt-ts/function';
+import { Pending } from './Future.js';
+import { complete } from './complete.js';
+/**
+ * Constructs a FutureQueue
+ */
+export function MutableFutureQueue() {
+    const queue = [];
+    function next(fx) {
+        if (queue.length > 0) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            return pipe(fx, complete(queue.shift()));
+        }
+        return false;
+    }
+    function waitFor(amount) {
+        const pendingFutures = Array.from({ length: amount }, () => Pending());
+        queue.push(...pendingFutures);
+        return pendingFutures;
+    }
+    function all(Fx) {
+        if (queue.length > 0) {
+            queue.forEach((f) => complete(f)(Fx));
+            queue.splice(0, queue.length); // Clear the Queue
+            return true;
+        }
+        return false;
+    }
+    return {
+        size: () => queue.length,
+        next,
+        waitFor,
+        all,
+    };
+}
+//# sourceMappingURL=MutableFutureQueue.js.map

package/esm/Future/MutableFutureQueue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MutableFutureQueue.js","sourceRoot":"","sources":["../../src/Future/MutableFutureQueue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAEtC,OAAO,EAAU,OAAO,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAcxC;;GAEG;AACH,MAAM,UAAU,kBAAkB;IAChC,MAAM,KAAK,GAA2B,EAAE,CAAA;IAExC,SAAS,IAAI,CAAC,EAAe;QAC3B,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;YACpB,oEAAoE;YACpE,OAAO,IAAI,CAAC,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAG,CAAC,CAAC,CAAA;SAC1C;QAED,OAAO,KAAK,CAAA;IACd,CAAC;IAED,SAAS,OAAO,CAAC,MAAc;QAC7B,MAAM,cAAc,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,OAAO,EAAW,CAAC,CAAA;QAE/E,KAAK,CAAC,IAAI,CAAC,GAAG,cAAc,CAAC,CAAA;QAE7B,OAAO,cAAc,CAAA;IACvB,CAAC;IAED,SAAS,GAAG,CAAC,EAAe;QAC1B,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;YACpB,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;YACrC,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA,CAAC,kBAAkB;YAEhD,OAAO,IAAI,CAAA;SACZ;QAED,OAAO,KAAK,CAAA;IACd,CAAC;IAED,OAAO;QACL,IAAI,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,MAAM;QACxB,IAAI;QACJ,OAAO;QACP,GAAG;KACK,CAAA;AACZ,CAAC"}

package/esm/Future/complete.d.ts

@@ -0,0 +1,4 @@
+import type { Future } from './Future.js';
+import type { Fx } from '@/Fx/Fx.js';
+export declare function complete<R, E, A>(future: Future<R, E, A>): (fx: Fx<R, E, A>) => boolean;
+//# sourceMappingURL=complete.d.ts.map

package/esm/Future/complete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complete.d.ts","sourceRoot":"","sources":["../../src/Future/complete.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEzC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,YAAY,CAAA;AAEpC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,QAC3C,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,aAUxB"}

package/esm/Future/complete.js

@@ -0,0 +1,10 @@
+export function complete(future) {
+    return (fx) => future.state.modify((s) => {
+        if (s.tag === 'Resolved') {
+            return [false, s];
+        }
+        s.observers.forEach((o) => o(fx));
+        return [true, { tag: 'Resolved', fx }];
+    });
+}
+//# sourceMappingURL=complete.js.map

package/esm/Future/complete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"complete.js","sourceRoot":"","sources":["../../src/Future/complete.ts"],"names":[],"mappings":"AAIA,MAAM,UAAU,QAAQ,CAAU,MAAuB;IACvD,OAAO,CAAC,EAAe,EAAE,EAAE,CACzB,MAAM,CAAC,KAAK,CAAC,MAAM,CAAU,CAAC,CAAC,EAAE,EAAE;QACjC,IAAI,CAAC,CAAC,GAAG,KAAK,UAAU,EAAE;YACxB,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;SAClB;QAED,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;QAEjC,OAAO,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,CAAA;IACxC,CAAC,CAAC,CAAA;AACN,CAAC"}

package/esm/Future/index.d.ts

@@ -0,0 +1,4 @@
+export * from './complete.js';
+export * from './Future.js';
+export * from './wait.js';
+//# sourceMappingURL=index.d.ts.map

package/esm/Future/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Future/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,WAAW,CAAA"}

package/esm/Future/index.js

@@ -0,0 +1,4 @@
+export * from './complete.js';
+export * from './Future.js';
+export * from './wait.js';
+//# sourceMappingURL=index.js.map

package/esm/Future/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/Future/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,WAAW,CAAA"}

package/esm/Future/wait.d.ts

@@ -0,0 +1,4 @@
+import type { Future } from './Future.js';
+import type { Fx } from '@/Fx/Fx.js';
+export declare function wait<R, E, A>(future: Future<R, E, A>): Fx<R, E, A>;
+//# sourceMappingURL=wait.d.ts.map

package/esm/Future/wait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait.d.ts","sourceRoot":"","sources":["../../src/Future/wait.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEzC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,YAAY,CAAA;AAGpC,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAElE"}

package/esm/Future/wait.js

@@ -0,0 +1,5 @@
+import { Wait } from '@/Fx/Instruction.js';
+export function wait(future) {
+    return Wait.make(future, "Wait.make" + " node_modules/@typed/fx/src/Future/wait.ts:7:19");
+}
+//# sourceMappingURL=wait.js.map

package/esm/Future/wait.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait.js","sourceRoot":"","sources":["../../src/Future/wait.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAA;AAE1C,MAAM,UAAU,IAAI,CAAU,MAAuB;IACnD,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,kEAAC,CAAA;AAC1B,CAAC"}

package/esm/Fx/Fx.d.ts

@@ -0,0 +1,136 @@
+import { HKT3, Lazy, Params, Variance } from 'hkt-ts';
+import * as Either from 'hkt-ts/Either';
+import { Maybe } from 'hkt-ts/Maybe';
+import { ReadonlyRecord } from 'hkt-ts/Record';
+import * as AB from 'hkt-ts/Typeclass/AssociativeBoth';
+import * as AE from 'hkt-ts/Typeclass/AssociativeEither';
+import * as AF from 'hkt-ts/Typeclass/AssociativeFlatten';
+import { Bottom3 } from 'hkt-ts/Typeclass/Bottom';
+import * as CB from 'hkt-ts/Typeclass/CommutativeBoth';
+import { CommutativeEither3 } from 'hkt-ts/Typeclass/CommutativeEither';
+import * as C from 'hkt-ts/Typeclass/Covariant';
+import * as IB from 'hkt-ts/Typeclass/IdentityBoth';
+import * as T from 'hkt-ts/Typeclass/Top';
+import { Unary } from 'hkt-ts/Unary';
+import { NonNegativeInteger } from 'hkt-ts/number';
+import { Instr, Instruction } from './Instruction.js';
+import * as Cause from '@/Cause/index.js';
+import type { Env } from '@/Env/Env.js';
+import { Exit } from '@/Exit/index.js';
+import type * as Fiber from '@/Fiber/Fiber.js';
+import type { FiberContext } from '@/FiberContext/FiberContext.js';
+import { FiberId } from '@/FiberId/FiberId.js';
+import type { FiberRef } from '@/FiberRef/FiberRef.js';
+import type * as Layer from '@/Layer/Layer.js';
+import type { Scope } from '@/Scope/Scope.js';
+import { Service } from '@/Service/Service.js';
+import { Trace } from '@/Trace/Trace.js';
+export interface Fx<out R, out E, out A> {
+    readonly instr: Instruction<R, E, A>;
+    readonly [Symbol.iterator]: () => Generator<Instruction<R, E, any>, A, any>;
+}
+export declare type ResourcesOf<T> = [T] extends [never] ? never : [T] extends [Instr<infer _R, infer _E, infer _A>] ? _R : [T] extends [Fx<infer _R, infer _E, infer _A>] ? _R : never;
+export declare type ErrorsOf<T> = [T] extends [never] ? never : [T] extends [Instr<infer _R, infer _E, infer _A>] ? _E : [T] extends [Fx<infer _R, infer _E, infer _A>] ? _E : never;
+export declare type OutputOf<T> = [T] extends [Fx<infer _R, infer _E, infer _A>] ? _A : never;
+export interface IO<E, A> extends Fx<never, E, A> {
+}
+export interface Of<A> extends IO<never, A> {
+}
+export interface RIO<R, A> extends Fx<R, never, A> {
+}
+export declare type AnyFx = Fx<any, any, any> | Fx<never, never, any> | Fx<never, any, any> | Fx<any, never, any>;
+export declare const now: <A>(a: A, __trace?: string) => Of<A>;
+export declare const success: <A>(a: A, __trace?: string) => Of<A>;
+export declare const unit: Of<void>;
+export declare const fromLazy: <A>(a: Lazy<A>, __trace?: string) => Of<A>;
+export declare const lazy: <T extends AnyFx>(a: Lazy<T>, __trace?: string) => T;
+export declare const flatMap: <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>, __trace?: string) => <R, E>(fx: Fx<R, E, A>) => Fx<R2 | R, E2 | E, B>;
+export declare const access: <R = never, R2 = never, E = never, A = any>(f: (r: Env<R>) => Fx<R2, E, A>, __trace?: string) => Fx<R | R2, E, A>;
+export declare const getEnv: <R>(__trace?: string) => RIO<R, Env<R>>;
+export declare const provide: <R>(env: Env<R>, __trace?: string) => <E, A>(fx: Fx<R, E, A>) => IO<E, A>;
+export declare const provideService: <S, I extends S>(s: Service<S>, impl: I, __trace?: string) => <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, S>, E, A>;
+export declare const provideLayer: <R2, E2, S>(layer: Layer.Layer<R2, E2, S>, __trace?: string) => <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R2, S> | Exclude<R, S>, E2 | E, A>;
+export declare const provideLayers: <Layers extends readonly Layer.AnyLayer[]>(...layers: Layers) => <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, Layer.OutputOf<Layers[number]>> | Exclude<Layer.ResourcesOf<Layers[number]>, Layer.OutputOf<Layers[number]>>, E | Layer.ErrorsOf<Layers[number]>, A>;
+export declare const ask: <S>(s: Service<S>, __trace?: string) => RIO<S, S>;
+export declare const asks: <S>(s: Service<S>, __trace?: string) => <R, E, A>(f: (s: S) => Fx<R, E, A>) => Fx<S | R, E, A>;
+export declare const asksEnv: <R, A>(f: (env: Env<R>) => A, __trace?: string) => Fx<R, never, A>;
+export declare const ensuring: <E, A, R2, E2, B>(ensure: (a: Exit<E, A>) => Fx<R2, E2, B>, __trace?: string) => <R>(fx: Fx<R, E, A>) => Fx<R2 | R, E | E2, A>;
+export declare const fromCause: <E>(cause: Cause.Cause<E>, __trace?: string) => IO<E, never>;
+export declare const fromExit: <E, A>(exit: Exit<E, A>, __trace?: string) => IO<E, A>;
+export declare const interrupted: (id: FiberId, __trace?: string) => IO<never, never>;
+export declare const map: <A, B>(f: Unary<A, B>, __trace?: string) => <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>;
+export declare const tap: <A, B>(f: Unary<A, B>, __trace?: string) => <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>;
+export declare const mapTo: <B>(b: B, __trace?: string) => <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, B>;
+export declare const matchCause: <E, R2, E2, B, A, R3, E3, C>(onLeft: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, onRight: (a: A) => Fx<R3, E3, C>, __trace?: string) => <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>;
+export declare const match: <E, R2, E2, B, A, R3, E3, C>(onLeft: (cause: E) => Fx<R2, E2, B>, onRight: (a: A) => Fx<R3, E3, C>, __trace?: string) => <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>;
+export declare const orElseCause: <E, R2, E2, B>(onLeft: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, __trace?: string) => <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>;
+export declare const orElse: <E, R2, E2, B>(onLeft: (cause: E) => Fx<R2, E2, B>, __trace?: string) => <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>;
+export declare const mapLeft: <E, E2>(f: (e: E) => E2) => <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>;
+export declare const attempt: <R, E, A>(fx: Fx<R, E, A>, __trace?: string) => Fx<R, never, Exit<E, A>>;
+export declare const bimap: <A, B, C, D>(f: (a: A) => B, g: (c: C) => D) => <R>(fx: Fx<R, A, C>) => Fx<R, B, D>;
+export declare const addTrace: (trace: Trace) => <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
+export declare const addCustomTrace: (trace?: string) => <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
+export declare const getTrace: Of<Trace>;
+export declare const withConcurrency: (level: NonNegativeInteger) => <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
+export declare const uninterruptable: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
+export declare const interruptable: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
+export declare const getFiberContext: Fx<never, never, FiberContext>;
+export declare const both: <R2, E2, B>(second: Fx<R2, E2, B>, __trace?: string) => <R, E, A>(first: Fx<R2, E, A>) => Fx<R2 | R, E2 | E, readonly [A, B]>;
+export declare const either: <R2, E2, B>(second: Fx<R2, E2, B>, __trace?: string) => <R, E, A>(first: Fx<R2, E, A>) => Fx<R2 | R, E2 | E, Either.Either<A, B>>;
+export declare const forkInContext: (context: FiberContext, __trace?: string) => <R, E, A>(fx: Fx<R, E, A>) => Fx<R, never, Fiber.Live<E, A>>;
+export declare const fork: <R, E, A>(fx: Fx<R, E, A>, __trace?: string) => Fx<R, never, Fiber.Live<E, A>>;
+export declare const forkIn: (scope: Scope, __trace?: string) => <R, E, A>(fx: Fx<R, E, A>) => Fx<R, never, Fiber.Live<E, A>>;
+export declare const getFiberRef: <R, E, A>(ref: FiberRef<R, E, A>, __trace?: string) => Fx<R, E, A>;
+export declare const modifyFiberRef: <A, B>(f: (a: A) => readonly [B, A], __trace?: string) => <R, E>(ref: FiberRef<R, E, A>) => Fx<R, E, B>;
+export declare const deleteFiberRef: <R, E, A>(ref: FiberRef<R, E, A>, __trace?: string) => Fx<R, E, Maybe<A>>;
+export declare const fiberRefLocally: <R2, E2, B>(ref: FiberRef<R2, E2, B>, value: B) => <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
+declare type AnyGenerator = Generator<any, any, any> | Generator<never, never, any> | Generator<never, any, any> | Generator<any, never, any>;
+declare type YieldOf<T> = [T] extends [Generator<infer _Y, infer _R, infer _N>] ? _Y : never;
+declare type ReturnOf<T> = [T] extends [Generator<infer _Y, infer _R, infer _N>] ? _R : never;
+export declare function Fx<G extends AnyGenerator>(f: () => G, __trace?: string): Fx<ResourcesOf<YieldOf<G>>, ErrorsOf<YieldOf<G>>, ReturnOf<G>>;
+export declare function async<R, E, A, R2 = never, E2 = never>(register: AsyncRegister<R, E, A, R2, E2>, __trace?: string): Fx<R | R2, E | E2, A>;
+export interface AsyncRegister<R, E, A, R2, E2> {
+    (cb: (fx: Fx<R, E, A>) => void): Either.Either<Fx<R2, E2, any>, Fx<R, E, A>>;
+}
+export declare const fromPromise: <A>(f: () => Promise<A>, __trace?: string) => Of<A>;
+export declare const yieldNow: Of<void>;
+export interface FxHKT extends HKT3 {
+    readonly type: Fx<this[Params.R], this[Params.E], this[Params.A]>;
+    readonly defaults?: {
+        [Params.R]: Variance.Covariant<never>;
+        [Params.E]: Variance.Covariant<never>;
+    };
+}
+export declare const Covariant: C.Covariant3<FxHKT>;
+export declare const Do: Of<{}>;
+export declare const bindTo: <N extends string>(name: N) => <R, E, A>(kind: Fx<R, E, A>) => Fx<R, E, { readonly [K in N]: A; }>;
+export declare const flap: <A>(a: A) => <R, E, B>(kind: Fx<R, E, (a: A) => B>) => Fx<R, E, B>;
+export declare const tupled: <R, E, A>(kind: Fx<R, E, A>) => Fx<R, E, readonly [A]>;
+export declare const Top: T.Top3REC<FxHKT, never, never>;
+export declare const top: typeof T.top;
+export declare const never: Fx<never, never, never>;
+export declare const Bottom: Bottom3<FxHKT>;
+export declare const bottom: Fx<unknown, unknown, never>;
+export declare const flatten: <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => Fx<R | R2, E | E2, A>;
+export declare const Flatten: AF.AssociativeFlatten3<FxHKT>;
+export declare const bind: <N extends string, A extends Readonly<Record<string, any>>, R, E, B>(name: Exclude<N, keyof A>, f: (a: A) => Fx<R, E, B>) => <R2, E2>(kind: Fx<R2, E2, A>) => Fx<R | R2, E | E2, { readonly [K in N | keyof A]: K extends N ? B : K extends keyof A ? A[K] : B; }>;
+declare const let_: <N extends string, A extends Readonly<Record<string, any>>, B>(name: Exclude<N, keyof A>, f: (a: A) => B) => <R, E>(kind: Fx<R, E, A>) => Fx<R, E, { readonly [K in N | keyof A]: K extends N ? B : K extends keyof A ? A[K] : B; }>;
+export { let_ as let };
+export declare const AssociativeBoth: AB.AssociativeBoth3<FxHKT>;
+export declare const zipLeftSeq: <R, E, B>(second: Fx<R, E, B>) => <A>(first: Fx<R, E, A>) => Fx<R, E, A>;
+export declare const zipRightSeq: <R, E, B>(second: Fx<R, E, B>) => <A>(first: Fx<R, E, A>) => Fx<R, E, B>;
+export declare const IdentityBoth: IB.IdentityBoth3<FxHKT>;
+export declare const CommutativeBoth: CB.CommutativeBoth3<FxHKT>;
+export declare const zipLeft: <R, E, B>(second: Fx<R, E, B>) => <A>(first: Fx<R, E, A>) => Fx<R, E, A>;
+export declare const zipRight: <R, E, B>(second: Fx<R, E, B>) => <A>(first: Fx<R, E, A>) => Fx<R, E, B>;
+export declare const IdentityBothPar: IB.IdentityBoth3<FxHKT>;
+export declare const zipAll: <FX extends readonly AnyFx[]>(fxs: readonly [...FX], __trace?: string) => Fx<ResourcesOf<FX[number]>, ErrorsOf<FX[number]>, { readonly [K in keyof FX]: OutputOf<FX[K]>; }>;
+export declare const struct: <FX extends ReadonlyRecord<string, AnyFx>>(fxs: FX, __trace?: string) => Fx<ResourcesOf<FX[string]>, ErrorsOf<FX[string]>, { readonly [K in keyof FX]: OutputOf<FX[K]>; }>;
+export declare const zipAllSeq: <FX extends readonly AnyFx[]>(fxs: readonly [...FX], __trace?: string) => Fx<ResourcesOf<FX[number]>, ErrorsOf<FX[number]>, { readonly [K in keyof FX]: OutputOf<FX[K]>; }>;
+export declare const structSeq: <FX extends ReadonlyRecord<string, AnyFx>>(fxs: FX, __trace?: string) => Fx<ResourcesOf<FX[string]>, ErrorsOf<FX[string]>, { readonly [K in keyof FX]: OutputOf<FX[K]>; }>;
+export declare const CommutativeEither: CommutativeEither3<FxHKT>;
+export declare const raceAll: <FX extends readonly AnyFx[]>(fxs: readonly [...FX], __trace?: string) => Fx<ResourcesOf<FX[number]>, ErrorsOf<FX[number]>, OutputOf<FX[number]>>;
+export declare const AssociativeEither: AE.AssociativeEither3<FxHKT>;
+export declare const eitherSeq: <R, E, B>(second: Fx<R, E, B>) => <A>(first: Fx<R, E, A>) => Fx<R, E, Either.Either<A, B>>;
+export declare const eventually: <R, E, A>(kind: Fx<R, E, A>) => Fx<R, E, A>;
+//# sourceMappingURL=Fx.d.ts.map

package/esm/Fx/Fx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fx.d.ts","sourceRoot":"","sources":["../../src/Fx/Fx.ts"],"names":[],"mappings":"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"}

package/esm/Fx/Fx.js

@@ -0,0 +1,173 @@
+import { Params, constant, flow, identity, pipe } from 'hkt-ts';
+import * as Either from 'hkt-ts/Either';
+import * as AB from 'hkt-ts/Typeclass/AssociativeBoth';
+import * as AE from 'hkt-ts/Typeclass/AssociativeEither';
+import * as AF from 'hkt-ts/Typeclass/AssociativeFlatten';
+import * as C from 'hkt-ts/Typeclass/Covariant';
+import { DeepEquals } from 'hkt-ts/Typeclass/Eq';
+import * as IB from 'hkt-ts/Typeclass/IdentityBoth';
+import * as T from 'hkt-ts/Typeclass/Top';
+import { Access, AddTrace, BothFx, DeleteFiberRef, EitherFx, FiberRefLocally, FlatMap, Fork, FromCause, FromLazy, GetFiberContext, GetFiberRef, GetTrace, LazyFx, MapFx, Match, ModifyFiberRef, Now, Provide, ProvideLayer, ProvideService, SetConcurrencyLevel, SetInterruptStatus, } from './Instruction.js';
+import { getCauseError } from '@/Cause/CauseError.js';
+import * as Cause from '@/Cause/index.js';
+import { settable } from '@/Disposable/Disposable.js';
+import { Pending } from '@/Future/Future.js';
+import { complete } from '@/Future/complete.js';
+import { wait } from '@/Future/wait.js';
+import { Trace } from '@/Trace/Trace.js';
+export const now = (a, __trace) => Now.make(a, __trace);
+export const success = now;
+export const unit = now(undefined);
+export const fromLazy = (a, __trace) => FromLazy.make(a, __trace);
+export const lazy = (a, __trace) => LazyFx.make(a, __trace);
+export const flatMap = (f, __trace) => (fx) => FlatMap.make(fx, f, __trace);
+export const access = (f, __trace) => Access.make(f, __trace);
+export const getEnv = (__trace) => access(now, __trace);
+export const provide = (env, __trace) => (fx) => Provide.make(fx, env, __trace);
+export const provideService = (s, impl, __trace) => (fx) => ProvideService.make(fx, s, impl, __trace);
+export const provideLayer = (layer, __trace) => (fx) => ProvideLayer.make(fx, layer, __trace);
+export const provideLayers = (...layers) => (fx) => layers.reduceRight((fx, l) => pipe(fx, provideLayer(l)), fx);
+export const ask = (s, __trace) => access((e) => e.get(s), __trace);
+export const asks = (s, __trace) => (f) => access((e) => pipe(e.get(s), flatMap(f)), __trace);
+export const asksEnv = (f, __trace) => access((e) => now(f(e)), __trace);
+export const ensuring = (ensure, __trace) => (fx) => pipe(fx, matchCause((cause) => pipe(ensure(Either.Left(cause)), matchCause((cause2) => fromCause(Cause.sequential(cause, cause2)), () => fromCause(cause))), (a) => pipe(ensure(Either.Right(a)), map(() => a)), __trace));
+export const fromCause = (cause, __trace) => FromCause.make(cause, __trace);
+export const fromExit = (exit, __trace) => (exit.tag === 'Left' ? fromCause(exit.left, __trace) : now(exit.right, __trace));
+export const interrupted = (id, __trace) => fromCause(Cause.interrupted(id), __trace);
+export const map = (f, __trace) => (fx) => MapFx.make(fx, f, __trace);
+export const tap = (f, __trace) => (fx) => MapFx.make(fx, (a) => {
+    f(a);
+    return a;
+}, __trace);
+export const mapTo = (b, __trace) => (fx) => MapFx.make(fx, constant(b), __trace);
+export const matchCause = (onLeft, onRight, __trace) => (fx) => Match.make(fx, onLeft, onRight, __trace);
+export const match = (onLeft, onRight, __trace) => (fx) => Match.make(fx, (cause) => cause.tag === 'Expected' ? onLeft(cause.error) : fromCause(cause), onRight, __trace);
+export const orElseCause = (onLeft, __trace) => (fx) => Match.make(fx, onLeft, now, __trace);
+export const orElse = (onLeft, __trace) => (fx) => Match.make(fx, (cause) => cause.tag === 'Expected' ? onLeft(cause.error) : fromCause(cause), now, __trace);
+export const mapLeft = (f) => orElseCause(flow(Cause.map(f), fromCause), "orElseCause" + " node_modules/@typed/fx/src/Fx/Fx.ts:252:63");
+export const attempt = (fx, __trace) => pipe(fx, matchCause(flow(Either.Left, now), flow(Either.Right, now), __trace));
+export const bimap = (f, g) => (fx) => pipe(fx, mapLeft(f), map(g));
+export const addTrace = (trace) => (fx) => AddTrace.make(fx, trace);
+export const addCustomTrace = (trace) => (fx) => trace ? addTrace(Trace.custom(trace))(fx) : fx;
+export const getTrace = GetTrace.make();
+export const withConcurrency = (level) => (fx) => SetConcurrencyLevel.make(fx, level, "SetConcurrencyLevel.make" + " node_modules/@typed/fx/src/Fx/Fx.ts:277:29");
+export const uninterruptable = (fx) => SetInterruptStatus.make(fx, false, "SetInterruptStatus.make" + " node_modules/@typed/fx/src/Fx/Fx.ts:279:85");
+export const interruptable = (fx) => SetInterruptStatus.make(fx, true, "SetInterruptStatus.make" + " node_modules/@typed/fx/src/Fx/Fx.ts:281:83");
+export const getFiberContext = GetFiberContext.make();
+export const both = (second, __trace) => (first) => BothFx.make(first, second, __trace);
+export const either = (second, __trace) => (first) => EitherFx.make(first, second, __trace);
+export const forkInContext = (context, __trace) => (fx) => Fork.make(fx, context, __trace);
+export const fork = (fx, __trace) => pipe(getFiberContext, flatMap((context) => forkInContext(context.fork())(fx), __trace));
+export const forkIn = (scope, __trace) => (fx) => pipe(getFiberContext, flatMap((context) => forkInContext(context.fork({ scope: scope.fork() }))(fx), __trace));
+export const getFiberRef = (ref, __trace) => GetFiberRef.make(ref, __trace);
+export const modifyFiberRef = (f, __trace) => (ref) => ModifyFiberRef.make(ref, f, __trace);
+export const deleteFiberRef = (ref, __trace) => DeleteFiberRef.make(ref, __trace);
+export const fiberRefLocally = (ref, value) => (fx) => FiberRefLocally.make(ref, value, fx, "FiberRefLocally.make" + " node_modules/@typed/fx/src/Fx/Fx.ts:330:25");
+export function Fx(f, __trace) {
+    return lazy(() => {
+        const gen = f();
+        return pipe(runFxGenerator(gen, gen.next()), 
+        // Allow running Gen.throw to attempt to use try/catch to handle any errors
+        orElseCause((cause) => (Cause.shouldRethrow(cause)
+            ? pipe(lazy(() => runFxGenerator(gen, gen.throw(getCauseError(cause)))), orElseCause((inner) => 
+            // Ensure the the most useful error is continued up the stack
+            DeepEquals.equals(getCauseError(inner), getCauseError(cause))
+                ? fromCause(cause)
+                : fromCause(Cause.sequential(cause, inner))))
+            : fromCause(cause))));
+    }, __trace);
+}
+function runFxGenerator(gen, result) {
+    if (result.done) {
+        return now(result.value, "now" + " node_modules/@typed/fx/src/Fx/Fx.ts:376:15");
+    }
+    return pipe(result.value, flatMap((a) => runFxGenerator(gen, gen.next(a))));
+}
+export function async(register, __trace) {
+    return addCustomTrace(__trace)(lazy(() => {
+        const future = Pending();
+        const either = register(complete(future));
+        return pipe(either, Either.match(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        (finalizer) => ensuring((_) => finalizer)(wait(future)), identity));
+    }));
+}
+export const fromPromise = (f, __trace) => async((cb) => {
+    const d = settable();
+    f().then((a) => {
+        if (!d.isDisposed()) {
+            cb(now(a));
+        }
+    }, (e) => {
+        if (!d.isDisposed()) {
+            cb(fromCause(Cause.unexpected(e)));
+        }
+    });
+    return Either.Left(fromLazy(() => d.dispose()));
+}, __trace);
+export const yieldNow = fromPromise(() => Promise.resolve(), 'yieldNow');
+export const Covariant = {
+    map,
+};
+export const Do = success({});
+export const bindTo = C.bindTo(Covariant);
+export const flap = C.flap(Covariant);
+export const tupled = C.tupled(Covariant);
+export const Top = {
+    top: now([], "now" + " node_modules/@typed/fx/src/Fx/Fx.ts:450:11"),
+};
+export const top = T.top;
+export const never = async(() => Either.Left(unit));
+export const Bottom = {
+    bottom: never,
+};
+export const bottom = Bottom.bottom;
+export const flatten = (fx) => pipe(fx, flatMap(identity));
+export const Flatten = {
+    flatten,
+};
+export const bind = AF.bind({ ...Flatten, ...Covariant });
+const let_ = (name, f) => (kind) => pipe(kind, map((a) => ({ ...a, [name]: f(a) })));
+export { let_ as let };
+export const AssociativeBoth = AF.makeAssociativeBoth({ ...Flatten, ...Covariant });
+export const zipLeftSeq = AB.zipLeft({ ...AssociativeBoth, ...Covariant });
+export const zipRightSeq = AB.zipRight({ ...AssociativeBoth, ...Covariant });
+export const IdentityBoth = {
+    ...AssociativeBoth,
+    ...Top,
+};
+export const CommutativeBoth = {
+    both,
+};
+export const zipLeft = AB.zipLeft({ ...CommutativeBoth, ...Covariant });
+export const zipRight = AB.zipRight({ ...CommutativeBoth, ...Covariant });
+export const IdentityBothPar = {
+    ...CommutativeBoth,
+    ...Top,
+};
+const zipAll_ = IB.tuple({ ...IdentityBothPar, ...Covariant });
+export const zipAll = (fxs, __trace) => addCustomTrace(__trace)(zipAll_(...fxs));
+export const struct = IB.struct({ ...IdentityBothPar, ...Covariant });
+export const zipAllSeq = IB.tuple({ ...IdentityBoth, ...Covariant });
+export const structSeq = IB.struct({ ...IdentityBoth, ...Covariant });
+export const CommutativeEither = {
+    either,
+};
+const raceAll_ = AE.tuple({ ...CommutativeEither, ...Covariant });
+export const raceAll = (fxs, __trace) => addCustomTrace(__trace)(raceAll_(...fxs));
+export const AssociativeEither = {
+    either: (s) => (f) => Fx(function* () {
+        const fe = yield* attempt(f);
+        if (Either.isRight(fe)) {
+            return Either.Left(fe.right);
+        }
+        const se = yield* attempt(s);
+        if (Either.isRight(se)) {
+            return se;
+        }
+        return yield* fromCause(Cause.sequential(fe.left, se.left));
+    }, "Fx" + " node_modules/@typed/fx/src/Fx/Fx.ts:611:9"),
+};
+export const eitherSeq = AssociativeEither.either;
+export const eventually = AE.eventually({ ...AssociativeEither, ...Covariant });
+//# sourceMappingURL=Fx.js.map