@typed/fx 1.31.0 → 2.0.0-beta.0

package/dist/Sink/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./combinators.js";
+export * from "./Sink.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/Sink/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Sink/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC"}

package/dist/Sink/index.js

@@ -0,0 +1,2 @@
+export * from "./combinators.js";
+export * from "./Sink.js";

package/dist/Sink.d.ts

@@ -0,0 +1,2 @@
+export * from "./Sink/index.js";
+//# sourceMappingURL=Sink.d.ts.map

package/dist/Sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sink.d.ts","sourceRoot":"","sources":["../src/Sink.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

package/dist/Sink.js

@@ -0,0 +1 @@
+export * from "./Sink/index.js";

package/dist/Subject/Subject.d.ts

@@ -0,0 +1,152 @@
+import type * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Layer from "effect/Layer";
+import * as MutableRef from "effect/MutableRef";
+import * as Option from "effect/Option";
+import * as Scope from "effect/Scope";
+import * as ServiceMap from "effect/ServiceMap";
+import type * as Fx from "../Fx/index.js";
+import { RingBuffer } from "../Fx/internal/ring-buffer.js";
+import { FxTypeId } from "../Fx/TypeId.js";
+import type * as Sink from "../Sink/Sink.js";
+/**
+ * A `Subject` is an `Fx` that allows for imperative pushing of values.
+ * It also acts as a `Sink`, meaning you can `run` another `Fx` into it.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Subject<A, E = never, R = never> extends Fx.Fx<A, E, R | Scope.Scope>, Sink.Sink<A, E, R> {
+    /**
+     * The number of current subscribers to this Subject.
+     */
+    readonly subscriberCount: Effect.Effect<number, never, R>;
+    /**
+     * Interrupts all subscribers and clears the subject.
+     */
+    readonly interrupt: Effect.Effect<void, never, R>;
+}
+export declare namespace Subject {
+    interface Service<Self, Id extends string, A, E> extends Subject<A, E, Self> {
+        readonly id: Id;
+        readonly service: ServiceMap.Service<Self, Subject<A, E>>;
+        readonly make: (replay?: number) => Layer.Layer<Self, never, Scope.Scope>;
+    }
+    interface Class<Self, Id extends string, A, E> extends Service<Self, Id, A, E> {
+        new (): Service<Self, Id, A, E>;
+    }
+}
+/**
+ * Shares the execution of an Fx among multiple subscribers using a Subject.
+ * The source Fx is started when the first subscriber arrives and stopped when the last one leaves.
+ *
+ * @param fx - The source Fx.
+ * @param subject - The subject to use for multicasting.
+ * @returns A shared `Fx`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function share<A, E, R, R2>(fx: Fx.Fx<A, E, R>, subject: Subject<A, E, R2>): Fx.Fx<A, E, R | R2 | Scope.Scope>;
+declare class RefCounter {
+    _RefCount: MutableRef.MutableRef<number>;
+    increment(): number;
+    decrement(): number;
+}
+export declare class Share<A, E, R, R2> implements Fx.Fx<A, E, R | R2 | Scope.Scope> {
+    readonly [FxTypeId]: Fx.Fx.Variance<A, E, R | R2 | Scope.Scope>;
+    _FxFiber: MutableRef.MutableRef<Option.Option<Fiber.Fiber<unknown>>>;
+    _RefCount: RefCounter;
+    readonly i0: Fx.Fx<A, E, R>;
+    readonly i1: Subject<A, E, R2>;
+    constructor(i0: Fx.Fx<A, E, R>, i1: Subject<A, E, R2>);
+    pipe(): unknown;
+    run<R3>(sink: Sink.Sink<A, E, R3>): Effect.Effect<unknown, never, R | R2 | R3 | Scope.Scope>;
+    private initialize;
+    private interrupt;
+}
+/**
+ * Multicasts an Fx to multiple subscribers.
+ * The source Fx is shared, so side effects only happen once per active session (ref count > 0).
+ *
+ * @param fx - The source Fx.
+ * @returns A multicasted `Fx`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function multicast<A, E, R>(fx: Fx.Fx<A, E, R>): Fx.Fx<A, E, R | Scope.Scope>;
+/**
+ * Holds the latest value emitted by the Fx and replays it to new subscribers.
+ *
+ * @param fx - The source Fx.
+ * @returns A shared `Fx` that replays the latest value.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function hold<A, E, R>(fx: Fx.Fx<A, E, R>): Fx.Fx<A, E, R | Scope.Scope>;
+/**
+ * Replays the last `capacity` values emitted by the Fx to new subscribers.
+ *
+ * @param capacity - The number of values to buffer and replay.
+ * @param fx - The source Fx.
+ * @returns A shared `Fx` that replays values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const replay: {
+    (capacity: number): <A, E, R>(fx: Fx.Fx<A, E, R>) => Fx.Fx<A, E, R>;
+    <A, E, R>(fx: Fx.Fx<A, E, R>, capacity: number): Fx.Fx<A, E, R>;
+};
+/**
+ * @internal
+ */
+export declare class SubjectImpl<A, E> implements Subject<A, E> {
+    readonly [FxTypeId]: Fx.Fx.Variance<A, E, Scope.Scope>;
+    protected sinks: Set<readonly [Sink.Sink<A, E, any>, ServiceMap.ServiceMap<any>, Scope.Closeable]>;
+    constructor();
+    pipe(): unknown;
+    run<R2>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R2 | Scope.Scope>;
+    onFailure(cause: Cause.Cause<E>): Effect.Effect<void, never, never>;
+    onSuccess(a: A): Effect.Effect<void, never, never>;
+    protected interruptScopes: Effect.Effect<void, never, never>;
+    readonly interrupt: Effect.Effect<void, never, never>;
+    protected addSink<R, B, R2>(sink: Sink.Sink<A, E, R>, f: (scope: Scope.Scope) => Effect.Effect<B, never, R2>): Effect.Effect<B, never, R2 | Scope.Scope>;
+    readonly subscriberCount: Effect.Effect<number>;
+    protected onEvent(a: A): Effect.Effect<void, never, never>;
+    protected onCause(cause: Cause.Cause<E>): Effect.Effect<void, never, never>;
+}
+/**
+ * @internal
+ */
+export declare class HoldSubjectImpl<A, E> extends SubjectImpl<A, E> implements Subject<A, E> {
+    readonly lastValue: MutableRef.MutableRef<Option.Option<Exit.Exit<A, E>>>;
+    onSuccess: (a: A) => Effect.Effect<void, never, never>;
+    onFailure: (cause: Cause.Cause<E>) => Effect.Effect<void, never, never>;
+    run<R2>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R2 | Scope.Scope>;
+    readonly interrupt: Effect.Effect<void, never, never>;
+}
+/**
+ * @internal
+ */
+export declare class ReplaySubjectImpl<A, E> extends SubjectImpl<A, E> {
+    readonly buffer: RingBuffer<Exit.Exit<A, E>>;
+    constructor(buffer: RingBuffer<Exit.Exit<A, E>>);
+    onSuccess: (a: A) => Effect.Effect<void, never, never>;
+    onFailure: (cause: Cause.Cause<E>) => Effect.Effect<void, never, never>;
+    run<R2>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R2 | Scope.Scope>;
+    readonly interrupt: Effect.Effect<void, never, never>;
+}
+/**
+ * Creates a `Subject` that replays the last `replay` values. You will need to manually call `interrupt` on the subject to clear resources.
+ * @param replay - The number of values to replay.
+ * @returns A `Subject` that replays the last `replay` values.
+ */
+export declare function unsafeMake<A, E = never>(replay?: number): Subject<A, E>;
+/**
+ * Create a Subject which utilizes a Scope to manage the lifecycle of the subject's resources.
+ */
+export declare function make<A, E = never>(replay?: number): Effect.Effect<Subject<A, E>, never, Scope.Scope>;
+export declare function Service<Self, A, E = never>(): <const Id extends string>(id: Id) => Subject.Class<Self, Id, A, E>;
+export {};
+//# sourceMappingURL=Subject.d.ts.map

package/dist/Subject/Subject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Subject.d.ts","sourceRoot":"","sources":["../../src/Subject/Subject.ts"],"names":[],"mappings":"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"}

package/dist/Subject/Subject.js

@@ -0,0 +1,272 @@
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { dual, identity } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as MutableRef from "effect/MutableRef";
+import * as Option from "effect/Option";
+import { pipeArguments } from "effect/Pipeable";
+import * as Scope from "effect/Scope";
+import * as ServiceMap from "effect/ServiceMap";
+import { RingBuffer } from "../Fx/internal/ring-buffer.js";
+import { awaitScopeClose, withExtendedScope } from "../Fx/internal/scope.js";
+import { FxTypeId } from "../Fx/TypeId.js";
+/**
+ * Shares the execution of an Fx among multiple subscribers using a Subject.
+ * The source Fx is started when the first subscriber arrives and stopped when the last one leaves.
+ *
+ * @param fx - The source Fx.
+ * @param subject - The subject to use for multicasting.
+ * @returns A shared `Fx`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export function share(fx, subject) {
+    return new Share(fx, subject);
+}
+class RefCounter {
+    _RefCount = MutableRef.make(0);
+    increment() {
+        return MutableRef.updateAndGet(this._RefCount, (n) => n + 1);
+    }
+    decrement() {
+        return MutableRef.updateAndGet(this._RefCount, (n) => Math.max(0, n - 1));
+    }
+}
+const VARIANCE = {
+    _A: identity,
+    _E: identity,
+    _R: identity,
+};
+export class Share {
+    [FxTypeId] = VARIANCE;
+    _FxFiber = MutableRef.make(Option.none());
+    _RefCount = new RefCounter();
+    i0;
+    i1;
+    constructor(i0, i1) {
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    pipe() {
+        return pipeArguments(this, arguments);
+    }
+    run(sink) {
+        return Effect.flatMap(this.initialize(), () => Effect.onExit(this.i1.run(sink), () => this._RefCount.decrement() === 0 ? this.interrupt() : Effect.void));
+    }
+    initialize() {
+        return Effect.suspend(() => {
+            if (this._RefCount.increment() === 1) {
+                return this.i0.run(this.i1).pipe(Effect.ensuring(Effect.suspend(() => {
+                    MutableRef.set(this._FxFiber, Option.none());
+                    return this.i1.interrupt;
+                })), Effect.interruptible, Effect.forkDetach, Effect.tap((fiber) => Effect.sync(() => MutableRef.set(this._FxFiber, Option.some(fiber)))));
+            }
+            else {
+                return Effect.void;
+            }
+        });
+    }
+    interrupt() {
+        return Option.match(MutableRef.getAndSet(this._FxFiber, Option.none()), {
+            onNone: () => Effect.void,
+            onSome: Fiber.interrupt,
+        });
+    }
+}
+/**
+ * Multicasts an Fx to multiple subscribers.
+ * The source Fx is shared, so side effects only happen once per active session (ref count > 0).
+ *
+ * @param fx - The source Fx.
+ * @returns A multicasted `Fx`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export function multicast(fx) {
+    return new Share(fx, unsafeMake(0));
+}
+/**
+ * Holds the latest value emitted by the Fx and replays it to new subscribers.
+ *
+ * @param fx - The source Fx.
+ * @returns A shared `Fx` that replays the latest value.
+ * @since 1.0.0
+ * @category combinators
+ */
+export function hold(fx) {
+    return new Share(fx, unsafeMake(1));
+}
+/**
+ * Replays the last `capacity` values emitted by the Fx to new subscribers.
+ *
+ * @param capacity - The number of values to buffer and replay.
+ * @param fx - The source Fx.
+ * @returns A shared `Fx` that replays values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const replay = dual(2, function replay(fx, capacity) {
+    return new Share(fx, unsafeMake(capacity));
+});
+const DISCARD = { discard: true };
+/**
+ * @internal
+ */
+export class SubjectImpl {
+    [FxTypeId] = VARIANCE;
+    sinks = new Set();
+    constructor() {
+        this.onFailure = this.onFailure.bind(this);
+        this.onSuccess = this.onSuccess.bind(this);
+    }
+    pipe() {
+        return pipeArguments(this, arguments);
+    }
+    run(sink) {
+        return this.addSink(sink, awaitScopeClose);
+    }
+    onFailure(cause) {
+        return this.onCause(cause);
+    }
+    onSuccess(a) {
+        return this.onEvent(a);
+    }
+    interruptScopes = Effect.withFiber((fiber) => Effect.forEach(Array.from(this.sinks), ([, , scope]) => Scope.close(scope, Exit.interrupt(fiber.id)), DISCARD));
+    interrupt = this.interruptScopes;
+    addSink(sink, f) {
+        return withExtendedScope((innerScope) => Effect.servicesWith((ctx) => {
+            const entry = [sink, ctx, innerScope];
+            this.sinks.add(entry);
+            const remove = Effect.sync(() => this.sinks.delete(entry));
+            return Effect.flatMap(Scope.addFinalizer(innerScope, remove), () => f(innerScope));
+        }), "sequential");
+    }
+    subscriberCount = Effect.sync(() => this.sinks.size);
+    onEvent(a) {
+        if (this.sinks.size === 0)
+            return Effect.void;
+        else if (this.sinks.size === 1) {
+            const [sink, ctx] = this.sinks.values().next().value;
+            return runSinkEvent(sink, ctx, a);
+        }
+        else {
+            return Effect.forEach(this.sinks, ([sink, ctx]) => runSinkEvent(sink, ctx, a), DISCARD);
+        }
+    }
+    onCause(cause) {
+        if (this.sinks.size === 0)
+            return Effect.void;
+        else if (this.sinks.size === 1) {
+            const [sink, ctx, scope] = this.sinks.values().next().value;
+            return runSinkCause(sink, ctx, scope, cause);
+        }
+        else {
+            return Effect.forEach(this.sinks, ([sink, ctx, scope]) => runSinkCause(sink, ctx, scope, cause), DISCARD);
+        }
+    }
+}
+function runSinkEvent(sink, ctx, a) {
+    return Effect.provide(Effect.catchCause(sink.onSuccess(a), sink.onFailure), ctx);
+}
+function runSinkCause(sink, ctx, scope, cause) {
+    return Effect.provide(Effect.catchCause(sink.onFailure(cause), (error) => Scope.close(scope, Exit.failCause(error))), ctx);
+}
+/**
+ * @internal
+ */
+export class HoldSubjectImpl extends SubjectImpl {
+    lastValue = MutableRef.make(Option.none());
+    onSuccess = (a) => Effect.suspend(() => {
+        // Keep track of the last value emitted by the subject
+        MutableRef.set(this.lastValue, Option.some(Exit.succeed(a)));
+        return this.onEvent(a);
+    });
+    onFailure = (cause) => {
+        return Effect.suspend(() => {
+            // Keep track of the last value emitted by the subject
+            MutableRef.set(this.lastValue, Option.some(Exit.failCause(cause)));
+            return this.onCause(cause);
+        });
+    };
+    run(sink) {
+        return this.addSink(sink, (scope) => Option.match(MutableRef.get(this.lastValue), {
+            onNone: () => awaitScopeClose(scope),
+            // If we have a previous value, emit it first
+            onSome: (exit) => Effect.flatMap(Exit.match(exit, sink), () => awaitScopeClose(scope)),
+        }));
+    }
+    interrupt = Effect.tap(this.interruptScopes, Effect.sync(() => MutableRef.set(this.lastValue, Option.none())));
+}
+/**
+ * @internal
+ */
+export class ReplaySubjectImpl extends SubjectImpl {
+    buffer;
+    constructor(buffer) {
+        super();
+        this.buffer = buffer;
+    }
+    onSuccess = (a) => Effect.suspend(() => {
+        // Keep track of the last value emitted by the subject
+        this.buffer.push(Exit.succeed(a));
+        return this.onEvent(a);
+    });
+    onFailure = (cause) => Effect.suspend(() => {
+        this.buffer.push(Exit.failCause(cause));
+        return this.onCause(cause);
+    });
+    run(sink) {
+        return this.addSink(sink, (scope) => Effect.flatMap(this.buffer.forEach(Exit.match(sink)), () => awaitScopeClose(scope)));
+    }
+    interrupt = Effect.tap(this.interruptScopes, Effect.sync(() => this.buffer.clear()));
+}
+/**
+ * Creates a `Subject` that replays the last `replay` values. You will need to manually call `interrupt` on the subject to clear resources.
+ * @param replay - The number of values to replay.
+ * @returns A `Subject` that replays the last `replay` values.
+ */
+export function unsafeMake(replay = 0) {
+    replay = Math.max(0, replay);
+    if (replay === 0) {
+        return new SubjectImpl();
+    }
+    else if (replay === 1) {
+        return new HoldSubjectImpl();
+    }
+    else {
+        return new ReplaySubjectImpl(new RingBuffer(replay));
+    }
+}
+/**
+ * Create a Subject which utilizes a Scope to manage the lifecycle of the subject's resources.
+ */
+export function make(replay) {
+    return Effect.acquireRelease(Effect.sync(() => unsafeMake(replay)), (subject) => subject.interrupt);
+}
+export function Service() {
+    return (id) => {
+        const service = ServiceMap.Service(id);
+        // eslint-disable-next-line @typescript-eslint/no-extraneous-class
+        return class SubjectService {
+            static id = id;
+            static service = service;
+            static make = (replay) => Layer.effect(service, make(replay));
+            static [FxTypeId] = VARIANCE;
+            static pipe = function () {
+                return pipeArguments(this, arguments);
+            };
+            // Fx
+            static run = (sink) => Effect.flatMap(service.asEffect(), (subject) => subject.run(sink));
+            // Sink
+            static onSuccess = (value) => Effect.flatMap(service.asEffect(), (subject) => subject.onSuccess(value));
+            static onFailure = (cause) => Effect.flatMap(service.asEffect(), (subject) => subject.onFailure(cause));
+            // Subject
+            static subscriberCount = Effect.flatMap(service.asEffect(), (subject) => subject.subscriberCount);
+            static interrupt = Effect.flatMap(service.asEffect(), (subject) => subject.interrupt);
+            constructor() {
+                return SubjectService;
+            }
+        };
+    };
+}

package/dist/Subject/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Subject.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/Subject/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Subject/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/Subject/index.js

@@ -0,0 +1 @@
+export * from "./Subject.js";

package/dist/Subject.d.ts

@@ -0,0 +1,2 @@
+export * from "./Subject/index.js";
+//# sourceMappingURL=Subject.d.ts.map

package/dist/Subject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Subject.d.ts","sourceRoot":"","sources":["../src/Subject.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/Subject.js

@@ -0,0 +1 @@
+export * from "./Subject/index.js";

package/dist/Versioned/Versioned.d.ts

@@ -0,0 +1,176 @@
+/** @effect-diagnostics missingEffectError:skip-file */
+/** @effect-diagnostics missingEffectContext:skip-file */
+/**
+ * Versioned is a special Fx which is also an Effect, and keeps track of a version number of the
+ * current value it holds. The Fx portion is used to subscribe to changes, the Effect portion to
+ * sample the current value. The version can be utilized to avoid computing work related to this value.
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import type * as Scope from "effect/Scope";
+import * as ServiceMap from "effect/ServiceMap";
+import type * as Fx from "../Fx/Fx.js";
+import { YieldableFx } from "../Fx/internal/yieldable.js";
+import type * as Sink from "../Sink/Sink.js";
+/**
+ * A Versioned value is a value that changes over time, and each change is associated with a version number.
+ * It combines the capabilities of an `Fx` (to observe changes) and an `Effect` (to get the current value).
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Versioned<out R1, out E1, out A2, out E2, out R2, out A3, out E3, out R3> extends Fx.Fx<A2, E2, R2>, Effect.Yieldable<Versioned<R1, E1, A2, E2, R2, A3, E3, R3>, A3, E3, R3> {
+    readonly version: Effect.Effect<number, E1, R1>;
+    readonly interrupt: Effect.Effect<void, never, R1>;
+}
+export declare namespace Versioned {
+    /**
+     * Unifies a Versioned type.
+     * @since 1.0.0
+     * @category type-level
+     */
+    type Unify<T> = T extends Versioned<infer R1, infer E1, infer R2, infer E2, infer A2, infer R3, infer E3, infer A3> | (infer _) ? Versioned<R1, E1, A2, E2, R2, A3, E3, R3> : never;
+    /**
+     * Extracts the context required to get the version.
+     * @since 1.0.0
+     * @category type-level
+     */
+    type VersionContext<T> = T extends Versioned<infer R, any, any, any, any, any, any, any> ? R : never;
+    /**
+     * Extracts the error type of the version effect.
+     * @since 1.0.0
+     * @category type-level
+     */
+    type VersionError<T> = T extends Versioned<any, infer E, any, any, any, any, any, any> ? E : never;
+    interface Service<Self, Id extends string, E1, A2, E2, A3, E3> extends Versioned<Self, E1, A2, E2, Self, A3, E3, Self> {
+        readonly id: Id;
+        readonly service: ServiceMap.Service<Self, Versioned<never, E1, A2, E2, never, A3, E3, never>>;
+        readonly make: <R1 = never, R2 = never, R3 = never>(version: Effect.Effect<number, E1, R1>, fx: Fx.Fx<A2, E2, R2>, effect: Effect.Yieldable<any, A3, E3, R3>) => Layer.Layer<Self, never, Exclude<R1 | R2 | R3, Scope.Scope>>;
+    }
+    interface Class<Self, Id extends string, E1, A2, E2, A3, E3> extends Service<Self, Id, E1, A2, E2, A3, E3> {
+        new (): Service<Self, Id, E1, A2, E2, A3, E3>;
+    }
+}
+/**
+ * Creates a Versioned value from its components.
+ *
+ * @param version - An effect that retrieves the current version number.
+ * @param fx - The stream of updates.
+ * @param effect - An effect that retrieves the current value.
+ * @returns A `Versioned` value.
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare function make<R1, E1, A2, E2, R2, A3, E3, R3>(version: Effect.Effect<number, E1, R1>, fx: Fx.Fx<A2, E2, R2>, effect: Effect.Yieldable<any, A3, E3, R3>): Versioned<R1, E1, A2, E2, R2, A3, E3, R3>;
+/**
+ * Transforms a Versioned value into another Versioned value.
+ *
+ * @param input - The source Versioned value.
+ * @param transformFx - A function to transform the update stream.
+ * @param transformGet - A function to transform the current value effect.
+ * @returns A new `Versioned` value.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function transform<R0, E0, A, E, R, B, E2, R2, C, E3, R3, D, E4, R4>(input: Versioned<R0, E0, A, E, R, B, E2, R2>, transformFx: (fx: Fx.Fx<A, E, R>) => Fx.Fx<C, E3, R3>, transformGet: (effect: Effect.Effect<B, E2, R2>) => Effect.Effect<D, E4, R4>): Versioned<never, never, C, E3, R3, D, E0 | E4, R0 | R4>;
+/**
+ * @internal
+ */
+export declare class VersionedTransform<R0, E0, A, E, R, B, E2, R2, C, E3, R3, D, E4, R4> extends YieldableFx<C, E3, R3, D, E0 | E4, R0 | R4> implements Versioned<never, never, C, E3, R3, D, E0 | E4, R0 | R4> {
+    _version: number;
+    _currentValue: Option.Option<Exit.Exit<D, E0 | E4>>;
+    _fx: Fx.Fx<C, E3, R3>;
+    readonly input: Versioned<R0, E0, A, E, R, B, E2, R2>;
+    readonly _transformFx: (fx: Fx.Fx<A, E, R>) => Fx.Fx<C, E3, R3>;
+    readonly _transformEffect: (effect: Effect.Effect<B, E2, R2>) => Effect.Effect<D, E4, R4>;
+    constructor(input: Versioned<R0, E0, A, E, R, B, E2, R2>, _transformFx: (fx: Fx.Fx<A, E, R>) => Fx.Fx<C, E3, R3>, _transformEffect: (effect: Effect.Effect<B, E2, R2>) => Effect.Effect<D, E4, R4>);
+    readonly version: Effect.Effect<number, never, never>;
+    run<R5>(sink: Sink.Sink<C, E3, R5>): Effect.Effect<unknown, never, R3 | R5>;
+    toEffect(): Effect.Effect<D, E0 | E4, R0 | R4>;
+    interrupt: Effect.Effect<void, never, never>;
+}
+/**
+ * Transform a Versioned's output value as both an Fx and Effect.
+ * @since 1.18.0
+ * @category combinators
+ */
+export declare const map: {
+    <A, E, R, C, B, D>(options: {
+        onFx: (a: A) => C;
+        onEffect: (b: B) => D;
+    }): <R0, E0, R2, E2>(versioned: Versioned<R0, E0, A, E, R, B, E2, R2>) => Versioned<never, never, C, E, R, D, E0 | E2, R0 | R2>;
+    <R0, E0, A, E, R, B, E2, R2, C, D>(versioned: Versioned<R0, E0, A, E, R, B, E2, R2>, options: {
+        onFx: (a: A) => C;
+        onEffect: (b: B) => D;
+    }): Versioned<never, never, C, E, R, D, E0 | E2, R0 | R2>;
+};
+/**
+ * Transform a Versioned's output value as both an Fx and Effect using an Effect.
+ * @since 1.18.0
+ * @category combinators
+ */
+export declare const mapEffect: {
+    <A, C, E3, R3, B, D, E4, R4>(options: {
+        onFx: (a: A) => Effect.Effect<C, E3, R3>;
+        onEffect: (b: B) => Effect.Effect<D, E4, R4>;
+    }): <R0, E0, R, E, R2, E2>(versioned: Versioned<R0, E0, A, E, R, B, E2, R2>) => Versioned<never, never, C, E | E3, R | R3, D, E0 | E2 | E4, R0 | R2 | R4>;
+    <R0, E0, A, E, R, B, E2, R2, C, E3, R3, D, E4, R4>(versioned: Versioned<R0, E0, A, E, R, B, E2, R2>, options: {
+        onFx: (a: A) => Effect.Effect<C, E3, R3>;
+        onEffect: (b: B) => Effect.Effect<D, E4, R4>;
+    }): Versioned<never, never, C, E | E3, R | R3, D, E0 | E2 | E4, R0 | R2 | R4>;
+};
+/**
+ * Combines multiple Versioned values into a single tuple.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function tuple<const VS extends ReadonlyArray<Versioned<any, any, any, any, any, any, any, any>>>(versioneds: VS): Versioned<Versioned.VersionContext<VS[number]>, Versioned.VersionError<VS[number]>, {
+    readonly [K in keyof VS]: Effect.Success<VS[K]>;
+}, Fx.Error<VS[number]>, Fx.Services<VS[number]>, {
+    readonly [K in keyof VS]: Fx.Success<VS[K]>;
+}, Effect.Error<VS[number]>, Effect.Services<VS[number]>>;
+/**
+ * Combines multiple Versioned values into a single struct.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function struct<const VS extends Readonly<Record<string, Versioned<any, any, any, any, any, any, any, any>>>>(versioneds: VS): Versioned<Versioned.VersionContext<VS[keyof VS]>, Versioned.VersionError<VS[keyof VS]>, {
+    readonly [K in keyof VS]: Fx.Success<VS[K]>;
+}, Fx.Error<VS[keyof VS]>, Fx.Services<VS[keyof VS]>, {
+    readonly [K in keyof VS]: Effect.Success<VS[K]>;
+}, Effect.Error<VS[keyof VS]>, Effect.Services<VS[keyof VS]>>;
+/**
+ * Provides context to a Versioned value.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const provide: <R0, E0, A, E, R, B, E2, R2, R3 = never, S = never>(versioned: Versioned<R0, E0, A, E, R, B, E2, R2>, layer: Layer.Layer<S, never, R3>) => Versioned<R3 | Exclude<R0, S>, E0, A, E, R3 | Exclude<R, S>, B, E2, R3 | Exclude<R2, S>>;
+/**
+ * Creates a Versioned value from a constant.
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare function of<A>(value: A): Versioned<never, never, A, never, never, A, never, never>;
+/**
+ * Holds the latest value of a Versioned stream.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function hold<R0, E0, A, E, R, B, E2, R2>(versioned: Versioned<R0, E0, A, E, R, B, E2, R2>): Versioned<R0, E0, A, E, R | Scope.Scope, B, E2, R2>;
+/**
+ * Multicasts a Versioned stream.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function multicast<R0, E0, A, E, R, B, E2, R2>(versioned: Versioned<R0, E0, A, E, R, B, E2, R2>): Versioned<R0, E0, A, E, R | Scope.Scope, B, E2, R2>;
+/**
+ * Replays the last `bufferSize` values of a Versioned stream.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function replay<R0, E0, A, E, R, B, E2, R2>(versioned: Versioned<R0, E0, A, E, R, B, E2, R2>, bufferSize: number): Versioned<R0, E0, A, E, R | Scope.Scope, B, E2, R2>;
+export declare function Service<Self, E1 = never, A2 = never, E2 = never, A3 = never, E3 = never>(): <const Id extends string>(id: Id) => Versioned.Class<Self, Id, E1, A2, E2, A3, E3>;
+//# sourceMappingURL=Versioned.d.ts.map