@fncts/io 0.0.17 → 0.0.18

package/IO/definition.d.ts

@@ -7,21 +7,18 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { FiberScope } from "@fncts/io/FiberScope";
 import { Lazy } from "@fncts/base/data/function/definition";
 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 { FiberRef } from "@fncts/io/FiberRef/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
+import type { FiberStatus } from "../FiberStatus.js";
 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;
+export type IOTypeId = typeof IOTypeId;
 export interface IOF extends HKT {
     type: IO<this["R"], this["E"], this["A"]>;
     variance: {
-        R: "-";
+        R: "+";
         E: "+";
         A: "+";
     };
@@ -62,9 +59,9 @@ export declare function unifyIO<X extends IO<any, any, any>>(self: X): IO<[
 ] extends [{
     _A: () => infer A;
 }] ? A : never>;
-export declare type UIO<A> = IO<never, never, A>;
-export declare type URIO<R, A> = IO<R, never, A>;
-export declare type FIO<E, A> = IO<never, E, A>;
+export type UIO<A> = IO<never, never, A>;
+export type URIO<R, A> = IO<R, never, A>;
+export type FIO<E, A> = IO<never, E, A>;
 export declare const enum IOTag {
     SucceedNow = "SucceedNow",
     Chain = "Chain",
@@ -78,22 +75,9 @@ export declare const enum IOTag {
     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"
+    Stateful = "Stateful"
 }
 export declare function isIO(u: unknown): u is IO<any, any, any>;
 /**
@@ -156,7 +140,7 @@ export declare class Match<R, E, A, R1, E1, B, R2, E2, C> extends IO<R | R1 | R2
     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;
+export type FailureReporter = (e: Cause<unknown>) => void;
 /**
  * @internal
  */
@@ -214,112 +198,11 @@ export declare class Race<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3> extends I
     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<never, 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<never, 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<never, 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>;
+export declare class Stateful<R, E, A> extends IO<R, E, A> {
+    readonly onState: (fiber: FiberContext<E, A>, status: FiberStatus) => 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);
+    readonly _tag = IOTag.Stateful;
+    constructor(onState: (fiber: FiberContext<E, A>, status: FiberStatus) => IO<R, E, A>, trace?: string | undefined);
 }
 export declare class Logged extends IO<never, never, void> {
     readonly message: () => string;
@@ -331,20 +214,14 @@ export declare class Logged extends IO<never, never, void> {
     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<never, 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;
+export 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> | Fail<any> | Yield | Defer<any, any, any> | DeferWith<any, any, any> | Stateful<any, any, any> | Race<any, any, any, any, any, any, any, any, any, any, any, any> | Trace | Logged;
 /**
  * @tsplus macro identity
  */
 export declare function concrete(_: IO<any, any, any>): Instruction;
-export declare type Canceler<R> = URIO<R, void>;
+export type Canceler<R> = URIO<R, void>;
 export declare const IOErrorTypeId: unique symbol;
-export declare type IOErrorTypeId = typeof IOErrorTypeId;
+export type IOErrorTypeId = typeof IOErrorTypeId;
 export declare class IOError<E, A> {
     readonly exit: Exit<E, A>;
     readonly _typeId: IOErrorTypeId;

package/IO.d.ts

@@ -42,6 +42,7 @@ 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/supervised.js";
 export * from "./IO/api/timeout.js";
 export * from "./IO/api/withChildren.js";
 export * from "./IO/api/withEarlyRelease.js";

package/IOEnv/definition.d.ts

@@ -1,7 +1,7 @@
 import { Clock } from "@fncts/io/Clock/definition";
 import { Random } from "@fncts/io/Random/definition";
 import { Console } from "@fncts/io/Console";
-export declare type IOEnv = Clock | Console | Random;
+export type IOEnv = Clock | Console | Random;
 /**
  * @tsplus type fncts.io.IOEnvOps
  */

package/Layer/definition.d.ts

@@ -3,7 +3,7 @@ import { Environment } from "@fncts/base/data/Environment/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 import { IO } from "@fncts/io/IO/definition";
 export declare const LayerHash: unique symbol;
-export declare type LayerHash = typeof LayerHash;
+export type LayerHash = typeof LayerHash;
 /**
  * @tsplus type fncts.io.Layer
  * @tsplus companion fncts.io.LayerOps
@@ -15,7 +15,7 @@ export declare abstract class Layer<RIn, E, ROut> {
     [LayerHash]: PropertyKey;
     setKey(hash: PropertyKey): this;
 }
-export declare type Concrete = Fold<any, any, any, any, any, any, any, any, any> | Fresh<any, any, any> | FromScoped<any, any, any> | Defer<any, any, any> | To<any, any, any, any, any> | ZipWith<any, any, any, any, any, any, any> | ZipWithC<any, any, any, any, any, any, any>;
+export type Concrete = Fold<any, any, any, any, any, any, any, any, any> | Fresh<any, any, any> | FromScoped<any, any, any> | Defer<any, any, any> | To<any, any, any, any, any> | ZipWith<any, any, any, any, any, any, any> | ZipWithC<any, any, any, any, any, any, any>;
 /**
  * @tsplus fluent fncts.io.Layer concrete
  * @tsplus location "@fncts/io/Layer/definition"

package/Ref/definition.d.ts

@@ -5,7 +5,7 @@ import type { Derived } from "./Derived.js";
 import type { DerivedAll } from "./DerivedAll.js";
 import type * as Synchro from "./Synchronized/definition.js";
 export declare const RefTypeId: unique symbol;
-export declare type RefTypeId = typeof RefTypeId;
+export type RefTypeId = typeof RefTypeId;
 /**
  * @tsplus type fncts.io.Ref
  */
@@ -18,8 +18,8 @@ export interface PRef<RA, RB, EA, EB, A, B> {
     readonly _A: (_: A) => void;
     readonly _B: () => B;
 }
-export declare type Ref<A> = PRef<never, never, never, never, A, A>;
-export declare type ERef<E, A> = PRef<unknown, unknown, E, E, A, A>;
+export type Ref<A> = PRef<never, never, never, never, A, A>;
+export type ERef<E, A> = PRef<unknown, unknown, E, E, A, A>;
 export declare namespace PRef {
     type Synchronized<RA, RB, EA, EB, A, B> = Synchro.PSynchronized<RA, RB, EA, EB, A, B>;
 }

package/RuntimeConfig.d.ts

@@ -10,7 +10,7 @@ export declare const RuntimeConfigFlag: {
     readonly TrackRuntimeMetrics: symbol;
     readonly EnableFiberRoots: symbol;
 };
-export declare type RuntimeConfigFlag = typeof RuntimeConfigFlag[keyof typeof RuntimeConfigFlag];
+export type RuntimeConfigFlag = typeof RuntimeConfigFlag[keyof typeof RuntimeConfigFlag];
 export declare class RuntimeConfig extends CaseClass<{
     readonly reportFailure: (e: Cause<unknown>) => void;
     readonly supervisor: Supervisor<any>;

package/STM/definition.d.ts

@@ -12,7 +12,7 @@ export declare const enum STMTag {
     ContramapEnvironment = "ContramapEnvironment"
 }
 export declare const STMTypeId: unique symbol;
-export declare type STMTypeId = typeof STMTypeId;
+export type STMTypeId = typeof STMTypeId;
 /**
  * @tsplus type fncts.io.STM
  * @tsplus companion fncts.io.STMOps
@@ -75,7 +75,7 @@ export declare class ContramapEnvironment<R, E, A, R0> extends STM<R0, E, A> {
 }
 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 type FailExceptionTypeId = typeof FailExceptionTypeId;
 export declare class FailException<E> {
     readonly e: E;
     readonly _typeId: FailExceptionTypeId;
@@ -83,7 +83,7 @@ export declare class FailException<E> {
 }
 export declare function isFailException(u: unknown): u is FailException<unknown>;
 export declare const HaltExceptionTypeId: unique symbol;
-export declare type HaltExceptionTypeId = typeof HaltExceptionTypeId;
+export type HaltExceptionTypeId = typeof HaltExceptionTypeId;
 export declare class HaltException<E> {
     readonly e: E;
     readonly _typeId: HaltExceptionTypeId;
@@ -91,7 +91,7 @@ export declare class HaltException<E> {
 }
 export declare function isHaltException(u: unknown): u is HaltException<unknown>;
 export declare const InterruptExceptionTypeId: unique symbol;
-export declare type InterruptExceptionTypeId = typeof InterruptExceptionTypeId;
+export type InterruptExceptionTypeId = typeof InterruptExceptionTypeId;
 export declare class InterruptException {
     readonly fiberId: FiberId;
     readonly _typeId: InterruptExceptionTypeId;
@@ -99,7 +99,7 @@ export declare class InterruptException {
 }
 export declare function isInterruptException(u: unknown): u is InterruptException;
 export declare const RetryExceptionTypeId: unique symbol;
-export declare type RetryExceptionTypeId = typeof RetryExceptionTypeId;
+export type RetryExceptionTypeId = typeof RetryExceptionTypeId;
 export declare class RetryException {
     readonly _typeId: RetryExceptionTypeId;
 }

package/STM/internal/CommitState.d.ts

@@ -28,7 +28,7 @@ export declare const Running: CommitState<never, never>;
 /**
  * @tsplus type fncts.io.CommitState
  */
-export declare type CommitState<E, A> = Done<E, A> | Interrupted | Running;
+export type CommitState<E, A> = Done<E, A> | Interrupted | Running;
 /**
  * @tsplus type fncts.io.CommitStateOps
  */

package/STM/internal/Entry.d.ts

@@ -1,7 +1,7 @@
 import type { Atomic } from "../../TRef.js";
 import { Versioned } from "./Versioned.js";
 export declare const EntryTypeId: unique symbol;
-export declare type EntryTypeId = typeof EntryTypeId;
+export type EntryTypeId = typeof EntryTypeId;
 /**
  * @tsplus type fncts.io.Entry
  * @tsplus companion fncts.io.EntryOps
@@ -17,7 +17,7 @@ export declare class 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 type ConcreteEntryTypeId = typeof ConcreteEntryTypeId;
 export declare class ConcreteEntry<S> {
     readonly tref: Atomic<S>;
     readonly expected: Versioned<S>;

package/STM/internal/Journal.d.ts

@@ -14,14 +14,14 @@ import { Done } from "./TryCommit.js";
 /**
  * @tsplus type fncts.io.Journal
  */
-export declare type Journal = Map<Atomic<any>, Entry>;
+export type Journal = Map<Atomic<any>, Entry>;
 /**
  * @tsplus type fncts.io.JournalOps
  */
 export interface JournalOps {
 }
 export declare const Journal: JournalOps;
-export declare type Todo = () => unknown;
+export type Todo = () => unknown;
 /**
  * Creates a function that can reset the journal.
  * @tsplus fluent fncts.io.Journal prepareReset
@@ -34,13 +34,13 @@ export declare function prepareResetJournal(journal: Journal): () => unknown;
  * @tsplus location "@fncts/io/STM/internal/Journal"
  */
 export declare function commitJournal(journal: Journal): void;
-declare type Invalid = -1;
+type Invalid = -1;
 declare const Invalid = -1;
-declare type ReadOnly = 0;
+type ReadOnly = 0;
 declare const ReadOnly = 0;
-declare type ReadWrite = 1;
+type ReadWrite = 1;
 declare const ReadWrite = 1;
-declare type JournalAnalysis = Invalid | ReadOnly | ReadWrite;
+type JournalAnalysis = Invalid | ReadOnly | ReadWrite;
 /**
  * Analyzes the journal, determining whether it is valid and whether it is
  * read only in a single pass. Note that information on whether the

package/STM/internal/TryCommit.d.ts

@@ -1,8 +1,8 @@
 import { Exit } from "@fncts/base/data/Exit/definition";
 import type { Journal } from "./Journal.js";
 export declare const TryCommitTypeId: unique symbol;
-export declare type TryCommitTypeId = typeof TryCommitTypeId;
-export declare type TryCommit<E, A> = Done<E, A> | Suspend;
+export type TryCommitTypeId = typeof TryCommitTypeId;
+export type TryCommit<E, A> = Done<E, A> | Suspend;
 export declare const enum TryCommitTag {
     Done = "Done",
     Suspend = "Suspend"

package/STM/internal/Versioned.d.ts

@@ -1,5 +1,5 @@
 export declare const VersionedTypeId: unique symbol;
-export declare type VersionedTypeId = typeof VersionedTypeId;
+export type VersionedTypeId = typeof VersionedTypeId;
 export declare class Versioned<A> {
     readonly value: A;
     readonly _typeId: VersionedTypeId;

package/Schedule/Decision.d.ts

@@ -15,7 +15,7 @@ export declare class Done {
 /**
  * @tsplus type fncts.io.Schedule.Decision
  */
-export declare type Decision = Continue | Done;
+export type Decision = Continue | Done;
 /**
  * @tsplus type fncts.io.Schedule.DecisionOps
  */

package/Scope/ReleaseMap/definition.d.ts

@@ -18,7 +18,7 @@ export declare class Running {
     readonly _tag = "Running";
     constructor(nextKey: number, finalizers: HashMap<number, Finalizer>, update: (_: Finalizer) => Finalizer);
 }
-export declare type State = Exited | Running;
+export type State = Exited | Running;
 interface ReleaseMapN extends HKT {
     readonly type: ReleaseMap;
 }

package/Scope/definition.d.ts

@@ -3,7 +3,7 @@ import { UIO } from "@fncts/io/IO/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 export declare const ScopeTypeId: unique symbol;
-export declare type ScopeTypeId = typeof ScopeTypeId;
+export type ScopeTypeId = typeof ScopeTypeId;
 /**
  * @tsplus type fncts.io.Scope
  * @tsplus companion fncts.io.ScopeOps
@@ -20,7 +20,7 @@ export declare abstract class Scope {
 export declare abstract class Closeable extends Scope {
     abstract close(exit: Lazy<Exit<any, any>>): UIO<void>;
 }
-declare type Closeable_ = Closeable;
+type Closeable_ = Closeable;
 export declare namespace Scope {
     type Closeable = Closeable_;
 }

package/ScopedRef/definition.d.ts

@@ -1,7 +1,7 @@
 import { IO, UIO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 export declare const ScopedRefTypeId: unique symbol;
-export declare type ScopedRefTypeId = typeof ScopedRefTypeId;
+export type ScopedRefTypeId = typeof ScopedRefTypeId;
 /**
  * @tsplus type fncts.io.ScopedRef
  * @tsplus companion fncts.io.ScopedRefOps

package/State/internal.d.ts

@@ -1,6 +1,6 @@
 import { UIO } from "@fncts/io/IO/definition";
 export declare const StateTypeId: unique symbol;
-export declare type StateTypeId = typeof StateTypeId;
+export type StateTypeId = typeof StateTypeId;
 export declare abstract class StateInternal<S> {
     readonly _A: () => S;
     readonly _typeId: StateTypeId;

package/Stream/api.d.ts

@@ -744,7 +744,7 @@ export declare function mergeMapIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>,
  */
 export declare function mergeEither_<R, E, A, R1, E1, B>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, Either<A, B>>;
 export declare function mergeWithHandler<R, E>(terminate: boolean, __tsplusTrace?: string): (exit: Exit<E, unknown>) => MergeDecision<R, E, unknown, E, unknown>;
-export declare type TerminationStrategy = "Left" | "Right" | "Both" | "Either";
+export type TerminationStrategy = "Left" | "Right" | "Both" | "Either";
 /**
  * @tsplus fluent fncts.io.Stream mergeWith
  * @tsplus location "@fncts/io/Stream/api"

package/Stream/definition.d.ts

@@ -2,7 +2,7 @@ import { Channel } from "@fncts/io/Channel";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import type { _A, _E, _R } from "@fncts/base/types";
 export declare const StreamTypeId: unique symbol;
-export declare type StreamTypeId = typeof StreamTypeId;
+export type StreamTypeId = typeof StreamTypeId;
 /**
  * A `Stream<R, E, A>` is a description of a program that, when evaluated,
  * may emit 0 or more values of type `A`, may fail with errors of type `E`

package/Stream/internal/DebounceState.d.ts

@@ -7,19 +7,19 @@ export declare const enum DebounceStateTag {
     Current = "Current"
 }
 export declare const NotStartedTag: unique symbol;
-export declare type NotStartedTag = typeof NotStartedTag;
+export type NotStartedTag = typeof NotStartedTag;
 export declare class NotStarted {
     readonly _tag = DebounceStateTag.NotStarted;
 }
 export declare const PreviousTag: unique symbol;
-export declare type PreviousTag = typeof PreviousTag;
+export type PreviousTag = typeof PreviousTag;
 export declare class Previous<A> {
     readonly fiber: Fiber<never, Conc<A>>;
     readonly _tag = DebounceStateTag.Previous;
     constructor(fiber: Fiber<never, Conc<A>>);
 }
 export declare const CurrentTag: unique symbol;
-export declare type CurrentTag = typeof CurrentTag;
+export type CurrentTag = typeof CurrentTag;
 export declare class Current<E, A> {
     readonly fiber: Fiber<E, HandoffSignal<E, A>>;
     readonly _tag = DebounceStateTag.Current;
@@ -28,7 +28,7 @@ export declare class Current<E, A> {
 /**
  * @tsplus type fncts.io.Stream.DebounceState
  */
-export declare type DebounceState<E, A> = NotStarted | Previous<A> | Current<E, A>;
+export type DebounceState<E, A> = NotStarted | Previous<A> | Current<E, A>;
 /**
  * @tsplus type fncts.io.Stream.DebounceStateOps
  */

package/Stream/internal/Handoff.d.ts

@@ -29,7 +29,7 @@ export declare class Full<A> {
     readonly _tag: typeof FullTypeId;
     constructor(a: A, notifyProducer: Future<never, void>);
 }
-export declare type State<A> = Empty | Full<A>;
+export type State<A> = Empty | Full<A>;
 /**
  * @tsplus static fncts.io.Stream.HandoffOps __call
  * @tsplus location "@fncts/io/Stream/internal/Handoff"
@@ -52,7 +52,7 @@ export declare function take<A>(handoff: Handoff<A>): UIO<A>;
 export declare function poll<A>(handoff: Handoff<A>): UIO<Maybe<A>>;
 export declare const HandoffSignalTypeId: unique symbol;
 export declare const EmitTypeId: unique symbol;
-export declare type EmitTypeId = typeof EmitTypeId;
+export type EmitTypeId = typeof EmitTypeId;
 export declare class Emit<A> {
     readonly els: Conc<A>;
     readonly _typeId: typeof HandoffSignalTypeId;
@@ -60,7 +60,7 @@ export declare class Emit<A> {
     constructor(els: Conc<A>);
 }
 export declare const HaltTypeId: unique symbol;
-export declare type HaltTypeId = typeof HaltTypeId;
+export type HaltTypeId = typeof HaltTypeId;
 export declare class Halt<E> {
     readonly error: Cause<E>;
     readonly _typeId: typeof HandoffSignalTypeId;
@@ -68,7 +68,7 @@ export declare class Halt<E> {
     constructor(error: Cause<E>);
 }
 export declare const EndTypeId: unique symbol;
-export declare type EndTypeId = typeof EndTypeId;
+export type EndTypeId = typeof EndTypeId;
 export declare class End {
     readonly reason: SinkEndReason;
     readonly _typeId: typeof HandoffSignalTypeId;
@@ -78,7 +78,7 @@ export declare class End {
 /**
  * @tsplus type fncts.io.Stream.HandoffSignal
  */
-export declare type HandoffSignal<E, A> = Emit<A> | Halt<E> | End;
+export type HandoffSignal<E, A> = Emit<A> | Halt<E> | End;
 /**
  * @tsplus type fncts.io.Stream.HandoffSignalOps
  */

package/Stream/internal/Pull.d.ts

@@ -4,7 +4,7 @@ import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import type { Queue } from "../../Queue.js";
 import type { Take } from "./Take.js";
-export declare type Pull<R, E, A> = IO<R, Maybe<E>, Conc<A>>;
+export type Pull<R, E, A> = IO<R, Maybe<E>, Conc<A>>;
 /**
  * @tsplus type fncts.io.Stream.PullOps
  */

package/Stream/internal/SinkEndReason.d.ts

@@ -16,7 +16,7 @@ export declare class UpstreamEnd {
 /**
  * @tsplus type fncts.io.Stream.SinkEndReason
  */
-export declare type SinkEndReason = ScheduleEnd | UpstreamEnd;
+export type SinkEndReason = ScheduleEnd | UpstreamEnd;
 /**
  * @tsplus fluent fncts.io.Stream.SinkEndReason match
  * @tsplus location "@fncts/io/Stream/internal/SinkEndReason"

package/TExit/definition.d.ts

@@ -4,7 +4,7 @@ import { FiberId } from "@fncts/base/data/FiberId/definition";
 /**
  * @tsplus type fncts.TExit
  */
-export declare type TExit<E, A> = Fail<E> | Succeed<A> | Retry | Halt | Interrupt;
+export type TExit<E, A> = Fail<E> | Succeed<A> | Retry | Halt | Interrupt;
 /**
  * @tsplus type fncts.TExitOps
  */
@@ -12,7 +12,7 @@ export interface TExitOps {
 }
 export declare const TExit: TExitOps;
 export declare const TExitTypeId: unique symbol;
-export declare type TExitTypeId = typeof TExitTypeId;
+export type TExitTypeId = typeof TExitTypeId;
 export declare const enum TExitTag {
     Fail = "Fail",
     Succeed = "Succeed",
@@ -21,7 +21,7 @@ export declare const enum TExitTag {
     Retry = "Retry"
 }
 export declare const FailTypeId: unique symbol;
-export declare type FailTypeId = typeof FailTypeId;
+export type FailTypeId = typeof FailTypeId;
 /**
  * @tsplus static fncts.TExitOps isTExit
  * @tsplus location "@fncts/io/TExit/definition"

package/TReentrantLock/definition.d.ts

@@ -62,4 +62,4 @@ export declare class ReadLock implements Lock {
     noOtherHolder(fiberId: FiberId): boolean;
     adjust(fiberId: FiberId, adjust: number): ReadLock;
 }
-export declare type LockState = WriteLock | ReadLock;
+export type LockState = WriteLock | ReadLock;

package/TRef/definition.d.ts

@@ -5,7 +5,7 @@ import type { Versioned } from "../STM/internal/Versioned.js";
 import type { AtomicReference } from "@fncts/base/internal/AtomicReference";
 import type { TxnId } from "@fncts/io/TxnId";
 export declare const TRefTypeId: unique symbol;
-export declare type TRefTypeId = typeof TRefTypeId;
+export type TRefTypeId = typeof TRefTypeId;
 /**
  * A `TRef<EA, EB, A, B>` is a polymorphic, purely functional description of a
  * mutable reference that can be modified as part of a transactional effect. The

package/TxnId.d.ts

@@ -1,4 +1,4 @@
-export declare type TxnId = number;
+export type TxnId = number;
 /**
  * @tsplus type fncts.TxnIdOps
  */

package/_cjs/Clock/definition.cjs

@@ -22,6 +22,6 @@ class Clock {}
 
 
 exports.Clock = Clock;
-const ClockTag = /*#__PURE__*/tsplus_module_1.makeTag("d60c9045-a93d-492e-97ae-170170bdeed1");
+const ClockTag = /*#__PURE__*/tsplus_module_1.makeTag("19435fc3-3855-4914-989b-3d23ff58fa87");
 exports.ClockTag = ClockTag;
 //# sourceMappingURL=definition.cjs.map