@fncts/io 0.0.1

package/TFuture/api.d.ts

@@ -0,0 +1,29 @@
+import { TFuture } from "@fncts/io/TFuture/definition";
+import { Either } from "@fncts/base/data/Either";
+import { USTM, STM } from "@fncts/io/STM/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+/**
+ * @tsplus fluent fncts.io.TFuture done
+ * @tsplus location "@fncts/io/TFuture/api"
+ */
+export declare function done_<E, A>(self: TFuture<E, A>, v: Either<E, A>): USTM<boolean>;
+/**
+ * @tsplus fluent fncts.io.TFuture fail
+ * @tsplus location "@fncts/io/TFuture/api"
+ */
+export declare function fail_<E, A>(self: TFuture<E, A>, e: E): USTM<boolean>;
+/**
+ * @tsplus getter fncts.io.TFuture poll
+ * @tsplus location "@fncts/io/TFuture/api"
+ */
+export declare function poll<E, A>(self: TFuture<E, A>): USTM<Maybe<Either<E, A>>>;
+/**
+ * @tsplus fluent fncts.io.TFuture succeed
+ * @tsplus location "@fncts/io/TFuture/api"
+ */
+export declare function succeed_<E, A>(self: TFuture<E, A>, a: A): USTM<boolean>;
+/**
+ * @tsplus getter fncts.io.TFuture await
+ * @tsplus location "@fncts/io/TFuture/api"
+ */
+export declare function wait<E, A>(self: TFuture<E, A>): STM<unknown, E, A>;

package/TFuture/constructors.d.ts

@@ -0,0 +1,16 @@
+import { USTM } from "@fncts/io/STM/definition";
+import { TFuture } from "@fncts/io/TFuture/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Either } from "@fncts/base/data/Either";
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus static fncts.io.TFutureOps make
+ * @tsplus static fncts.io.TFutureOps __call
+ * @tsplus location "@fncts/io/TFuture/constructors"
+ */
+export declare function make<E, A>(): USTM<TFuture<E, A>>;
+/**
+ * @tsplus static fncts.io.TFutureOps makeCommit
+ * @tsplus location "@fncts/io/TFuture/constructors"
+ */
+export declare function makeCommit<E, A>(): UIO<TFuture<E, A>>;

package/TFuture/definition.d.ts

@@ -0,0 +1,22 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Either } from "@fncts/base/data/Either";
+import type { UTRef } from "../TRef.js";
+interface TFutureN extends HKT {
+    readonly type: TFuture<this["E"], this["A"]>;
+}
+/**
+ * @tsplus type fncts.io.TFuture
+ */
+export interface TFuture<E, A> extends Newtype<{
+    readonly TFuture: unique symbol;
+}, UTRef<Maybe<Either<E, A>>>> {
+}
+/**
+ * @tsplus type fncts.io.TFutureOps
+ */
+export interface TFutureOps extends NewtypeIso<TFutureN> {
+}
+export declare const TFuture: TFutureOps;
+export {};

package/TFuture.d.ts

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

package/TRef/api.d.ts

@@ -0,0 +1,85 @@
+import { STM } from "@fncts/io/STM/definition";
+import { Either } from "@fncts/base/data/Either";
+import { Maybe } from "@fncts/base/data/Maybe";
+import type { Journal } from "../STM/internal/Journal.js";
+import type { TRef } from "../TRef/definition.js";
+/**
+ * Retrieves the value of the `TRef`.
+ * @tsplus getter fncts.io.TRef get
+ * @tsplus location "@fncts/io/TRef/api"
+ */
+export declare function get<EA, EB, A, B>(self: TRef<EA, EB, A, B>): STM<unknown, EB, B>;
+/**
+ * Updates the value of the variable, returning a function of the specified
+ * value.
+ * @tsplus fluent fncts.io.TRef modify
+ * @tsplus location "@fncts/io/TRef/api"
+ */
+export declare function modify_<E, A, B>(self: TRef<E, E, A, A>, f: (a: A) => readonly [B, A]): STM<unknown, E, B>;
+/**
+ * Sets the value of the `TRef`.
+ * @tsplus fluent fncts.io.TRef set
+ * @tsplus location "@fncts/io/TRef/api"
+ */
+export declare function set_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, a: A): STM<unknown, EA, void>;
+/**
+ * Unsafely retrieves the value of the `TRef`.
+ * @tsplus fluent fncts.io.TRef unsafeGet
+ * @tsplus location "@fncts/io/TRef/api"
+ */
+export declare function unsafeGet_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, journal: Journal): A;
+/**
+ * Updates the value of the variable, returning a function of the specified
+ * value.
+ * @tsplus fluent fncts.io.TRef modifyJust
+ * @tsplus location "@fncts/io/TRef/api"
+ */
+export declare function modifyJust_<E, A, B>(self: TRef<E, E, A, A>, b: B, f: (a: A) => Maybe<readonly [B, A]>): STM<unknown, E, B>;
+/**
+ * Sets the value of the `TRef` and returns the old value.
+ * @tsplus fluent fncts.io.TRef getAndSet
+ * @tsplus location "@fncts/io/TRef/api"
+ */
+export declare function getAndSet_<E, A>(self: TRef<E, E, A, A>, a: A): STM<unknown, E, A>;
+/**
+ * Updates the value of the variable and returns the old value.
+ * @tsplus fluent fncts.io.TRef getAndUpdate
+ * @tsplus location "@fncts/io/TRef/api"
+ */
+export declare function getAndUpdate_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM<unknown, E, A>;
+/**
+ * Updates some values of the variable but leaves others alone, returning the
+ * old value.
+ * @tsplus fluent fncts.io.TRef getAndUpdateJust
+ * @tsplus location "@fncts/io/TRef/api"
+ */
+export declare function getAndUpdateJust_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>): STM<unknown, E, A>;
+/**
+ * Updates the value of the variable.
+ * @tsplus fluent fncts.io.TRef update
+ * @tsplus location "@fncts/io/TRef/api"
+ */
+export declare function update_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM<unknown, E, void>;
+/**
+ * Updates some values of the variable but leaves others alone.
+ * @tsplus fluent fncts.io.TRef updateJust
+ * @tsplus location "@fncts/io/TRef/api"
+ */
+export declare function updateJust_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>): STM<unknown, E, void>;
+/**
+ * Updates the value of the variable and returns the new value.
+ * @tsplus fluent fncts.io.TRef updateAndGet
+ * @tsplus location "@fncts/io/TRef/api"
+ */
+export declare function updateAndGet_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM<unknown, E, A>;
+/**
+ * Updates some values of the variable but leaves others alone.
+ * @tsplus fluent fncts.io.TRef updateJustAndGet
+ * @tsplus location "@fncts/io/TRef/api"
+ */
+export declare function updateJustAndGet_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>): STM<unknown, E, A>;
+/**
+ * @tsplus fluent fncts.io.TRef unsafeSet
+ * @tsplus location "@fncts/io/TRef/api"
+ */
+export declare function unsafeSet_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, journal: Journal, a: A): void;

package/TRef/constructors.d.ts

@@ -0,0 +1,32 @@
+import { STM } from "@fncts/io/STM/definition";
+import { Lazy } from "@fncts/base/data/function";
+import { UIO } from "@fncts/io/IO/definition";
+import type { UTRef } from "./definition.js";
+/**
+ * Makes a new `TRef` that is initialized to the specified value.
+ * @tsplus static fncts.io.TRefOps makeNow
+ * @tsplus location "@fncts/io/TRef/constructors"
+ */
+export declare function makeNow<A>(a: A): STM<unknown, never, UTRef<A>>;
+/**
+ * Makes a new `TRef` that is initialized to the specified value.
+ * @tsplus static fncts.io.TRefOps make
+ * @tsplus location "@fncts/io/TRef/constructors"
+ */
+export declare function make<A>(a: Lazy<A>): STM<unknown, never, UTRef<A>>;
+/**
+ * Unsafely makes a new `TRef` that is initialized to the specified value.
+ * @tsplus static fncts.io.TRefOps unsafeMake
+ * @tsplus location "@fncts/io/TRef/constructors"
+ */
+export declare function unsafeMake<A>(a: A): UTRef<A>;
+/**
+ * Makes a new `TRef` that is initialized to the specified value.
+ * @tsplus static fncts.io.TRefOps makeCommit
+ * @tsplus location "@fncts/io/TRef/constructors"
+ */
+export declare function makeCommit<A>(a: Lazy<A>): UIO<UTRef<A>>;
+/**
+ * Makes a new `TRef` that is initialized to the specified value.
+ */
+export declare function makeCommitNow<A>(a: A): UIO<UTRef<A>>;

package/TRef/definition.d.ts

@@ -0,0 +1,87 @@
+import { Either } from "@fncts/base/data/Either";
+import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import type { Todo } from "../STM/internal/Journal.js";
+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;
+/**
+ * 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
+ * fundamental operations of a `TRef` are `set` and `get`. `set` takes a value
+ * of type `A` and transactionally sets the reference to a new value, potentially
+ * failing with an error of type `EA`. `get` gets the current value of the reference
+ * and returns a value of type `B`, potentially failing with an error of type `EB`.
+ *
+ * When the error and value types of the `TRef` are unified, that is, it is a
+ * `TRef<E, E, A, A>`, the `TRef` also supports atomic `modify` and `update`
+ * operations. All operations are guaranteed to be executed transactionally.
+ *
+ * NOTE: While `TRef` provides the transactional equivalent of a mutable reference,
+ * the value inside the `TRef` should be immutable.
+ *
+ * @tsplus type fncts.io.TRef
+ */
+export interface TRef<EA, EB, A, B> {
+    readonly _typeId: TRefTypeId;
+    readonly _EA: () => EA;
+    readonly _EB: () => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: () => B;
+}
+/**
+ * @tsplus type fncts.io.TRefOps
+ */
+export interface TRefOps {
+}
+export declare const TRef: TRefOps;
+export declare abstract class TRefInternal<EA, EB, A, B> implements TRef<EA, EB, A, B> {
+    readonly _typeId: TRefTypeId;
+    readonly _EA: () => EA;
+    readonly _EB: () => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: () => B;
+    abstract match<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ca: (c: C) => Either<EC, A>, bd: (b: B) => Either<ED, D>): TRef<EC, ED, C, D>;
+    abstract matchAll<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ec: (ea: EB) => EC, ca: (c: C) => (b: B) => Either<EC, A>, bd: (b: B) => Either<ED, D>): TRef<EC, ED, C, D>;
+}
+/**
+ * @tsplus type fncts.io.TRef
+ */
+export interface UTRef<A> extends TRef<never, never, A, A> {
+}
+/**
+ * @tsplus type fncts.io.TRef
+ */
+export interface ETRef<E, A> extends TRef<E, E, A, A> {
+}
+export declare class Atomic<A> extends TRefInternal<never, never, A, A> {
+    versioned: Versioned<A>;
+    readonly todo: AtomicReference<HashMap<TxnId, Todo>>;
+    readonly _typeId: TRefTypeId;
+    readonly _tag = "Atomic";
+    readonly atomic: Atomic<unknown>;
+    constructor(versioned: Versioned<A>, todo: AtomicReference<HashMap<TxnId, Todo>>);
+    match<EC, ED, C, D>(_ea: (ea: never) => EC, _eb: (ea: never) => ED, ca: (c: C) => Either<EC, A>, bd: (b: A) => Either<ED, D>): TRef<EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(_ea: (ea: never) => EC, _eb: (ea: never) => ED, _ec: (ea: never) => EC, ca: (c: C) => (b: A) => Either<EC, A>, bd: (b: A) => Either<ED, D>): TRef<EC, ED, C, D>;
+}
+export declare class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
+    readonly use: <X>(f: <S>(getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>, value: Atomic<S>, atomic: Atomic<unknown>) => X) => X;
+    readonly _typeId: TRefTypeId;
+    readonly _tag = "Derived";
+    constructor(use: <X>(f: <S>(getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>, value: Atomic<S>, atomic: Atomic<unknown>) => X) => X);
+    match<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ca: (c: C) => Either<EC, A>, bd: (b: B) => Either<ED, D>): TRef<EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ec: (ea: EB) => EC, ca: (c: C) => (b: B) => Either<EC, A>, bd: (b: B) => Either<ED, D>): TRef<EC, ED, C, D>;
+}
+export declare class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
+    readonly use: <X>(f: <S>(getEither: (s: S) => Either<EB, B>, setEither: (a: A) => (s: S) => Either<EA, S>, value: Atomic<S>, atomic: Atomic<unknown>) => X) => X;
+    readonly _typeId: TRefTypeId;
+    readonly _tag = "DerivedAll";
+    constructor(use: <X>(f: <S>(getEither: (s: S) => Either<EB, B>, setEither: (a: A) => (s: S) => Either<EA, S>, value: Atomic<S>, atomic: Atomic<unknown>) => X) => X);
+    match<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ca: (c: C) => Either<EC, A>, bd: (b: B) => Either<ED, D>): TRef<EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ec: (ea: EB) => EC, ca: (c: C) => (b: B) => Either<EC, A>, bd: (b: B) => Either<ED, D>): TRef<EC, ED, C, D>;
+}
+/**
+ * @tsplus macro remove
+ */
+export declare function concrete<EA, EB, A, B>(_: TRef<EA, EB, A, B>): asserts _ is (Atomic<A> & Atomic<B>) | Derived<EA, EB, A, B> | DerivedAll<EA, EB, A, B>;

package/TRef.d.ts

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

package/TSemaphore/api.d.ts

@@ -0,0 +1,38 @@
+import { TSemaphore } from "@fncts/io/TSemaphore/definition";
+import { USTM } from "@fncts/io/STM/definition";
+import { IO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus getter fncts.io.TSemaphore acquire
+ * @tsplus location "@fncts/io/TSemaphore/api"
+ */
+export declare function acquire(self: TSemaphore): USTM<void>;
+/**
+ * @tsplus fluent fncts.io.TSemaphore acquireN
+ * @tsplus location "@fncts/io/TSemaphore/api"
+ */
+export declare function acquireN_(self: TSemaphore, n: number): USTM<void>;
+/**
+ * @tsplus getter fncts.io.TSemaphore available
+ * @tsplus location "@fncts/io/TSemaphore/api"
+ */
+export declare function available(self: TSemaphore): USTM<number>;
+/**
+ * @tsplus getter fncts.io.TSemaphore release
+ * @tsplus location "@fncts/io/TSemaphore/api"
+ */
+export declare function release(self: TSemaphore): USTM<void>;
+/**
+ * @tsplus fluent fncts.io.TSemaphore releaseN
+ * @tsplus location "@fncts/io/TSemaphore/api"
+ */
+export declare function releaseN_(self: TSemaphore, n: number): USTM<void>;
+/**
+ * @tsplus getter fncts.io.TSemaphore withPermits
+ * @tsplus location "@fncts/io/TSemaphore/api"
+ */
+export declare function withPermitsSelf(self: TSemaphore): (n: number) => <R, E, A>(io: import("../IO.js").IO<R, E, A>) => import("../IO.js").IO<R, E, A>;
+/**
+ * @tsplus getter fncts.io.TSemaphore withPermit
+ * @tsplus location "@fncts/io/TSemaphore/api"
+ */
+export declare function withPermitSelf(self: TSemaphore): <R, E, A>(io: import("../IO.js").IO<R, E, A>) => import("../IO.js").IO<R, E, A>;

package/TSemaphore/constructors.d.ts

@@ -0,0 +1,13 @@
+import { USTM } from "@fncts/io/STM/definition";
+import { TSemaphore } from "@fncts/io/TSemaphore/definition";
+/**
+ * @tsplus static fncts.io.TSemaphoreOps __call
+ * @tsplus static fncts.io.TSemaphoreOps make
+ * @tsplus location "@fncts/io/TSemaphore/constructors"
+ */
+export declare function make(permits: number): USTM<TSemaphore>;
+/**
+ * @tsplus static fncts.io.TSemaphoreOps unsafeMake
+ * @tsplus location "@fncts/io/TSemaphore/constructors"
+ */
+export declare function unsafeMake(permits: number): TSemaphore;

package/TSemaphore/definition.d.ts

@@ -0,0 +1,20 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
+import { UTRef } from "@fncts/io/TRef/definition";
+interface TSemaphoreN extends HKT {
+    readonly type: TSemaphore;
+}
+/**
+ * @tsplus type fncts.io.TSemaphore
+ */
+export interface TSemaphore extends Newtype<{
+    readonly TSemaphore: unique symbol;
+}, UTRef<number>> {
+}
+/**
+ * @tsplus type fncts.io.TSemaphoreOps
+ */
+export interface TSemaphoreOps extends NewtypeIso<TSemaphoreN> {
+}
+export declare const TSemaphore: TSemaphoreOps;
+export {};

package/TSemaphore.d.ts

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

package/TxnId.d.ts

@@ -0,0 +1,12 @@
+export declare type TxnId = number;
+/**
+ * @tsplus type fncts.TxnIdOps
+ */
+export interface TxnIdOps {
+}
+export declare const TxnId: TxnIdOps;
+/**
+ * @tsplus static fncts.TxnIdOps make
+ * @tsplus location "@fncts/io/TxnId"
+ */
+export declare function make(): TxnId;

package/_cjs/Cached/api.cjs

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.auto = auto;
+exports.get_ = get_;
+exports.refresh_ = exports.manual = void 0;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/core-scope"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/schedule"));
+
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/interrupt"));
+
+var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Fiber/api/interrupt"));
+
+var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/acquireRelease"));
+
+var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api"));
+
+var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/environment"));
+
+var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/ScopedRef/api"));
+
+var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Exit/constructors"));
+
+var _definition = /*#__PURE__*/require("@fncts/io/Cached/definition");
+
+var _internal = /*#__PURE__*/require("@fncts/io/Cached/internal");
+
+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; }
+
+const fileName_1 = "(@fncts/io) src/Cached/api.ts";
+const manual = manual_1;
+exports.manual = manual;
+const refresh_ = refresh_1;
+exports.refresh_ = refresh_;
+
+/**
+ * @tsplus static fncts.io.CachedOps auto
+ */
+function auto(acquire, policy, __tsplusTrace) {
+  return tsplus_module_6.flatMap_(manual_1(acquire), manual => tsplus_module_6.map_(tsplus_module_5.acquireRelease(() => tsplus_module_1.forkDaemon(tsplus_module_3.interruptible(tsplus_module_2.schedule(refresh_1(manual), () => policy, __tsplusTrace), __tsplusTrace)), fiber => tsplus_module_4.interrupt(fiber)), () => manual), __tsplusTrace);
+}
+/**
+ * @tsplus getter fncts.io.Cached get
+ */
+
+
+function get_(self, __tsplusTrace) {
+  void 0;
+  return self.get;
+}
+/**
+ * @tsplus static fncts.io.CachedOps manual
+ */
+
+
+function manual_1(acquire) {
+  return tsplus_module_6.flatMap_(tsplus_module_7.environment(fileName_1 + ":34:33"), env => tsplus_module_6.map_(tsplus_module_8.fromAcquire(tsplus_module_6.result(acquire), fileName_1 + ":35:40"), ref => new Manual(ref, tsplus_module_7.provideEnvironment_(acquire, env, fileName_1 + ":36:54")), fileName_1 + ":35:18"), fileName_1 + ":34:18");
+}
+
+class Manual extends _internal.CachedInternal {
+  constructor(ref, acquire) {
+    super();
+    this.ref = ref;
+    this.acquire = acquire;
+    this.get = tsplus_module_6.flatMap_(this.ref.get, tsplus_module_6.fromExitNow, fileName_1 + ":44:51");
+    this.refresh = this.ref.set(tsplus_module_6.map_(this.acquire, tsplus_module_9.succeed, fileName_1 + ":45:60"), fileName_1 + ":45:43");
+  }
+
+}
+/**
+ * @tsplus getter fncts.io.Cached refresh
+ */
+
+
+function refresh_1(self, __tsplusTrace) {
+  void 0;
+  return self.refresh;
+}
+//# sourceMappingURL=api.cjs.map

package/_cjs/Cached/api.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.cjs","mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;;;;;;MA4BgBA,MAAM;;MAqBNC,QAAQ;;;AA/CxB;;;AAGM,SAAUC,IAAV,CACJC,OADI,EAEJC,MAFI,EAGJC,aAHI,EAGkB;EAEtB,gCACmBC,SAAcH,OAAd,CADnB,EACQH,MAAM,yBACVO,gEAAkBC,8BAAiBC,4CAAM,MAAkBL,MAAxB,EAJvCC,aAIuC,CAAjB,EAJtBA,aAIsB,CAAlB,GAAiFK,KAAD,IAAUC,0BAACD,KAAD,CAA1F,CADU,EACiG,MACtGV,MAFK,CADd,EAFAK,aAEA;AAKD;AAED;;;;;AAGM,SAAUO,IAAV,CAAgCC,IAAhC,EAA+DR,aAA/D,EAAqF;EACzF;EACA,OAAOQ,IAAI,CAACC,GAAZ;AACD;AAED;;;;;AAGA,kBACEX,OADF,EACiC;EAE/B,gCACgBY,kDADhB,EACQC,GAAG,yBACKC,mDAAsBd,OAAtB,GAA6Be,qBAA7B,CADL,EACHC,GAAG,IACF,IAAIC,MAAJ,CAAWD,GAAX,EAAgBJ,6CAA2BC,GAA3B,EAA8BE,qBAA9B,CAAhB,CAFE,EAE8CA,qBAF9C,CADX,EAGyDA,qBAHzD;AAKD;;AAED,MAAME,MAAN,SAAsCC,wBAAtC,CAAqE;EACnEC,YAAqBH,GAArB,EAAqEhB,OAArE,EAA6G;IAC3G;IADmB;IAAgD;IAGrE,WAA4BoB,8BAAKJ,GAAL,CAASL,GAAT,EAAYS,2BAAZ,EAAYL,qBAAZ,CAA5B;IACA,eAA4B,KAAKC,GAAL,CAASK,GAAT,CAAaD,0BAAKpB,OAAL,EAAYsB,uBAAZ,EAAYP,qBAAZ,CAAb,EAA2CA,qBAA3C,CAA5B;EAFC;;AAHkE;AAQrE;;;;;AAGA,mBAA0CL,IAA1C,EAAyER,aAAzE,EAA+F;EAC7F;EACA,OAAOQ,IAAI,CAACa,OAAZ;AACD","names":["manual","refresh_","auto","acquire","policy","__tsplusTrace","manual_1","tsplus_module_5","tsplus_module_3","tsplus_module_2","fiber","tsplus_module_4","get_","self","get","tsplus_module_7","env","tsplus_module_8","fileName_1","ref","Manual","CachedInternal","constructor","tsplus_module_6","set","tsplus_module_9","refresh"],"sourceRoot":"","sources":["../../_src/Cached/api.ts"],"sourcesContent":[null]}

package/_cjs/Cached/definition.cjs

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Cached = void 0;
+exports.concrete = concrete;
+
+var _internal = /*#__PURE__*/require("@fncts/io/Cached/internal");
+
+/**
+ * A Cached is a possibly resourceful value that is loaded into memory, and
+ * which can be refreshed either manually or automatically
+ *
+ * @tsplus type fncts.io.Cached
+ * @tsplus companion fncts.io.CachedOps
+ */
+class Cached {
+  constructor() {
+    this._typeId = _internal.CachedTypeId;
+  }
+
+}
+/**
+ * @tsplus macro remove
+ */
+
+
+exports.Cached = Cached;
+
+function concrete(_) {//
+}
+//# sourceMappingURL=definition.cjs.map

package/_cjs/Cached/definition.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.cjs","mappings":";;;;;;;;AAEA;;AAEA;;;;;;;AAOM,MAAOA,MAAP,CAAa;EAAnBC;IAGW,eAAwBC,sBAAxB;EACV;;AAJkB;AAMnB;;;;;;;AAGM,SAAUC,QAAV,CAAyBC,CAAzB,EAAwC,CAC5C;AACD","names":["Cached","constructor","CachedTypeId","concrete","_"],"sourceRoot":"","sources":["../../_src/Cached/definition.ts"],"sourcesContent":[null]}

package/_cjs/Cached/internal.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CachedTypeId = exports.CachedInternal = void 0;
+const CachedTypeId = /*#__PURE__*/Symbol.for("fncts.io.Cached");
+exports.CachedTypeId = CachedTypeId;
+
+class CachedInternal {
+  constructor() {
+    this._typeId = CachedTypeId;
+  }
+
+}
+
+exports.CachedInternal = CachedInternal;
+//# sourceMappingURL=internal.cjs.map

package/_cjs/Cached/internal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.cjs","mappings":";;;;;;AAAO,MAAMA,YAAY,gBAAGC,MAAM,CAACC,GAAP,CAAW,iBAAX,CAArB;;;AAGD,MAAgBC,cAAhB,CAA8B;EAApCC;IAGW,eAAwBJ,YAAxB;EAGV;;AANmC","names":["CachedTypeId","Symbol","for","CachedInternal","constructor"],"sourceRoot":"","sources":["../../_src/Cached/internal.ts"],"sourcesContent":[null]}

package/_cjs/Cached.cjs

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _api = /*#__PURE__*/require("./Cached/api.js");
+
+Object.keys(_api).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _api[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _api[key];
+    }
+  });
+});
+
+var _definition = /*#__PURE__*/require("./Cached/definition.js");
+
+Object.keys(_definition).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _definition[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _definition[key];
+    }
+  });
+});
+
+var _internal = /*#__PURE__*/require("./Cached/internal.js");
+
+Object.keys(_internal).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _internal[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _internal[key];
+    }
+  });
+});
+//# sourceMappingURL=Cached.cjs.map

package/_cjs/Cached.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cached.cjs","mappings":";;;;;;AACA;;AAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AACA;;AAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AACA;;AAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA","names":[],"sourceRoot":"","sources":["../_src/Cached.ts"],"sourcesContent":[null]}

package/_cjs/CancellerState.cjs

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pending = exports.empty = exports.Registered = exports.Pending = exports.Empty = exports.CancellerState = void 0;
+exports.registered = registered;
+
+class Empty {
+  constructor() {
+    this._tag = "Empty"
+    /* CancellerStateTag.Empty */
+    ;
+  }
+
+}
+
+exports.Empty = Empty;
+
+class Pending {
+  constructor() {
+    this._tag = "Pending"
+    /* CancellerStateTag.Pending */
+    ;
+  }
+
+}
+
+exports.Pending = Pending;
+
+class Registered {
+  constructor(asyncCanceller) {
+    this.asyncCanceller = asyncCanceller;
+    this._tag = "Registered"
+    /* CancellerStateTag.Registered */
+    ;
+  }
+
+}
+
+exports.Registered = Registered;
+const CancellerState = {};
+/**
+ * @tsplus static fncts.CancellerStateOps empty
+ */
+
+exports.CancellerState = CancellerState;
+const empty = /*#__PURE__*/new Empty();
+/**
+ * @tsplus static fncts.CancellerStateOps pending
+ */
+
+exports.empty = empty;
+const pending = /*#__PURE__*/new Pending();
+/**
+ * @tsplus static fncts.CancellerStateOps registered
+ */
+
+exports.pending = pending;
+
+function registered(asyncCanceller) {
+  return new Registered(asyncCanceller);
+}
+//# sourceMappingURL=CancellerState.cjs.map

package/_cjs/CancellerState.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CancellerState.cjs","mappings":";;;;;;;;AAMM,MAAOA,KAAP,CAAY;EAAlBC;IACW,YAAI;IAAA;IAAJ;EACV;;AAFiB;;;;AAIZ,MAAOC,OAAP,CAAc;EAApBD;IACW,YAAI;IAAA;IAAJ;EACV;;AAFmB;;;;AAId,MAAOE,UAAP,CAAiB;EAErBF,YAAqBG,cAArB,EAAsD;IAAjC;IADZ,YAAI;IAAA;IAAJ;EACiD;;AAFrC;;;AAehB,MAAMC,cAAc,GAAsB,EAA1C;AAEP;;;;;AAGO,MAAMC,KAAK,gBAAG,IAAIN,KAAJ,EAAd;AAEP;;;;;AAGO,MAAMO,OAAO,gBAAG,IAAIL,OAAJ,EAAhB;AAEP;;;;;;AAGM,SAAUM,UAAV,CAAqBJ,cAArB,EAAsD;EAC1D,OAAO,IAAID,UAAJ,CAAeC,cAAf,CAAP;AACD","names":["Empty","constructor","Pending","Registered","asyncCanceller","CancellerState","empty","pending","registered"],"sourceRoot":"","sources":["../_src/CancellerState.ts"],"sourcesContent":[null]}