@fncts/io 0.0.18 → 0.0.20

package/Clock/definition.d.ts

@@ -11,6 +11,7 @@ export declare abstract class Clock {
 }
 /**
  * @tsplus static fncts.io.ClockOps Tag
+ * @tsplus implicit
  * @tsplus location "@fncts/io/Clock/definition"
  */
 export declare const ClockTag: import("@fncts/base/data/Tag").Tag<Clock>;

package/Differ/api.d.ts

@@ -0,0 +1,24 @@
+import type { Environment } from "@fncts/base/data/Environment";
+import type { Supervisor } from "@fncts/io/Supervisor";
+import { Differ } from "./definition.js";
+/**
+ * Constructs a differ that just diffs two values by returning a function that
+ * sets the value to the new value. This differ does not support combining
+ * multiple updates to the value compositionally and should only be used when
+ * there is no compositional way to update them.
+ * @tsplus static fncts.io.DifferOps update
+ * @tsplus location "@fncts/io/Differ/api"
+ */
+export declare function update<A>(): Differ<A, (_: A) => A>;
+/**
+ * Constructs a differ that knows how to diff `Environment` values.
+ * @tsplus static fncts.io.DifferOps environment
+ * @tsplus location "@fncts/io/Differ/api"
+ */
+export declare function environment<A>(): Differ<Environment<A>, Environment.Patch<A, A>>;
+/**
+ * Constructs a differ that knows how to diff `Supervisor` values.
+ * @tsplus static fncts.io.DifferOps supervisor
+ * @tsplus location "@fncts/io/Differ/api"
+ */
+export declare function supervisor(): Differ<Supervisor<any>, Supervisor.Patch>;

package/Differ/definition.d.ts

@@ -0,0 +1,15 @@
+export declare const DifferTypeId: unique symbol;
+export type DifferTypeId = typeof DifferTypeId;
+/**
+ * @tsplus type fncts.io.Differ
+ * @tsplus companion fncts.io.DifferOps
+ */
+export declare abstract class Differ<Value, Patch> {
+    readonly _typeId: DifferTypeId;
+    _Value: Value;
+    _Patch: Patch;
+    abstract readonly empty: Patch;
+    abstract combine(first: Patch, second: Patch): Patch;
+    abstract diff(oldValue: Value, newValue: Value): Patch;
+    abstract patch(patch: Patch): (oldValue: Value) => Value;
+}

package/Fiber/FiberContext.d.ts

@@ -28,7 +28,7 @@ import { Stack } from "@fncts/base/internal/Stack";
 import { FiberTypeId } from "@fncts/io/Fiber/definition";
 import { FiberState } from "@fncts/io/FiberState";
 import { FiberStatus } from "@fncts/io/FiberStatus";
-export type FiberRefLocals = AtomicReference<HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>>;
+export type FiberRefLocals = HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>;
 type Erased = IO<any, any, any>;
 type ErasedCont = (a: any) => Erased;
 export declare class InterruptExit {
@@ -87,6 +87,7 @@ export declare class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable
     awaitAsync(k: FiberState.Callback<E, A>): void;
     get children(): UIO<Conc<Fiber.Runtime<any, any>>>;
     evalOnIO<R1, E1, B, R2, E2, C>(effect: IO<R1, E1, B>, orElse: IO<R2, E2, C>, __tsplusTrace?: string): IO<R1 & R2, E1 | E2, B | C>;
+    get fiberRefs(): FiberRefs;
     get await(): UIO<Exit<E, A>>;
     run(): void;
     get scope(): FiberScope;
@@ -125,7 +126,7 @@ export declare class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable
     private unsafeNextEffect;
     private unsafeNotifyObservers;
     private unsafeRemoveObserver;
-    private unsafeInterruptAs;
+    interruptAsFork(fiberId: FiberId): UIO<void>;
     private unsafeTryDone;
     private unsafeSetAsyncCanceller;
     private unsafeReportUnhandled;
@@ -145,6 +146,8 @@ export declare class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable
     unsafeAddChild(child: FiberContext<unknown, unknown>): void;
     private unsafeLog;
     private unsafeLogWith;
+    private unsafeIsFatal;
+    private unsafeHandleFatalError;
     get currentSupervisor(): Supervisor<any>;
 }
 export {};

package/Fiber/api/interruptAll.d.ts

@@ -6,7 +6,7 @@ import { UIO } from "@fncts/io/IO/definition";
  * @tsplus static fncts.io.FiberOps interruptAllAs
  * @tsplus location "@fncts/io/Fiber/api/interruptAll"
  */
-export declare function interruptAllAs_(fs: Iterable<Fiber<any, any>>, id: FiberId, __tsplusTrace?: string): UIO<void>;
+export declare function interruptAllAs(fs: Iterable<Fiber<any, any>>, id: FiberId, __tsplusTrace?: string): UIO<void>;
 /**
  * Interrupts all fibers and awaits their interruption
  * @tsplus static fncts.io.FiberOps interruptAll

package/Fiber/api/interruptAsFork.d.ts

@@ -0,0 +1,8 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus fluent fncts.io.Fiber interruptAsFork
+ * @tsplus location "@fncts/io/Fiber/api/interruptAsFork"
+ */
+export declare function interruptAsFork<E, A>(self: Fiber<E, A>, fiberId: FiberId): UIO<void>;

package/Fiber/definition.d.ts

@@ -39,11 +39,9 @@ export interface FiberCommon<E, A> extends Fiber<E, A> {
      */
     readonly inheritRefs: UIO<void>;
     /**
-     * Interrupts the fiber as if interrupted from the specified fiber. If the
-     * fiber has already exited, the returned effect will resume immediately.
-     * Otherwise, the effect will resume when the fiber exits.
+     * Interrupts the fiber as if interrupted from the specified fiber.
      */
-    readonly interruptAs: (fiberId: FiberId) => UIO<Exit<E, A>>;
+    readonly interruptAsFork: (fiberId: FiberId) => UIO<void>;
     /**
      * Tentatively observes the fiber, but returns immediately if it is not already done.
      */
@@ -84,13 +82,13 @@ export declare class SyntheticFiber<E, A> implements FiberCommon<E, A> {
     readonly children: UIO<Conc<Fiber.Runtime<any, any>>>;
     readonly inheritRefs: UIO<void>;
     readonly poll: UIO<Maybe<Exit<E, A>>>;
-    readonly interruptAs: (fiberId: FiberId) => UIO<Exit<E, A>>;
+    readonly interruptAsFork: (fiberId: FiberId) => UIO<void>;
     readonly _tag = "SyntheticFiber";
     readonly _typeId: FiberTypeId;
     readonly _E: () => E;
     readonly _A: () => A;
     readonly await: import("../IO").UIO<import("@fncts/base/data/Exit").Exit<E, A>>;
-    constructor(id: FiberId, wait: UIO<Exit<E, A>>, children: UIO<Conc<Fiber.Runtime<any, any>>>, inheritRefs: UIO<void>, poll: UIO<Maybe<Exit<E, A>>>, interruptAs: (fiberId: FiberId) => UIO<Exit<E, A>>);
+    constructor(id: FiberId, wait: UIO<Exit<E, A>>, children: UIO<Conc<Fiber.Runtime<any, any>>>, inheritRefs: UIO<void>, poll: UIO<Maybe<Exit<E, A>>>, interruptAsFork: (fiberId: FiberId) => UIO<void>);
 }
 export type ConcreteFiber<E, A> = Fiber.Runtime<E, A> | Fiber.Synthetic<E, A>;
 /**

package/FiberRef/api.d.ts

@@ -87,3 +87,8 @@ export declare function patch<Value, Patch>(self: FiberRef.WithPatch<Value, Patc
  * @tsplus location "@fncts/io/FiberRef/api"
  */
 export declare function fork<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>): Patch;
+/**
+ * @tsplus fluent fncts.io.FiberRef join
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function join<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>, oldValue: Value, newValue: Value): Value;

package/FiberRef/definition.d.ts

@@ -25,9 +25,10 @@ export declare class FiberRefInternal<Value, Patch> extends FiberRef<Value> impl
     readonly _combine: (first: Patch, second: Patch) => Patch;
     readonly _patch: (patch: Patch) => (oldValue: Value) => Value;
     readonly _fork: Patch;
+    readonly _join: (oldValue: Value, newValue: Value) => Value;
     readonly _Patch: Patch;
     private readonly id;
-    constructor(_initial: Value, _diff: (oldValue: Value, newValue: Value) => Patch, _combine: (first: Patch, second: Patch) => Patch, _patch: (patch: Patch) => (oldValue: Value) => Value, _fork: Patch);
+    constructor(_initial: Value, _diff: (oldValue: Value, newValue: Value) => Patch, _combine: (first: Patch, second: Patch) => Patch, _patch: (patch: Patch) => (oldValue: Value) => Value, _fork: Patch, _join: (oldValue: Value, newValue: Value) => Value);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }

package/FiberRef/unsafe.d.ts

@@ -1,24 +1,31 @@
 import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
+import { Supervisor } from "@fncts/io/Supervisor/definition";
+import { SupervisorPatch } from "@fncts/io/SupervisorPatch";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { FiberScope } from "@fncts/io/FiberScope";
 import { LogLevel } from "@fncts/io/LogLevel";
 import { List } from "@fncts/base/collection/immutable/List/definition";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
-import { Supervisor } from "@fncts/io/Supervisor/definition";
 import type { LogSpan } from "../LogSpan.js";
 import type { Scheduler } from "@fncts/io/internal/Scheduler.js";
-import { Patch } from "@fncts/base/data/Patch";
+import { Differ } from "@fncts/io/Differ/definition";
+import { IsFatal } from "../internal/IsFatal.js";
 /**
  * @tsplus static fncts.io.FiberRefOps unsafeMakePatch
  * @tsplus location "@fncts/io/FiberRef/unsafe"
  */
-export declare function unsafeMakePatch<Value, Patch>(initial: Value, diff: (oldValue: Value, newValue: Value) => Patch, combine: (first: Patch, second: Patch) => Patch, patch: (patch: Patch) => (oldValue: Value) => Value, fork: Patch): FiberRef.WithPatch<Value, Patch>;
+export declare function unsafeMakePatch<Value, Patch>(initial: Value, differ: Differ<Value, Patch>, fork: Patch, join?: (oldValue: Value, newValue: Value) => Value): FiberRef.WithPatch<Value, Patch>;
 /**
  * @tsplus static fncts.io.FiberRefOps unsafeMakeEnvironment
  * @tsplus location "@fncts/io/FiberRef/unsafe"
  */
-export declare function unsafeMakeEnvironment<A>(initial: Environment<A>): FiberRef.WithPatch<Environment<A>, Patch<A, A>>;
+export declare function unsafeMakeEnvironment<A>(initial: Environment<A>): FiberRef.WithPatch<Environment<A>, Environment.Patch<A, A>>;
+/**
+ * @tsplus static fncts.io.FiberRefOps unsafeMakeSupervisor
+ * @tsplus location "@fncts/io/FiberRef/unsafe"
+ */
+export declare function unsafeMakeSupervisor(initial: Supervisor<any>): FiberRef.WithPatch<Supervisor<any>, SupervisorPatch>;
 /**
  * @tsplus static fncts.io.FiberRefOps unsafeMake
  * @tsplus location "@fncts/io/FiberRef/unsafe"
@@ -33,7 +40,7 @@ export declare const forkScopeOverride: import("./definition.js").FiberRef.WithP
  * @tsplus static fncts.io.FiberRefOps currentEnvironment
  * @tsplus location "@fncts/io/FiberRef/unsafe"
  */
-export declare const currentEnvironment: import("./definition.js").FiberRef.WithPatch<import("@fncts/base/data/Environment.js").Environment<unknown>, Patch<unknown, unknown>>;
+export declare const currentEnvironment: import("./definition.js").FiberRef.WithPatch<import("@fncts/base/data/Environment.js").Environment<unknown>, import("@fncts/base/data/Environment.js").Environment.Patch<unknown, unknown>>;
 /**
  * @tsplus static fncts.io.FiberRefOps fiberName
  * @tsplus location "@fncts/io/FiberRef/unsafe"
@@ -63,4 +70,14 @@ export declare const currentScheduler: import("./definition.js").FiberRef.WithPa
  * @tsplus static fncts.io.FiberRefOps currentSupervisor
  * @tsplus location "@fncts/io/FiberRef/unsafe"
  */
-export declare const currentSupervisor: import("./definition.js").FiberRef.WithPatch<import("../Supervisor.js").Supervisor<any>, (_: import("../Supervisor.js").Supervisor<any>) => import("../Supervisor.js").Supervisor<any>>;
+export declare const currentSupervisor: import("./definition.js").FiberRef.WithPatch<import("../Supervisor.js").Supervisor<any>, import("../SupervisorPatch.js").SupervisorPatch>;
+/**
+ * @tsplus static fncts.io.FiberRefOps currentIsFatal
+ * @tsplus location "@fncts/io/FiberRef/unsafe"
+ */
+export declare const currentIsFatal: import("./definition.js").FiberRef.WithPatch<IsFatal, (_: IsFatal) => IsFatal>;
+/**
+ * @tsplus static fncts.io.FiberRefOps currentReportFatal
+ * @tsplus location "@fncts/io/FiberRef/unsafe"
+ */
+export declare const currentReportFatal: import("./definition.js").FiberRef.WithPatch<(t: unknown) => never, (_: (t: unknown) => never) => (t: unknown) => never>;

package/FiberRefs/api.d.ts

@@ -14,3 +14,8 @@ export declare function fiberRefs(self: FiberRefs): HashSet<FiberRef<unknown>>;
  * @tsplus location "@fncts/io/FiberRefs/api"
  */
 export declare function make(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>): FiberRefs;
+/**
+ * @tsplus fluent fncts.io.FiberRefs forkAs
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function forkAs(self: FiberRefs, childId: FiberId.Runtime): FiberRefs;

package/IOEnv/services.d.ts

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

package/Reloadable/api.d.ts

@@ -0,0 +1,21 @@
+import { Tag } from "@fncts/base/data/Tag/definition";
+import { IO } from "@fncts/io/IO/definition";
+import type { Reloadable } from "./definition.js";
+/**
+ * @tsplus static fncts.io.ReloadableOps get
+ * @tsplus location "@fncts/io/Reloadable/api"
+ */
+export declare function get<Service>(
+/** @tsplus auto */ tag: Tag<Reloadable<Service>>): IO<Reloadable<Service>, unknown, Service>;
+/**
+ * @tsplus static fncts.io.ReloadableOps reload
+ * @tsplus location "@fncts/io/Reloadable/api"
+ */
+export declare function reload<Service>(
+/** @tsplua auto */ tag: Tag<Reloadable<Service>>): IO<Reloadable<Service>, unknown, void>;
+/**
+ * @tsplus static fncts.io.ReloadableOps reloadFork
+ * @tsplus location "@fncts/io/Reloadable/api"
+ */
+export declare function reloadFork<Service>(
+/** @tsplus auto */ tag: Tag<Reloadable<Service>>): IO<Reloadable<Service>, never, void>;

package/Reloadable/constructors.d.ts

@@ -0,0 +1,23 @@
+import { Layer } from "@fncts/io/Layer";
+import { Tag } from "@fncts/base/data/Tag/definition";
+import { Schedule } from "@fncts/io/Schedule/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { Reloadable } from "./definition.js";
+/**
+ * @tsplus static fncts.io.ReloadableOps auto
+ * @tsplus location "@fncts/io/Reloadable/constructors"
+ */
+export declare function auto<In, E, Out, Env>(layer: Layer<In, E, Out>, tag: Tag<Out>, schedule: Schedule<Env, any, any>, 
+/** @tsplus auto */ reloadableTag: Tag<Reloadable<Out>>): Layer<In | Env, E, Reloadable<Out>>;
+/**
+ * @tsplus static fncts.io.ReloadableOps autoFromConfig
+ * @tsplus location "@fncts/io/Reloadable/constructors"
+ */
+export declare function autoFromConfig<In, E, Out, Env>(layer: Layer<In, E, Out>, tag: Tag<Out>, scheduleFromConfig: (env: Environment<In>) => Schedule<Env, any, any>, 
+/** @tsplus auto */ reloadableTag: Tag<Reloadable<Out>>): Layer<In | Env, E, Reloadable<Out>>;
+/**
+ * @tsplus static fncts.io.ReloadableOps manual
+ * @tsplus location "@fncts/io/Reloadable/constructors"
+ */
+export declare function manual<In, E, Out>(layer: Layer<In, E, Out>, tag: Tag<Out>, 
+/** @tsplus auto */ reloadableTag: Tag<Reloadable<Out>>): Layer<In, E, Reloadable<Out>>;

package/Reloadable/definition.d.ts

@@ -0,0 +1,20 @@
+import { ScopedRef } from "@fncts/io/ScopedRef/definition";
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Tag } from "@fncts/base/data/Tag/definition";
+/**
+ * @tsplus type fncts.io.Reloadable
+ * @tsplus companion fncts.io.ReloadableOps
+ */
+export declare class Reloadable<Service> {
+    readonly scopedRef: ScopedRef<Service>;
+    readonly reload: IO<never, unknown, void>;
+    _Service: (_: never) => Service;
+    constructor(scopedRef: ScopedRef<Service>, reload: IO<never, unknown, void>);
+    get get(): UIO<Service>;
+    get reloadFork(): UIO<void>;
+}
+/**
+ * @tsplus derive fncts.Tag[fncts.io.Reloadable]<_> 10
+ * @tsplus location "@fncts/io/Reloadable/definition"
+ */
+export declare function deriveTag<S>(...[tag]: [S] extends [Reloadable<infer X>] ? [tag: Tag<X>] : [tag: Tag<S>]): Tag<Reloadable<S>>;

package/Reloadable.d.ts

@@ -0,0 +1,3 @@
+export * from "./Reloadable/api.js";
+export * from "./Reloadable/constructors.js";
+export * from "./Reloadable/definition.js";

package/Supervisor/api.d.ts

@@ -1,11 +1,17 @@
 import { Supervisor } from "@fncts/io/Supervisor/definition";
-import { Environment } from "@fncts/base/data/Environment/definition";
-import { IO } from "@fncts/io/IO/definition";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
-import { Fiber } from "@fncts/io/Fiber/definition";
-import { Exit } from "@fncts/base/data/Exit/definition";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 /**
  * @tsplus fluent fncts.io.Supervisor zip
  * @tsplus location "@fncts/io/Supervisor/api"
  */
 export declare function zip_<A, B>(fa: Supervisor<A>, fb: Supervisor<B>): Supervisor<readonly [A, B]>;
+/**
+ * @tsplus getter fncts.io.Supervisor toSet
+ * @tsplus location "@fncts/io/Supervisor/api"
+ */
+export declare function toSet(self: Supervisor<any>): HashSet<Supervisor<any>>;
+/**
+ * @tsplus fluent fncts.io.Supervisor removeSupervisor
+ * @tsplus location "@fncts/io/Supervisor/api"
+ */
+export declare function removeSupervisor(self: Supervisor<any>, that: Supervisor<any>): Supervisor<any>;

package/Supervisor/definition.d.ts

@@ -3,6 +3,12 @@ import { Environment } from "@fncts/base/data/Environment/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
+import type { SupervisorPatch } from "@fncts/io/SupervisorPatch";
+export declare const enum SupervisorTag {
+    Const = 0,
+    Proxy = 1,
+    Zip = 2
+}
 /**
  * @tsplus type fncts.io.Supervisor
  * @tsplus companion fncts.io.SupervisorOps
@@ -15,8 +21,12 @@ export declare abstract class Supervisor<A> {
     unsafeOnSuspend<E, A>(_fiber: Fiber.Runtime<E, A>): void;
     unsafeOnResume<E, A>(_fiber: Fiber.Runtime<E, A>): void;
 }
+export declare namespace Supervisor {
+    type Patch = SupervisorPatch;
+}
 export declare class ConstSupervisor<A> extends Supervisor<A> {
     readonly value: UIO<A>;
+    readonly _tag = SupervisorTag.Const;
     constructor(value: UIO<A>);
     unsafeOnStart(): void;
     unsafeOnEnd(): void;
@@ -27,6 +37,7 @@ export declare class ConstSupervisor<A> extends Supervisor<A> {
 export declare class ProxySupervisor<A> extends Supervisor<A> {
     readonly value: UIO<A>;
     readonly underlying: Supervisor<any>;
+    readonly _tag = SupervisorTag.Proxy;
     constructor(value: UIO<A>, underlying: Supervisor<any>);
     unsafeOnStart<R, E, A>(environment: Environment<R>, effect: IO<R, E, A>, parent: Maybe<Fiber.Runtime<E, A>>, fiber: Fiber.Runtime<E, A>): void;
     unsafeOnEnd<E, A>(value: Exit<E, A>, fiber: Fiber.Runtime<E, A>): void;
@@ -34,3 +45,20 @@ export declare class ProxySupervisor<A> extends Supervisor<A> {
     unsafeOnSuspend<E, A>(fiber: Fiber.Runtime<E, A>): void;
     unsafeOnResume<E, A>(fiber: Fiber.Runtime<E, A>): void;
 }
+export declare class Zip<A, B> extends Supervisor<readonly [A, B]> {
+    readonly first: Supervisor<A>;
+    readonly second: Supervisor<B>;
+    readonly _tag = SupervisorTag.Zip;
+    constructor(first: Supervisor<A>, second: Supervisor<B>);
+    value: import("../IO").IO<never, never, readonly [A, B]>;
+    unsafeOnStart<R, E, A>(environment: Environment<R>, effect: IO<R, E, A>, parent: Maybe<Fiber.Runtime<any, any>>, fiber: Fiber.Runtime<E, A>): void;
+    unsafeOnEnd<E, A>(value: Exit<E, A>, fiber: Fiber.Runtime<E, A>): void;
+    unsafeOnEffect<E, A>(fiber: Fiber.Runtime<E, A>, effect: IO<any, any, any>): void;
+    unsafeOnSuspend<E, A>(fiber: Fiber.Runtime<E, A>): void;
+    unsafeOnResume<E, A>(fiber: Fiber.Runtime<E, A>): void;
+}
+export type Concrete = ConstSupervisor<any> | ProxySupervisor<any> | Zip<any, any>;
+/**
+ * @tsplus macro remove
+ */
+export declare function concrete(_: Supervisor<any>): asserts _ is Concrete;

package/SupervisorPatch.d.ts

@@ -0,0 +1,61 @@
+import { Supervisor } from "@fncts/io/Supervisor/definition";
+import { List } from "@fncts/base/collection/immutable/List/definition";
+export declare const SupervisorPatchTypeId: unique symbol;
+export type SupervisorPatchTypeId = typeof SupervisorPatchTypeId;
+export declare const enum SupervisorPatchTag {
+    AddSupervisor = 0,
+    Combine = 1,
+    Empty = 2,
+    RemoveSupervisor = 3
+}
+/**
+ * @tsplus type fncts.io.SupervisorPatch
+ * @tsplus companion fncts.io.SupervisorPatchOps
+ */
+export declare abstract class SupervisorPatch {
+    readonly _typeId: SupervisorPatchTypeId;
+}
+export declare class AddSupervisor extends SupervisorPatch {
+    readonly supervisor: Supervisor<any>;
+    readonly _tag = SupervisorPatchTag.AddSupervisor;
+    constructor(supervisor: Supervisor<any>);
+}
+export declare class Combine extends SupervisorPatch {
+    readonly first: SupervisorPatch;
+    readonly second: SupervisorPatch;
+    readonly _tag = SupervisorPatchTag.Combine;
+    constructor(first: SupervisorPatch, second: SupervisorPatch);
+}
+export declare class Empty extends SupervisorPatch {
+    readonly _tag = SupervisorPatchTag.Empty;
+}
+export declare class RemoveSupervisor extends SupervisorPatch {
+    readonly supervisor: Supervisor<any>;
+    readonly _tag = SupervisorPatchTag.RemoveSupervisor;
+    constructor(supervisor: Supervisor<any>);
+}
+export type Concrete = AddSupervisor | Combine | Empty | RemoveSupervisor;
+/**
+ * @tsplus macro remove
+ */
+export declare function concrete(_: SupervisorPatch): asserts _ is Concrete;
+/**
+ * @tsplus static fncts.io.SupervisorPatchOps empty
+ * @tsplus location "@fncts/io/SupervisorPatch"
+ */
+export declare const empty: SupervisorPatch;
+/**
+ * @tsplus fluent fncts.io.SupervisorPatch combine
+ * @tsplus location "@fncts/io/SupervisorPatch"
+ */
+export declare function combine(first: SupervisorPatch, second: SupervisorPatch): SupervisorPatch;
+/**
+ * @tsplus static fncts.io.SupervisorPatchOps diff
+ * @tsplus location "@fncts/io/SupervisorPatch"
+ */
+export declare function diff(oldValue: Supervisor<any>, newValue: Supervisor<any>): SupervisorPatch;
+/**
+ * @tsplus fluent fncts.io.SupervisorPatch __call
+ * @tsplus location "@fncts/io/SupervisorPatch"
+ */
+export declare function apply(self: SupervisorPatch, supervisor: Supervisor<any>): Supervisor<any>;

package/_cjs/Clock/definition.cjs

@@ -18,10 +18,11 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 class Clock {}
 /**
  * @tsplus static fncts.io.ClockOps Tag
+ * @tsplus implicit
  */
 
 
 exports.Clock = Clock;
-const ClockTag = /*#__PURE__*/tsplus_module_1.makeTag("19435fc3-3855-4914-989b-3d23ff58fa87");
+const ClockTag = /*#__PURE__*/tsplus_module_1.makeTag("fncts.io.Clock");
 exports.ClockTag = ClockTag;
 //# sourceMappingURL=definition.cjs.map

package/_cjs/Clock/definition.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"definition.cjs","mappings":";;;;;;;;;;;;;AAAA;;;;AAIM,MAAgBA,KAAhB,CAAqB;AAK3B;;;;;;AAGO,MAAMC,QAAQ,gBAAGC,+DAAjB","names":["Clock","ClockTag","tsplus_module_1"],"sourceRoot":"","sources":["../../_src/Clock/definition.ts"],"sourcesContent":[null]}
+{"version":3,"file":"definition.cjs","mappings":";;;;;;;;;;;;;AAAA;;;;AAIM,MAAgBA,KAAhB,CAAqB;AAK3B;;;;;;;AAIO,MAAMC,QAAQ,gBAAGC,wBAAW,gBAAX,CAAjB","names":["Clock","ClockTag","tsplus_module_1"],"sourceRoot":"","sources":["../../_src/Clock/definition.ts"],"sourcesContent":[null]}

package/_cjs/Console/definition.cjs

@@ -22,6 +22,6 @@ class Console {}
 
 
 exports.Console = Console;
-const ConsoleTag = /*#__PURE__*/tsplus_module_1.makeTag("d4a1e3a7-acd8-4e99-90cd-6d866a63acff");
+const ConsoleTag = /*#__PURE__*/tsplus_module_1.makeTag("fncts.io.Console");
 exports.ConsoleTag = ConsoleTag;
 //# sourceMappingURL=definition.cjs.map

package/_cjs/Console/definition.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"definition.cjs","mappings":";;;;;;;;;;;;;AAAA;;;;AAIM,MAAgBA,OAAhB,CAAuB;AAM7B;;;;;;AAGO,MAAMC,UAAU,gBAAGC,+DAAnB","names":["Console","ConsoleTag","tsplus_module_1"],"sourceRoot":"","sources":["../../_src/Console/definition.ts"],"sourcesContent":[null]}
+{"version":3,"file":"definition.cjs","mappings":";;;;;;;;;;;;;AAAA;;;;AAIM,MAAgBA,OAAhB,CAAuB;AAM7B;;;;;;AAGO,MAAMC,UAAU,gBAAGC,wBAAa,kBAAb,CAAnB","names":["Console","ConsoleTag","tsplus_module_1"],"sourceRoot":"","sources":["../../_src/Console/definition.ts"],"sourcesContent":[null]}

package/_cjs/Differ/api.cjs

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.environment = environment;
+exports.supervisor = supervisor;
+exports.update = update;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/function/api"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/EnvironmentPatch"));
+
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/SupervisorPatch"));
+
+var _definition = /*#__PURE__*/require("./definition.cjs");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * Constructs a differ that just diffs two values by returning a function that
+ * sets the value to the new value. This differ does not support combining
+ * multiple updates to the value compositionally and should only be used when
+ * there is no compositional way to update them.
+ *
+ * @tsplus static fncts.io.DifferOps update
+ */
+function update() {
+  return new class extends _definition.Differ {
+    constructor() {
+      super(...arguments);
+      this.empty = tsplus_module_1.identity;
+    }
+
+    combine(first, second) {
+      if (first === this.empty) return second;else if (second === this.empty) return first;
+      return tsplus_module_1.compose_(first, second);
+    }
+
+    diff(oldValue, newValue) {
+      if (oldValue === newValue) return this.empty;else return () => newValue;
+    }
+
+    patch(patch) {
+      return patch;
+    }
+
+  }();
+}
+/**
+ * Constructs a differ that knows how to diff `Environment` values.
+ *
+ * @tsplus static fncts.io.DifferOps environment
+ */
+
+
+function environment() {
+  return new class extends _definition.Differ {
+    constructor() {
+      super(...arguments);
+      this.empty = tsplus_module_2.empty();
+    }
+
+    combine(first, second) {
+      return tsplus_module_2.combine(first, second);
+    }
+
+    diff(oldValue, newValue) {
+      return tsplus_module_2.diff(oldValue, newValue);
+    }
+
+    patch(patch) {
+      return oldValue => tsplus_module_2.apply(patch, oldValue);
+    }
+
+  }();
+}
+/**
+ * Constructs a differ that knows how to diff `Supervisor` values.
+ *
+ * @tsplus static fncts.io.DifferOps supervisor
+ */
+
+
+function supervisor() {
+  return new class extends _definition.Differ {
+    constructor() {
+      super(...arguments);
+      this.empty = tsplus_module_3.empty;
+    }
+
+    combine(first, second) {
+      return tsplus_module_3.combine(first, second);
+    }
+
+    diff(oldValue, newValue) {
+      return tsplus_module_3.diff(oldValue, newValue);
+    }
+
+    patch(patch) {
+      return oldValue => tsplus_module_3.apply(patch, oldValue);
+    }
+
+  }();
+}
+//# sourceMappingURL=api.cjs.map

package/_cjs/Differ/api.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.cjs","mappings":";;;;;;;;;;;;;;;AAKA;;;;;;AAEA;;;;;;;;AAQM,SAAUA,MAAV,GAAgB;EACpB,OAAO,IAAK,cAAcC,kBAAd,CAAoC;IAApCC;;MAUV,aAAKC,wBAAL;IAID;;IAbCC,OAAO,CAACC,KAAD,EAAqBC,MAArB,EAAwC;MAC7C,IAAID,KAAK,KAAK,KAAKE,KAAnB,EAA0B,OAAOD,MAAP,CAA1B,KACK,IAAIA,MAAM,KAAK,KAAKC,KAApB,EAA2B,OAAOF,KAAP;MAChC,OAAOF,gCAAcG,MAAd,CAAP;IACD;;IACDE,IAAI,CAACC,QAAD,EAAcC,QAAd,EAAyB;MAC3B,IAAID,QAAQ,KAAKC,QAAjB,EAA2B,OAAO,KAAKH,KAAZ,CAA3B,KACK,OAAO,MAAMG,QAAb;IACN;;IAEDC,KAAK,CAACA,KAAD,EAAmB;MACtB,OAAOA,KAAP;IACD;;EAb6C,CAAzC,EAAP;AAeD;AAED;;;;;;;AAKM,SAAUC,WAAV,GAAqB;EACzB,OAAO,IAAK,cAAcX,kBAAd,CAA6D;IAA7DC;;MAOV,aAAQW,uBAAR;IAID;;IAVCT,OAAO,CAACC,KAAD,EAAiCC,MAAjC,EAAgE;MACrE,OAAOO,+BAAcP,MAAd,CAAP;IACD;;IACDE,IAAI,CAACC,QAAD,EAA2BC,QAA3B,EAAmD;MACrD,OAAOG,qBAAsBJ,QAAtB,EAAgCC,QAAhC,CAAP;IACD;;IAEDC,KAAK,CAACA,KAAD,EAA+B;MAClC,OAAQF,QAAD,IAAcI,6BAAMJ,QAAN,CAArB;IACD;;EAVsE,CAAlE,EAAP;AAYD;AAED;;;;;;;AAKM,SAAUK,UAAV,GAAoB;EACxB,OAAO,IAAK,cAAcb,kBAAd,CAAuD;IAAvDC;;MAOV,aAAKa,qBAAL;IAID;;IAVCX,OAAO,CAACC,KAAD,EAAyBC,MAAzB,EAAgD;MACrD,OAAOS,+BAAcT,MAAd,CAAP;IACD;;IACDE,IAAI,CAACC,QAAD,EAA4BC,QAA5B,EAAqD;MACvD,OAAOK,qBAAqBN,QAArB,EAA+BC,QAA/B,CAAP;IACD;;IAEDC,KAAK,CAACA,KAAD,EAAuB;MAC1B,OAAQF,QAAD,IAAcM,6BAAMN,QAAN,CAArB;IACD;;EAVgE,CAA5D,EAAP;AAYD","names":["update","Differ","constructor","tsplus_module_1","combine","first","second","empty","diff","oldValue","newValue","patch","environment","tsplus_module_2","supervisor","tsplus_module_3"],"sourceRoot":"","sources":["../../_src/Differ/api.ts"],"sourcesContent":[null]}

package/_cjs/Differ/definition.cjs

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DifferTypeId = exports.Differ = void 0;
+const DifferTypeId = /*#__PURE__*/Symbol.for("fncts.io.Differ");
+/**
+ * @tsplus type fncts.io.Differ
+ * @tsplus companion fncts.io.DifferOps
+ */
+
+exports.DifferTypeId = DifferTypeId;
+
+class Differ {
+  constructor() {
+    this._typeId = DifferTypeId;
+  }
+
+}
+
+exports.Differ = Differ;
+//# sourceMappingURL=definition.cjs.map

package/_cjs/Differ/definition.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.cjs","mappings":";;;;;;AAAO,MAAMA,YAAY,gBAAGC,MAAM,CAACC,GAAP,CAAW,iBAAX,CAArB;AAGP;;;;;;;AAIM,MAAgBC,MAAhB,CAAsB;EAA5BC;IACW,eAAwBJ,YAAxB;EAOV;;AAR2B","names":["DifferTypeId","Symbol","for","Differ","constructor"],"sourceRoot":"","sources":["../../_src/Differ/definition.ts"],"sourcesContent":[null]}