@fncts/io 0.0.1

package/STM/api.d.ts

@@ -0,0 +1,379 @@
+import { Lazy } from "@fncts/base/data/function";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Either } from "@fncts/base/data/Either";
+import { IO } from "@fncts/io/IO/definition";
+import { Environment } from "@fncts/base/data/Environment";
+import { Refinement } from "@fncts/base/data/Refinement";
+import { Predicate } from "@fncts/base/data/Predicate";
+import { STM } from "./definition.js";
+/**
+ * Maps the success value of this effect to the specified constant value.
+ * @tsplus fluent fncts.io.STM as
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function as_<R, E, A, B>(stm: STM<R, E, A>, b: Lazy<B>): STM<R, E, B>;
+/**
+ * Maps the success value of this effect to an optional value.
+ * @tsplus getter fncts.io.STM asJust
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function asJust<R, E, A>(stm: STM<R, E, A>): STM<R, E, Maybe<A>>;
+/**
+ * Maps the error value of this effect to an optional value.
+ * @tsplus getter fncts.io.STM asJustError
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function asJustError<R, E, A>(stm: STM<R, E, A>): STM<R, Maybe<E>, A>;
+/**
+ * Submerges the error case of an `Either` into the `STM`. The inverse
+ * operation of `STM.either`.
+ * @tsplus getter fncts.io.STM absolve
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function absolve<R, E, E1, A>(z: STM<R, E, Either<E1, A>>): STM<R, E | E1, A>;
+/**
+ * Retrieves the environment inside an stm.
+ * @tsplus static fncts.io.STMOps environment
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function environment<R>(): STM<R, never, R>;
+/**
+ * Accesses the environment of the transaction.
+ * @tsplus static fncts.io.STMOps environmentWith
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function environmentWith<R, A>(f: (r: R) => A): STM<R, never, A>;
+/**
+ * Accesses the environment of the transaction to perform a transaction.
+ * @tsplus static fncts.io.STMOps environmentWithSTM
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function environmentWithSTM<R0, R, E, A>(f: (r: R0) => STM<R, E, A>): STM<R & R0, E, A>;
+/**
+ * @tsplus static fncts.io.STMOps atomically
+ * @tsplus getter fncts.io.STM commit
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function atomically<R, E, A>(stm: STM<R, E, A>): IO<R, E, A>;
+/**
+ * Returns an `STM` effect whose failure and success channels have been mapped by
+ * the specified pair of functions, `f` and `g`.
+ */
+export declare function bimap_<R, E, A, E1, B>(stm: STM<R, E, A>, g: (e: E) => E1, f: (a: A) => B): STM<R, E1, B>;
+/**
+ * Recovers from specified error.
+ * @tsplus fluent fncts.io.STM catch
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function catch_<N extends keyof E, K extends E[N] & string, E, R, A, R1, E1, A1>(stm: STM<R, E, A>, tag: N, k: K, f: (e: Extract<E, {
+    [n in N]: K;
+}>) => STM<R1, E1, A1>): STM<R & R1, Exclude<E, {
+    [n in N]: K;
+}> | E1, A | A1>;
+/**
+ * Recovers from some or all of the error cases.
+ * @tsplus fluent fncts.io.STM catchJust
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function catchJust_<R, E, A, R1, E1, B>(stm: STM<R, E, A>, f: (e: E) => Maybe<STM<R1, E1, B>>): STM<R1 & R, E | E1, A | B>;
+/**
+ * Recovers from specified error.
+ * @tsplus fluent fncts.io.STM catchTag
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function catchTag_<K extends E["_tag"] & string, E extends {
+    _tag: string;
+}, R, A, R1, E1, A1>(stm: STM<R, E, A>, k: K, f: (e: Extract<E, {
+    _tag: K;
+}>) => STM<R1, E1, A1>): STM<R & R1, Exclude<E, {
+    _tag: K;
+}> | E1, A | A1>;
+/**
+ * Creates a composite effect that represents this effect followed by another
+ * one that may depend on the error produced by this one.
+ * @tsplus fluent fncts.io.STM flatMapError
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function chainError_<R, E, A, R2, E2>(stm: STM<R, E, A>, f: (e: E) => STM<R2, never, E2>): STM<R2 & R, E2, A>;
+/**
+ * Checks the condition, and if it's true, returns unit, otherwise, retries.
+ * @tsplus static fncts.io.STMOps check
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function check(predicate: () => boolean): STM<unknown, never, void>;
+/**
+ * Commits this transaction atomically, regardless of whether the transaction
+ * is a success or a failure.
+ */
+export declare function commitEither<R, E, A>(stm: STM<R, E, A>): IO<R, E, A>;
+/**
+ * Fail with `e` if the supplied `PartialFunction` does not match, otherwise
+ * succeed with the returned value.
+ * @tsplus fluent fncts.io.STM continueOrFail
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function continueOrFail_<R, E, E1, A, A2>(fa: STM<R, E, A>, e: Lazy<E1>, pf: (a: A) => Maybe<A2>): STM<R, E | E1, A2>;
+/**
+ * Fail with `e` if the supplied `PartialFunction` does not match, otherwise
+ * continue with the returned value.
+ * @tsplus fluent fncts.io.STM continueOrFailSTM
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function continueOrFailSTM_<R, E, E1, A, R2, E2, A2>(fa: STM<R, E, A>, e: Lazy<E1>, pf: (a: A) => Maybe<STM<R2, E2, A2>>): STM<R2 & R, E | E1 | E2, A2>;
+/**
+ * Fail with `e` if the supplied `PartialFunction` does not match, otherwise
+ * succeed with the returned value.
+ * @tsplus fluent fncts.io.STM continueOrRetry
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function continueOrRetry_<R, E, A, A2>(fa: STM<R, E, A>, pf: (a: A) => Maybe<A2>): STM<R, E, A2>;
+/**
+ * Simultaneously filters and flatMaps the value produced by this effect.
+ * Continues on the effect returned from pf.
+ * @tsplus fluent fncts.io.STM continueOrRetrySTM
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function continueOrRetrySTM_<R, E, A, R2, E2, A2>(fa: STM<R, E, A>, pf: (a: A) => Maybe<STM<R2, E2, A2>>): STM<R2 & R, E | E2, A2>;
+/**
+ * Suspends creation of the specified transaction lazily.
+ * @tsplus static fncts.io.STMOps defer
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function defer<R, E, A>(make: Lazy<STM<R, E, A>>): STM<R, E, A>;
+/**
+ * Converts the failure channel into an `Either`.
+ * @tsplus getter fncts.io.STM either
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function either<R, E, A>(stm: STM<R, E, A>): STM<R, never, Either<E, A>>;
+/**
+ * Returns an effect that ignores errors and runs repeatedly until it eventually succeeds.
+ * @tsplus getter fncts.io.STM eventually
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function eventually<R, E, A>(stm: STM<R, E, A>): STM<R, never, A>;
+/**
+ * Simultaneously filters and maps the value produced by this effect.
+ * @tsplus fluent fncts.io.STM filterMap
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function filterMap_<R, E, A, B>(stm: STM<R, E, A>, f: (a: A) => Maybe<B>): STM<R, E, B>;
+/**
+ * Simultaneously filters and chains the value produced by this effect.
+ * Continues on the effect returned from f.
+ * @tsplus fluent fncts.io.STM filterMapSTM
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function filterMapSTM_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (a: A) => Maybe<STM<R1, E1, B>>): STM<R & R1, E | E1, B>;
+/**
+ * Applies `or` if the predicate fails.
+ * @tsplus fluent fncts.io.STM filterOrElse
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function filterOrElse_<R, E, A, B extends A, R2, E2, A2>(fa: STM<R, E, A>, p: Refinement<A, B>, or: (a: Exclude<A, B>) => STM<R2, E2, A2>): STM<R & R2, E | E2, B | A2>;
+export declare function filterOrElse_<R, E, A, R2, E2, A2>(fa: STM<R, E, A>, p: Predicate<A>, or: (a: A) => STM<R2, E2, A2>): STM<R & R2, E | E2, A | A2>;
+/**
+ * Fails with `failWith` if the predicate fails.
+ * @tsplus fluent fncts.io.STM filterOrFail
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function filterOrFail_<R, E, E1, A, B extends A>(fa: STM<R, E, A>, p: Refinement<A, B>, failWith: (a: Exclude<A, B>) => E1): STM<R, E | E1, B>;
+export declare function filterOrFail_<R, E, E1, A>(fa: STM<R, E, A>, p: Predicate<A>, failWith: (a: A) => E1): STM<R, E | E1, A>;
+/**
+ * Halts with specified `unknown` if the predicate fails.
+ * @tsplus fluent fncts.io.STM filterOrHalt
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function filterOrHalt_<R, E, A, B extends A>(fa: STM<R, E, A>, p: Refinement<A, B>, haltWith: (a: Exclude<A, B>) => unknown): STM<R, E, B>;
+export declare function filterOrHalt_<R, E, A>(fa: STM<R, E, A>, p: Predicate<A>, haltWith: (a: A) => unknown): STM<R, E, A>;
+/**
+ * Flattens out a nested `STM` effect.
+ * @tsplus getter fncts.io.STM flatten
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function flatten<R, E, R1, E1, B>(stm: STM<R, E, STM<R1, E1, B>>): STM<R1 & R, E | E1, B>;
+/**
+ * Unwraps the optional error, defaulting to the provided value.
+ * @tsplus fluent fncts.io.STM flattenErrorOption
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function flattenErrorOption_<R, E, A, E2>(stm: STM<R, Maybe<E>, A>, def: Lazy<E2>): STM<R, E | E2, A>;
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` and
+ * returns a transactional effect that produces a new `ReadonlyArray<B>`.
+ * @tsplus static fncts.io.STMOps foreach
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function foreach_<A, R, E, B>(it: Iterable<A>, f: (a: A) => STM<R, E, B>): STM<R, E, readonly B[]>;
+/**
+ * Lifts an `Either` into a `STM`.
+ * @tsplus static fncts.io.STMOps fromEither
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function fromEither<E, A>(e: Lazy<Either<E, A>>): STM<unknown, E, A>;
+/**
+ * Lifts an `Either` into a `STM`.
+ * @tsplus static fncts.io.STMOps fromEitherNow
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function fromEitherNow<E, A>(e: Either<E, A>): STM<unknown, E, A>;
+/**
+ * Unwraps the optional success of this effect, but can fail with an None value.
+ */
+export declare function get<R, E, A>(stm: STM<R, E, Maybe<A>>): STM<R, Maybe<E>, A>;
+/**
+ * Provides the transaction its required environment, which eliminates
+ * its dependency on `R`.
+ * @tsplus fluent fncts.io.STM provideEnvironment
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function provideEnvironment_<R, E, A>(stm: STM<R, E, A>, r: R): STM<unknown, E, A>;
+/**
+ * Provides some of the environment required to run this effect,
+ * leaving the remainder `R0`.
+ * @tsplus fluent fncts.io.STM contramapEnvironment
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function contramapEnvironment_<R, E, A, R0>(self: STM<R, E, A>, f: (r: R0) => R): STM<R0, E, A>;
+/**
+ * Halts the fiber running the effect.
+ * @tsplus static fncts.io.STMOps halt
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function halt(u: Lazy<unknown>): STM<unknown, never, never>;
+/**
+ * Halts the fiber running the effect.
+ * @tsplus static fncts.io.STMOps haltNow
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function haltNow(u: unknown): STM<unknown, never, never>;
+/**
+ * Returns a successful effect with the head of the list if the list is
+ * non-empty or fails with the error `None` if the list is empty.
+ * @tsplus getter fncts.io.STM head
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function head<R, E, A>(stm: STM<R, E, Iterable<A>>): STM<R, Maybe<E>, A>;
+/**
+ * Interrupts the fiber running the effect.
+ * @tsplus static fncts.io.STMOps interrupt
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare const interrupt: STM<unknown, never, never>;
+/**
+ * Returns whether this effect is a failure.
+ * @tsplus getter fncts.io.STM isFailure
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function isFailure<R, E, A>(stm: STM<R, E, A>): STM<R, never, boolean>;
+/**
+ * Returns whether this effect is a success.
+ * @tsplus getter fncts.io.STM isSuccess
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function isSuccess<R, E, A>(stm: STM<R, E, A>): STM<R, never, boolean>;
+/**
+ * Depending on provided environment returns either this one or the other effect.
+ * @tsplus fluent fncts.io.STM join
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function join_<R, E, A, R1, E1, A1>(stm: STM<R, E, A>, that: STM<R1, E1, A1>): STM<Either<R, R1>, E | E1, A | A1>;
+/**
+ * Depending on provided environment returns either this one or the other effect.
+ * @tsplus fluent fncts.io.STM joinEither
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function joinEither_<R, E, A, R1, E1, A1>(stm: STM<R, E, A>, that: STM<R1, E1, A1>): STM<Either<R, R1>, E | E1, Either<A, A1>>;
+/**
+ * Returns a successful effect if the value is `Left`, or fails with the error `None`.
+ * @tsplus getter fncts.io.STM left
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function left<R, E, B, C>(stm: STM<R, E, Either<B, C>>): STM<R, Maybe<E>, B>;
+/**
+ * Returns a successful effect if the value is `Left`, or fails with the error e.
+ * @tsplus fluent fncts.io.STM leftOrFail
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function leftOrFail_<R, E, B, C, E1>(stm: STM<R, E, Either<B, C>>, orFail: (c: C) => E1): STM<R, E | E1, B>;
+/**
+ * Maps from one error type to another.
+ * @tsplus fluent fncts.io.STM mapError
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function mapError_<R, E, A, E1>(stm: STM<R, E, A>, f: (a: E) => E1): STM<R, E1, A>;
+/**
+ * Folds over the `STM` effect, handling both failure and success, but not
+ * retry.
+ * @tsplus fluent fncts.io.STM match
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function match_<R, E, A, B, C>(stm: STM<R, E, A>, g: (e: E) => C, f: (a: A) => B): STM<R, never, B | C>;
+/**
+ * Repeats this `STM` effect until its result satisfies the specified predicate.
+ *
+ * WARNING:
+ * `repeatUntil` uses a busy loop to repeat the effect and will consume a thread until
+ * it completes (it cannot yield). This is because STM describes a single atomic
+ * transaction which must either complete, retry or fail a transaction before
+ * yielding back to the Effect Runtime.
+ *
+ * - Use `retryUntil` instead if you don't need to maintain transaction state for repeats.
+ * - Ensure repeating the STM effect will eventually satisfy the predicate.
+ * @tsplus fluent fncts.io.STM repeatUntil
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function repeatUntil_<R, E, A>(stm: STM<R, E, A>, f: (a: A) => boolean): STM<R, E, A>;
+/**
+ * Repeats this `STM` effect while its result satisfies the specified predicate.
+ *
+ * WARNING:
+ * `repeatWhile` uses a busy loop to repeat the effect and will consume a thread until
+ * it completes (it cannot yield). This is because STM describes a single atomic
+ * transaction which must either complete, retry or fail a transaction before
+ * yielding back to the Effect Runtime.
+ *
+ * - Use `retryWhile` instead if you don't need to maintain transaction state for repeats.
+ * - Ensure repeating the STM effect will eventually not satisfy the predicate.
+ * @tsplus fluent fncts.io.STM repeatWhile
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function repeatWhile_<R, E, A>(stm: STM<R, E, A>, f: (a: A) => boolean): STM<R, E, A>;
+/**
+ * Returns an effect that swaps the error/success cases. This allows you to
+ * use all methods on the error channel, possibly before flipping back.
+ * @tsplus getter fncts.io.STM swap
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function swap<R, E, A>(stm: STM<R, E, A>): STM<R, A, E>;
+/**
+ * Swaps the error/value parameters, applies the function `f` and flips the parameters back
+ * @tsplus fluent fncts.io.STM swapWith
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function swapWith_<R, E, A, R2, E2, A2>(stm: STM<R, E, A>, f: (stm: STM<R, A, E>) => STM<R2, A2, E2>): STM<R2, E2, A2>;
+/**
+ * "Peeks" at the success of transactional effect.
+ * @tsplus fluent fncts.io.STM tap
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function tap_<R, E, A, R1, E1, B>(stm: STM<R, E, A>, f: (a: A) => STM<R1, E1, B>): STM<R1 & R, E | E1, A>;
+/**
+ * Returns an effect with the value on the left part.
+ * @tsplus static fncts.io.STMOps toLeft
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function toLeft<A>(a: Lazy<A>): STM<unknown, never, Either<A, never>>;
+/**
+ * Returns an `STM` effect that succeeds with `Unit`.
+ * @tsplus static fncts.io.STMOps unit
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare const unit: STM<unknown, never, void>;
+/**
+ * Sequentially zips this value with the specified one, combining the values
+ * using the specified combiner function.
+ * @tsplus fluent fncts.io.STM zipWith
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function zipWith_<R, E, A, R1, E1, B, C>(self: STM<R, E, A>, that: STM<R1, E1, B>, f: (a: A, b: B) => C): STM<R & R1, E | E1, C>;

package/STM/definition.d.ts

@@ -0,0 +1,105 @@
+import { FiberId } from "@fncts/base/data/FiberId";
+import type { Journal } from "./internal/Journal.js";
+import type { _A, _E, _R } from "@fncts/base/types";
+export declare const enum STMTag {
+    Effect = "Effect",
+    OnFailure = "OnFailure",
+    OnRetry = "OnRetry",
+    OnSuccess = "OnSuccess",
+    Succeed = "Succeed",
+    SucceedNow = "SucceedNow",
+    ContramapEnvironment = "ContramapEnvironment"
+}
+export declare const STMTypeId: unique symbol;
+export declare type STMTypeId = typeof STMTypeId;
+/**
+ * @tsplus type fncts.io.STM
+ * @tsplus companion fncts.io.STMOps
+ */
+export declare abstract class STM<R, E, A> {
+    readonly _typeId: STMTypeId;
+    readonly _R: (_: R) => void;
+    readonly _E: () => E;
+    readonly _A: () => A;
+}
+/**
+ * @tsplus unify fncts.io.STM
+ */
+export declare function unifySTM<X extends STM<any, any, any>>(self: X): STM<_R<X>, _E<X>, _A<X>>;
+/**
+ * @tsplus type fncts.io.STM
+ */
+export interface USTM<A> extends STM<unknown, never, A> {
+}
+export declare class Effect<R, E, A> extends STM<R, E, A> {
+    readonly f: (journal: Journal, fiberId: FiberId, r: R) => A;
+    readonly _tag = STMTag.Effect;
+    constructor(f: (journal: Journal, fiberId: FiberId, r: R) => A);
+}
+export declare class OnFailure<R, E, A, E1> extends STM<R, E1, A> {
+    readonly stm: STM<R, E, A>;
+    readonly onFailure: (e: E) => STM<R, E1, A>;
+    readonly _tag = STMTag.OnFailure;
+    constructor(stm: STM<R, E, A>, onFailure: (e: E) => STM<R, E1, A>);
+    apply(a: A): STM<R, E, A>;
+}
+export declare class OnRetry<R, E, A> extends STM<R, E, A> {
+    readonly stm: STM<R, E, A>;
+    readonly onRetry: STM<R, E, A>;
+    readonly _tag = STMTag.OnRetry;
+    constructor(stm: STM<R, E, A>, onRetry: STM<R, E, A>);
+    apply(a: A): STM<R, E, A>;
+}
+export declare class OnSuccess<R, E, A, B> extends STM<R, E, B> {
+    readonly stm: STM<R, E, A>;
+    readonly apply: (a: A) => STM<R, E, B>;
+    readonly _tag = STMTag.OnSuccess;
+    constructor(stm: STM<R, E, A>, apply: (a: A) => STM<R, E, B>);
+}
+export declare class Succeed<A> extends STM<unknown, never, A> {
+    readonly a: () => A;
+    readonly _tag = STMTag.Succeed;
+    constructor(a: () => A);
+}
+export declare class SucceedNow<A> extends STM<unknown, never, A> {
+    readonly a: A;
+    readonly _tag = STMTag.SucceedNow;
+    constructor(a: A);
+}
+export declare class ContramapEnvironment<R, E, A, R0> extends STM<R0, E, A> {
+    readonly stm: STM<R, E, A>;
+    readonly f: (_: R0) => R;
+    readonly _tag = STMTag.ContramapEnvironment;
+    constructor(stm: STM<R, E, A>, f: (_: R0) => R);
+}
+export declare function concrete<R, E, A>(_: STM<R, E, A>): asserts _ is Effect<R, E, A> | OnFailure<R, unknown, A, E> | OnSuccess<R, E, unknown, A> | OnRetry<R, E, A> | Succeed<A> | SucceedNow<A> | ContramapEnvironment<unknown, E, A, R>;
+export declare const FailExceptionTypeId: unique symbol;
+export declare type FailExceptionTypeId = typeof FailExceptionTypeId;
+export declare class FailException<E> {
+    readonly e: E;
+    readonly _typeId: FailExceptionTypeId;
+    constructor(e: E);
+}
+export declare function isFailException(u: unknown): u is FailException<unknown>;
+export declare const HaltExceptionTypeId: unique symbol;
+export declare type HaltExceptionTypeId = typeof HaltExceptionTypeId;
+export declare class HaltException<E> {
+    readonly e: E;
+    readonly _typeId: HaltExceptionTypeId;
+    constructor(e: E);
+}
+export declare function isHaltException(u: unknown): u is HaltException<unknown>;
+export declare const InterruptExceptionTypeId: unique symbol;
+export declare type InterruptExceptionTypeId = typeof InterruptExceptionTypeId;
+export declare class InterruptException {
+    readonly fiberId: FiberId;
+    readonly _typeId: InterruptExceptionTypeId;
+    constructor(fiberId: FiberId);
+}
+export declare function isInterruptException(u: unknown): u is InterruptException;
+export declare const RetryExceptionTypeId: unique symbol;
+export declare type RetryExceptionTypeId = typeof RetryExceptionTypeId;
+export declare class RetryException {
+    readonly _typeId: RetryExceptionTypeId;
+}
+export declare function isRetryException(u: unknown): u is RetryException;

package/STM/driver.d.ts

@@ -0,0 +1,15 @@
+import { STM } from "@fncts/io/STM/definition";
+import { FiberId } from "@fncts/base/data/FiberId";
+import { Environment } from "@fncts/base/data/Environment";
+import { TExit } from "@fncts/io/TExit/definition";
+import type { Journal } from "./internal/Journal.js";
+export declare class STMDriver<R, E, A> {
+    readonly self: STM<R, E, A>;
+    readonly journal: Journal;
+    readonly fiberId: FiberId;
+    private contStack;
+    private envStack;
+    constructor(self: STM<R, E, A>, journal: Journal, fiberId: FiberId, r0: Environment<R>);
+    private unwindStack;
+    run(): TExit<E, A>;
+}

package/STM/internal/CommitState.d.ts

@@ -0,0 +1,47 @@
+import { Exit } from "@fncts/base/data/Exit";
+import { TExit } from "@fncts/io/TExit/definition";
+export interface Done<E, A> {
+    readonly _tag: "Done";
+    readonly exit: Exit<E, A>;
+}
+/**
+ * @tsplus static fncts.io.CommitStateOps Done
+ * @tsplus location "@fncts/io/STM/internal/CommitState"
+ */
+export declare function Done<E, A>(exit: Exit<E, A>): Done<E, A>;
+export interface Interrupted {
+    readonly _tag: "Interrupted";
+}
+/**
+ * @tsplus static fncts.io.CommitStateOps Interrupted
+ * @tsplus location "@fncts/io/STM/internal/CommitState"
+ */
+export declare const Interrupted: CommitState<never, never>;
+export interface Running {
+    readonly _tag: "Running";
+}
+/**
+ * @tsplus static fncts.io.CommitStateOps Running
+ * @tsplus location "@fncts/io/STM/internal/CommitState"
+ */
+export declare const Running: CommitState<never, never>;
+/**
+ * @tsplus type fncts.io.CommitState
+ */
+export declare type CommitState<E, A> = Done<E, A> | Interrupted | Running;
+/**
+ * @tsplus type fncts.io.CommitStateOps
+ */
+export interface CommitStateOps {
+}
+export declare const CommitState: CommitStateOps;
+/**
+ * @tsplus getter fncts.io.CommitState isRunning
+ * @tsplus location "@fncts/io/STM/internal/CommitState"
+ */
+export declare function isRunning<E, A>(state: CommitState<E, A>): boolean;
+/**
+ * @tsplus static fncts.io.CommitStateOps done
+ * @tsplus location "@fncts/io/STM/internal/CommitState"
+ */
+export declare function done<E, A>(texit: TExit<E, A>): CommitState<E, A>;

package/STM/internal/Entry.d.ts

@@ -0,0 +1,37 @@
+import type { Atomic } from "../../TRef.js";
+import { Versioned } from "./Versioned.js";
+export declare const EntryTypeId: unique symbol;
+export declare type EntryTypeId = typeof EntryTypeId;
+/**
+ * @tsplus type fncts.io.Entry
+ * @tsplus companion fncts.io.EntryOps
+ */
+export declare class Entry {
+    readonly use: <X>(f: <S>(entry: ConcreteEntry<S>) => X) => X;
+    readonly _typeId: EntryTypeId;
+    constructor(use: <X>(f: <S>(entry: ConcreteEntry<S>) => X) => X);
+}
+/**
+ * @tsplus static fncts.io.EntryOps make
+ * @tsplus location "@fncts/io/STM/internal/Entry"
+ */
+export declare function make<A0>(tref0: Atomic<A0>, isNew0: boolean): Entry;
+export declare const ConcreteEntryTypeId: unique symbol;
+export declare type ConcreteEntryTypeId = typeof ConcreteEntryTypeId;
+export declare class ConcreteEntry<S> {
+    readonly tref: Atomic<S>;
+    readonly expected: Versioned<S>;
+    protected newValue: S;
+    readonly isNew: boolean;
+    private _isChanged;
+    readonly _typeId: ConcreteEntryTypeId;
+    constructor(tref: Atomic<S>, expected: Versioned<S>, newValue: S, isNew: boolean, _isChanged: boolean);
+    unsafeSet(value: unknown): void;
+    unsafeGet<B>(): B;
+    commit(): void;
+    copy(): Entry;
+    isInvalid(): boolean;
+    isValid(): boolean;
+    isChanged(): boolean;
+    toString(): string;
+}