@fncts/io 0.0.1

package/IO/definition.d.ts

@@ -0,0 +1,338 @@
+import { RuntimeConfig } from "@fncts/io/RuntimeConfig";
+import { FiberId } from "@fncts/base/data/FiberId";
+import { Either } from "@fncts/base/data/Either";
+import { Cause } from "@fncts/base/data/Cause";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { FiberScope } from "@fncts/io/FiberScope/definition";
+import { Lazy } from "@fncts/base/data/function";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { InterruptStatus } from "@fncts/io/InterruptStatus";
+import { FiberDescriptor } from "@fncts/io/FiberDescriptor";
+import { Supervisor } from "@fncts/io/Supervisor/definition";
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { FiberRefs } from "@fncts/io/FiberRefs";
+import { LogLevel } from "@fncts/io/LogLevel";
+import { Exit } from "@fncts/base/data/Exit";
+import type { Trace as Trace_ } from "@fncts/base/data/Trace";
+import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
+export declare const IOTypeId: unique symbol;
+export declare type IOTypeId = typeof IOTypeId;
+/**
+ * @tsplus type fncts.io.IO
+ * @tsplus companion fncts.io.IOOps
+ */
+export declare abstract class IO<R, E, A> {
+    readonly _typeId: IOTypeId;
+    readonly _R: (_: R) => void;
+    readonly _E: () => E;
+    readonly _A: () => A;
+}
+/**
+ * @tsplus type fncts.io.IOAspects
+ */
+export interface IOAspects {
+}
+/**
+ * @tsplus static fncts.io.IOOps $
+ * @tsplus location "@fncts/io/IO/definition"
+ */
+export declare const IOAspects: IOAspects;
+/**
+ * @tsplus unify fncts.io.IO
+ */
+export declare function unifyIO<X extends IO<any, any, any>>(self: X): IO<[
+    X
+] extends [IO<infer R, any, any>] ? R : never, [
+    X
+] extends [IO<any, infer E, any>] ? E : never, [
+    X
+] extends [IO<any, any, infer A>] ? A : never>;
+export declare type UIO<A> = IO<unknown, never, A>;
+export declare type URIO<R, A> = IO<R, never, A>;
+export declare type FIO<E, A> = IO<unknown, E, A>;
+export declare const enum IOTag {
+    SucceedNow = "SucceedNow",
+    Chain = "Chain",
+    Defer = "Defer",
+    DeferWith = "DeferWith",
+    Succeed = "SucceedLazy",
+    SucceedWith = "SucceedLazyWith",
+    Async = "Async",
+    Match = "Match",
+    Fork = "Fork",
+    Fail = "Fail",
+    Yield = "Yield",
+    Race = "Race",
+    SetInterrupt = "SetInterrupt",
+    GetInterrupt = "GetInterrupt",
+    GetDescriptor = "GetDescriptor",
+    Supervise = "Supervise",
+    FiberRefModify = "FiberRefModify",
+    FiberRefLocally = "FiberRefLocally",
+    FiberRefDelete = "FiberRefDelete",
+    FiberRefWith = "FiberRefWith",
+    FiberRefModifyAll = "FiberRefModifyAll",
+    GetForkScope = "GetForkScope",
+    OverrideForkScope = "OverrideForkScope",
+    Trace = "Trace",
+    GetRuntimeConfig = "GetRuntimeConfig",
+    Ensuring = "Ensuring",
+    Logged = "Logged",
+    SetRuntimeConfig = "SetRuntimeConfig"
+}
+export declare function isIO(u: unknown): u is IO<any, any, any>;
+/**
+ * @internal
+ */
+export declare class Chain<R, R1, E, E1, A, A1> extends IO<R & R1, E | E1, A1> {
+    readonly io: IO<R, E, A>;
+    readonly f: (a: A) => IO<R1, E1, A1>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.Chain;
+    constructor(io: IO<R, E, A>, f: (a: A) => IO<R1, E1, A1>, trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class SucceedNow<A> extends IO<unknown, never, A> {
+    readonly value: A;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.SucceedNow;
+    constructor(value: A, trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class Succeed<A> extends IO<unknown, never, A> {
+    readonly effect: () => A;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.Succeed;
+    constructor(effect: () => A, trace?: string | undefined);
+}
+export declare class SucceedWith<A> extends IO<unknown, never, A> {
+    readonly effect: (runtimeConfig: RuntimeConfig, fiberId: FiberId) => A;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.SucceedWith;
+    constructor(effect: (runtimeConfig: RuntimeConfig, fiberId: FiberId) => A, trace?: string | undefined);
+}
+export declare class Trace extends IO<unknown, never, Trace_> {
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.Trace;
+    constructor(trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class Async<R, E, A, R1> extends IO<R & R1, E, A> {
+    readonly register: (f: (_: IO<R, E, A>) => void) => Either<Canceler<R1>, IO<R, E, A>>;
+    readonly blockingOn: FiberId;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.Async;
+    constructor(register: (f: (_: IO<R, E, A>) => void) => Either<Canceler<R1>, IO<R, E, A>>, blockingOn: FiberId, trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class Match<R, E, A, R1, E1, B, R2, E2, C> extends IO<R & R1 & R2, E1 | E2, B | C> {
+    readonly io: IO<R, E, A>;
+    readonly onFailure: (cause: Cause<E>) => IO<R1, E1, B>;
+    readonly apply: (a: A) => IO<R2, E2, C>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.Match;
+    constructor(io: IO<R, E, A>, onFailure: (cause: Cause<E>) => IO<R1, E1, B>, apply: (a: A) => IO<R2, E2, C>, trace?: string | undefined);
+}
+export declare type FailureReporter = (e: Cause<unknown>) => void;
+/**
+ * @internal
+ */
+export declare class Fork<R, E, A> extends IO<R, never, FiberContext<E, A>> {
+    readonly io: IO<R, E, A>;
+    readonly scope: Maybe<FiberScope>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.Fork;
+    constructor(io: IO<R, E, A>, scope: Maybe<FiberScope>, trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class Fail<E> extends IO<unknown, E, never> {
+    readonly cause: Lazy<Cause<E>>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.Fail;
+    constructor(cause: Lazy<Cause<E>>, trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class Yield extends IO<unknown, never, void> {
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.Yield;
+    constructor(trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class Defer<R, E, A> extends IO<R, E, A> {
+    readonly make: () => IO<R, E, A>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.Defer;
+    constructor(make: () => IO<R, E, A>, trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class DeferWith<R, E, A> extends IO<R, E, A> {
+    readonly make: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.DeferWith;
+    constructor(make: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>, trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class Race<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3> extends IO<R & R1 & R2 & R3, E2 | E3, A2 | A3> {
+    readonly left: IO<R, E, A>;
+    readonly right: IO<R1, E1, A1>;
+    readonly leftWins: (exit: Fiber<E, A>, fiber: Fiber<E1, A1>) => IO<R2, E2, A2>;
+    readonly rightWins: (exit: Fiber<E1, A1>, fiber: Fiber<E, A>) => IO<R3, E3, A3>;
+    readonly trace?: string | undefined;
+    readonly _tag = "Race";
+    constructor(left: IO<R, E, A>, right: IO<R1, E1, A1>, leftWins: (exit: Fiber<E, A>, fiber: Fiber<E1, A1>) => IO<R2, E2, A2>, rightWins: (exit: Fiber<E1, A1>, fiber: Fiber<E, A>) => IO<R3, E3, A3>, trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class SetInterrupt<R, E, A> extends IO<R, E, A> {
+    readonly io: IO<R, E, A>;
+    readonly flag: InterruptStatus;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.SetInterrupt;
+    constructor(io: IO<R, E, A>, flag: InterruptStatus, trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class GetInterrupt<R, E, A> extends IO<R, E, A> {
+    readonly f: (_: InterruptStatus) => IO<R, E, A>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.GetInterrupt;
+    constructor(f: (_: InterruptStatus) => IO<R, E, A>, trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class GetDescriptor<R, E, A> extends IO<R, E, A> {
+    readonly f: (_: FiberDescriptor) => IO<R, E, A>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.GetDescriptor;
+    constructor(f: (_: FiberDescriptor) => IO<R, E, A>, trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class Supervise<R, E, A> extends IO<R, E, A> {
+    readonly io: IO<R, E, A>;
+    readonly supervisor: Supervisor<any>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.Supervise;
+    constructor(io: IO<R, E, A>, supervisor: Supervisor<any>, trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class FiberRefModify<A, B> extends IO<unknown, never, B> {
+    readonly fiberRef: FiberRef<unknown>;
+    readonly f: (a: A) => readonly [B, A];
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.FiberRefModify;
+    constructor(fiberRef: FiberRef<unknown>, f: (a: A) => readonly [B, A], trace?: string | undefined);
+}
+export declare class FiberRefLocally<V, R, E, A> extends IO<R, E, A> {
+    readonly localValue: V;
+    readonly fiberRef: FiberRef<V>;
+    readonly io: IO<R, E, A>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.FiberRefLocally;
+    constructor(localValue: V, fiberRef: FiberRef<V>, io: IO<R, E, A>, trace?: string | undefined);
+}
+export declare class FiberRefDelete extends IO<unknown, never, void> {
+    readonly fiberRef: FiberRef<unknown>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.FiberRefDelete;
+    constructor(fiberRef: FiberRef<unknown>, trace?: string | undefined);
+}
+export declare class FiberRefWith<A, P, R, E, B> extends IO<R, E, B> {
+    readonly fiberRef: FiberRef<A>;
+    readonly f: (a: A) => IO<R, E, B>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.FiberRefWith;
+    constructor(fiberRef: FiberRef<A>, f: (a: A) => IO<R, E, B>, trace?: string | undefined);
+}
+export declare class FiberRefModifyAll<A> extends IO<unknown, never, A> {
+    readonly f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs) => readonly [A, FiberRefs];
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.FiberRefModifyAll;
+    constructor(f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs) => readonly [A, FiberRefs], trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class GetForkScope<R, E, A> extends IO<R, E, A> {
+    readonly f: (_: FiberScope) => IO<R, E, A>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.GetForkScope;
+    constructor(f: (_: FiberScope) => IO<R, E, A>, trace?: string | undefined);
+}
+/**
+ * @internal
+ */
+export declare class OverrideForkScope<R, E, A> extends IO<R, E, A> {
+    readonly io: IO<R, E, A>;
+    readonly forkScope: Maybe<FiberScope>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.OverrideForkScope;
+    constructor(io: IO<R, E, A>, forkScope: Maybe<FiberScope>, trace?: string | undefined);
+}
+export declare class GetRuntimeConfig<R, E, A> extends IO<R, E, A> {
+    readonly f: (_: RuntimeConfig) => IO<R, E, A>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.GetRuntimeConfig;
+    constructor(f: (_: RuntimeConfig) => IO<R, E, A>, trace?: string | undefined);
+}
+export declare class Ensuring<R, E, A, R1> extends IO<R & R1, E, A> {
+    readonly io: IO<R, E, A>;
+    readonly finalizer: IO<R1, never, any>;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.Ensuring;
+    constructor(io: IO<R, E, A>, finalizer: IO<R1, never, any>, trace?: string | undefined);
+}
+export declare class Logged extends IO<unknown, never, void> {
+    readonly message: () => string;
+    readonly cause: Cause<any>;
+    readonly overrideLogLevel: Maybe<LogLevel>;
+    readonly trace?: string | undefined;
+    readonly overrideRef1: FiberRef<unknown> | null;
+    readonly overrideValue1: unknown | null;
+    readonly _tag = IOTag.Logged;
+    constructor(message: () => string, cause: Cause<any>, overrideLogLevel: Maybe<LogLevel>, trace?: string | undefined, overrideRef1?: FiberRef<unknown> | null, overrideValue1?: unknown | null);
+}
+export declare class SetRuntimeConfig extends IO<unknown, never, void> {
+    readonly runtimeConfig: RuntimeConfig;
+    readonly trace?: string | undefined;
+    readonly _tag = IOTag.SetRuntimeConfig;
+    constructor(runtimeConfig: RuntimeConfig, trace?: string | undefined);
+}
+export declare type Instruction = Chain<any, any, any, any, any, any> | SucceedNow<any> | Succeed<any> | SucceedWith<any> | Async<any, any, any, any> | Match<any, any, any, any, any, any, any, any, any> | Fork<any, any, any> | SetInterrupt<any, any, any> | GetInterrupt<any, any, any> | Fail<any> | GetDescriptor<any, any, any> | Yield | Defer<any, any, any> | DeferWith<any, any, any> | FiberRefModify<any, any> | FiberRefLocally<any, any, any, any> | FiberRefDelete | FiberRefWith<any, any, any, any, any> | FiberRefModifyAll<any> | Race<any, any, any, any, any, any, any, any, any, any, any, any> | Supervise<any, any, any> | GetForkScope<any, any, any> | OverrideForkScope<any, any, any> | Trace | GetRuntimeConfig<any, any, any> | Ensuring<any, any, any, any> | Logged | SetRuntimeConfig;
+/**
+ * @optimize identity
+ */
+export declare function concrete(_: IO<any, any, any>): Instruction;
+export declare type Canceler<R> = URIO<R, void>;
+export declare const IOErrorTypeId: unique symbol;
+export declare type IOErrorTypeId = typeof IOErrorTypeId;
+export declare class IOError<E, A> {
+    readonly exit: Exit<E, A>;
+    readonly _typeId: IOErrorTypeId;
+    constructor(exit: Exit<E, A>);
+}
+export declare function isIOError(u: unknown): u is IOError<unknown, unknown>;

package/IO/runtime.d.ts

@@ -0,0 +1,43 @@
+import { Environment } from "@fncts/base/data/Environment";
+import { RuntimeConfig } from "@fncts/io/RuntimeConfig";
+import { IO, URIO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit";
+import { FiberId } from "@fncts/base/data/FiberId";
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { Cons } from "@fncts/base/collection/immutable/List";
+export declare class Runtime<R> {
+    readonly environment: Environment<R>;
+    readonly runtimeConfig: RuntimeConfig;
+    constructor(environment: Environment<R>, runtimeConfig: RuntimeConfig);
+    unsafeRunWith: <E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>, k: (exit: import("@fncts/base/data/Exit").Exit<E, A>) => any, __tsplusTrace?: string) => (fiberId: FiberId) => (f: (exit: import("@fncts/base/data/Exit").Exit<E, A>) => any) => void;
+    unsafeRunAsync: <E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>, __tsplusTrace?: string) => void;
+    unsafeRunAsyncWith: <E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>, k: (exit: import("@fncts/base/data/Exit").Exit<E, A>) => any, __tsplusTrace?: string) => void;
+    unsafeRunPromiseExit: <E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>, __tsplusTrace?: string) => Promise<import("@fncts/base/data/Exit").Exit<E, A>>;
+}
+/**
+ * @tsplus static fncts.io.IOOps runtime
+ * @tsplus location "@fncts/io/IO/runtime"
+ */
+export declare function runtime<R>(__tsplusTrace?: string): URIO<R, Runtime<R>>;
+export declare const defaultRuntimeConfig: import("../RuntimeConfig").RuntimeConfig;
+export declare const defaultRuntime: Runtime<unknown>;
+/**
+ * @tsplus fluent fncts.io.IO unsafeRunAsync
+ * @tsplus location "@fncts/io/IO/runtime"
+ */
+export declare const unsafeRunAsync: <E, A>(io: import("@fncts/io/IO/definition").IO<unknown, E, A>, __tsplusTrace?: string) => void;
+/**
+ * @tsplus fluent fncts.io.IO unsafeRunAsyncWith
+ * @tsplus location "@fncts/io/IO/runtime"
+ */
+export declare const unsafeRunAsyncWith: <E, A>(io: import("@fncts/io/IO/definition").IO<unknown, E, A>, k: (exit: import("@fncts/base/data/Exit").Exit<E, A>) => any, __tsplusTrace?: string) => void;
+/**
+ * @tsplus fluent fncts.io.IO unsafeRunPromiseExit
+ * @tsplus location "@fncts/io/IO/runtime"
+ */
+export declare const unsafeRunPromiseExit: <E, A>(io: import("@fncts/io/IO/definition").IO<unknown, E, A>, __tsplusTrace?: string) => Promise<import("@fncts/base/data/Exit").Exit<E, A>>;
+/**
+ * @tsplus fluent fncts.io.IO unsafeRunWith
+ * @tsplus location "@fncts/io/IO/runtime"
+ */
+export declare const unsafeRunWith: <E, A>(io: import("@fncts/io/IO/definition").IO<unknown, E, A>, k: (exit: import("@fncts/base/data/Exit").Exit<E, A>) => any, __tsplusTrace?: string) => (fiberId: FiberId) => (f: (exit: import("@fncts/base/data/Exit").Exit<E, A>) => any) => void;

package/IO.d.ts

@@ -0,0 +1,47 @@
+export * from "./IO/api.js";
+export * from "./IO/definition.js";
+export * from "./IO/runtime.js";
+export * from "./IO/api/acquireRelease.js";
+export * from "./IO/api/acquireReleaseExit.js";
+export * from "./IO/api/acquireReleaseInterruptible.js";
+export * from "./IO/api/acquireReleaseInterruptibleExit.js";
+export * from "./IO/api/addFinalizer.js";
+export * from "./IO/api/addFinalizerExit.js";
+export * from "./IO/api/bracket.js";
+export * from "./IO/api/bracketExit.js";
+export * from "./IO/api/clockWith.js";
+export * from "./IO/api/concurrency.js";
+export * from "./IO/api/concurrentFinalizers.js";
+export * from "./IO/api/consoleWith.js";
+export * from "./IO/api/core-scope.js";
+export * from "./IO/api/environment.js";
+export * from "./IO/api/foreachC.js";
+export * from "./IO/api/foreachExec.js";
+export * from "./IO/api/forkAll.js";
+export * from "./IO/api/forkIn.js";
+export * from "./IO/api/forkScoped.js";
+export * from "./IO/api/fulfill.js";
+export * from "./IO/api/interrupt.js";
+export * from "./IO/api/memoize.js";
+export * from "./IO/api/once.js";
+export * from "./IO/api/onExit.js";
+export * from "./IO/api/provideLayer.js";
+export * from "./IO/api/provideSomeLayer.js";
+export * from "./IO/api/race.js";
+export * from "./IO/api/raceFirst.js";
+export * from "./IO/api/randomWith.js";
+export * from "./IO/api/repeat.js";
+export * from "./IO/api/retry.js";
+export * from "./IO/api/schedule.js";
+export * from "./IO/api/scope.js";
+export * from "./IO/api/scoped.js";
+export * from "./IO/api/scopeWith.js";
+export * from "./IO/api/sequenceT.js";
+export * from "./IO/api/sleep.js";
+export * from "./IO/api/stateful.js";
+export * from "./IO/api/withChildren.js";
+export * from "./IO/api/withFinalizer.js";
+export * from "./IO/api/withFinalizerExit.js";
+export * from "./IO/api/withRuntimeConfig.js";
+export * from "./IO/api/zipC.js";
+export * from "./IO/api/zipWithC.js";

package/IOEnv/definition.d.ts

@@ -0,0 +1,16 @@
+import { Has } from "@fncts/base/typeclass/Has";
+import { Clock } from "@fncts/io/Clock/definition";
+import { Random } from "@fncts/io/Random/definition";
+import { Console } from "@fncts/io/Console";
+export declare type IOEnv = Has<Clock> & Has<Console> & Has<Random>;
+/**
+ * @tsplus type fncts.io.IOEnvOps
+ */
+export interface IOEnvOps {
+}
+export declare const IOEnv: IOEnvOps;
+/**
+ * @tsplus static fncts.io.IOEnvOps environment
+ * @tsplus location "@fncts/io/IOEnv/definition"
+ */
+export declare const environment: import("@fncts/base/data/Environment").Environment<import("@fncts/base/typeclass").Has<import("../Clock").Clock> & import("@fncts/base/typeclass").Has<import("../Random").Random> & import("@fncts/base/typeclass").Has<Console>>;

package/IOEnv/live.d.ts

@@ -0,0 +1,6 @@
+import { Console } from "@fncts/io/Console";
+/**
+ * @tsplus static fncts.io.IOEnvOps Live
+ * @tsplus location "@fncts/io/IOEnv/live"
+ */
+export declare const live: import("../Layer").Layer<unknown, never, import("@fncts/base/typeclass").Has<import("../Clock").Clock> & import("@fncts/base/typeclass").Has<import("../Random").Random> & import("@fncts/base/typeclass").Has<Console>>;

package/IOEnv/services.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "@fncts/base/data/Environment";
+import { IOEnv } from "@fncts/io/IOEnv";
+import type { Patch } from "@fncts/base/data/Patch";
+/**
+ * @tsplus static fncts.io.IOEnvOps services
+ * @tsplus location "@fncts/io/IOEnv/services"
+ */
+export declare const services: FiberRef.WithPatch<Environment<IOEnv>, Patch<IOEnv, IOEnv>>;

package/IOEnv.d.ts

@@ -0,0 +1,3 @@
+export * from "./IOEnv/definition.js";
+export * from "./IOEnv/live.js";
+export * from "./IOEnv/services.js";

package/IOSpec.d.ts

@@ -0,0 +1,3 @@
+import { IO } from "@fncts/io/IO";
+import { Exit } from "@fncts/base/data/Exit";
+export {};

package/InterruptStatus/constructors.d.ts

@@ -0,0 +1,16 @@
+import { InterruptStatus } from "@fncts/io/InterruptStatus";
+/**
+ * @tsplus static fncts.InterruptStatusOps interruptible
+ * @tsplus location "@fncts/io/InterruptStatus/constructors"
+ */
+export declare const interruptible: import("./definition").InterruptStatus;
+/**
+ * @tsplus static fncts.InterruptStatusOps uninterruptible
+ * @tsplus location "@fncts/io/InterruptStatus/constructors"
+ */
+export declare const uninterruptible: import("./definition").InterruptStatus;
+/**
+ * @tsplus static fncts.InterruptStatusOps fromBoolean
+ * @tsplus location "@fncts/io/InterruptStatus/constructors"
+ */
+export declare function fromBoolean(b: boolean): InterruptStatus;

package/InterruptStatus/definition.d.ts

@@ -0,0 +1,12 @@
+/**
+ * InterruptStatus tracks interruptability of the current stack region
+ *
+ * @tsplus type fncts.InterruptStatus
+ * @tsplus companion fncts.InterruptStatusOps
+ */
+export declare class InterruptStatus {
+    readonly isInterruptible: boolean;
+    constructor(isInterruptible: boolean);
+    get isUninteruptible(): boolean;
+    get toBoolean(): boolean;
+}

package/InterruptStatus.d.ts

@@ -0,0 +1,2 @@
+export * from "./InterruptStatus/constructors.js";
+export * from "./InterruptStatus/definition.js";

package/Layer/MemoMap.d.ts

@@ -0,0 +1,43 @@
+import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import { FIO, UIO, IO } from "@fncts/io/IO/definition";
+import { Finalizer } from "@fncts/io/Scope/Finalizer";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Layer } from "@fncts/io/Layer";
+import { Environment } from "@fncts/base/data/Environment";
+import { Exit } from "@fncts/base/data/Exit";
+import { Has } from "@fncts/base/typeclass/Has";
+import type { Fresh } from "@fncts/io/Layer/definition";
+/**
+ * A `MemoMap` memoizes dependencies.
+ */
+export declare class MemoMap {
+    readonly ref: Ref.Synchronized<HashMap<PropertyKey, readonly [FIO<any, any>, Finalizer]>>;
+    constructor(ref: Ref.Synchronized<HashMap<PropertyKey, readonly [FIO<any, any>, Finalizer]>>);
+    /**
+     * Checks the memo map to see if a dependency exists. If it is, immediately
+     * returns it. Otherwise, obtains the dependency, stores it in the memo map,
+     * and adds a finalizer to the outer `Managed`.
+     */
+    getOrElseMemoize: <R, E, A>(scope: Scope, layer: import("@fncts/io/Layer/definition").Layer<R, E, A>) => import("../IO").IO<R, E, import("@fncts/base/data/Environment").Environment<A>>;
+}
+/**
+ * @tsplus fluent fncts.io.Layer isFresh
+ * @tsplus location "@fncts/io/Layer/MemoMap"
+ */
+export declare function isFresh<R, E, A>(self: Layer<R, E, A>): self is Fresh<R, E, A>;
+export declare function makeMemoMap(): UIO<MemoMap>;
+/**
+ * @tsplus getter fncts.io.Layer build
+ * @tsplus location "@fncts/io/Layer/MemoMap"
+ */
+export declare function build<R, E, A>(self: Layer<R, E, A>): IO<R & Has<Scope>, E, Environment<A>>;
+/**
+ * @tsplus fluent fncts.io.Layer build
+ * @tsplus location "@fncts/io/Layer/MemoMap"
+ */
+export declare function build_<R, E, A>(self: Layer<R, E, A>, scope: Scope): IO<R, E, Environment<A>>;
+/**
+ * @tsplus fluent fncts.io.Layer scope
+ * @tsplus location "@fncts/io/Layer/MemoMap"
+ */
+export declare function scope<R, E, A>(layer: Layer<R, E, A>, scope: Scope): IO<unknown, never, (_: MemoMap) => IO<R, E, Environment<A>>>;