# Share

The concrete lazy `Fx` returned by `share`.

## Signatures

```ts
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>;
}
```

## Why

`Share` exposes the ref-counted sharing mechanism as an ordinary `Fx`: one source execution feeds
the selected subject while each caller has an independently scoped subscription to that subject.
Most callers should prefer `share`, `multicast`, `hold`, or `replay` for clearer intent.

## Ownership and lifetime

Construction acquires nothing. The first executing `run` starts a detached source fiber; the
final executing `run` interrupts it. Source completion interrupts the subject's current
subscribers. Source, subject, and sink services are required only when `run` executes.

## Constructor

Creates the lazy shared `Fx`; source acquisition waits until the first call to `run` executes.

## Constructor: Why

Keeps selection of the source and multicast policy separate from their execution.

## Constructor: Ownership and lifetime

The constructor only stores `i0` and `i1`; it starts no fiber and installs no finalizer.

## Property: [[computed:[FxTypeId]]]

Carries `Fx` variance information for the shared output, error, and service channels.

## Property: [[computed:[FxTypeId]]]: Why

Lets generic `Fx` utilities recognize and infer a `Share` without inspecting its runtime fields.

## Property: [[computed:[FxTypeId]]]: Ownership and lifetime

The marker is immutable metadata and acquires no resources.

## Property: _FxFiber

Tracks the source fiber for the current active subscriber session.

## Property: _FxFiber: Why

Gives the final departing subscriber an exact fiber to interrupt without restarting or
duplicating the source.

## Property: _FxFiber: Ownership and lifetime

The reference is empty before a session, set after the first subscriber starts the source, and
cleared before or when that session ends. It does not outlive the `Share` instance.

## Property: _RefCount

Tracks how many executing `run` effects participate in the active source session.

## Property: _RefCount: Why

Implements the first-subscriber start and last-subscriber stop boundary.

## Property: _RefCount: Ownership and lifetime

The counter is owned by the `Share` instance and never falls below zero. Each executing `run`
increments once and decrements in its exit finalizer.

## Property: i0

The source whose execution is shared.

## Property: i0: Why

Retains the original source so every active session can start exactly that `Fx`.

## Property: i0: Ownership and lifetime

Holding the `Fx` value starts no work. Its `R` services and cleanup participate only while a
subscriber session is active.

## Property: i1

The multicast subject receiving source publications.

## Property: i1: Why

Separates source sharing from retention and publication policy.

## Property: i1: Ownership and lifetime

`Share` does not allocate this subject. It subscribes sinks to it and interrupts it when the
source session exits; the subject's `R2` services remain required by `run`.

## Method: pipe

Returns this value through the concrete class's zero-argument pipe entrypoint.

## Method: pipe: Why

Supplies the runtime pipe hook required by `Fx`; the concrete `Share` declaration currently
publishes only its zero-argument signature, so typed combinator composition should target the
`Fx` returned by `share`, `multicast`, `hold`, or `replay`.

## Method: pipe: Ownership and lifetime

Calling `pipe` itself acquires no resources; only an executing downstream `run` starts work.

## Method: run

Registers `sink`, joins or starts the active source session, and remains active until the
subscription ends. Interruption removes this subscriber and stops the source if it was last.

## Method: run: Why

Implements `Fx` consumption while coordinating one source execution across independent sinks.

## Method: run: Ownership and lifetime

The caller's `Scope` owns its subject subscription. Source `R`, subject `R2`, and sink `R3`
services are required during execution. Source failures are published to the sink rather than
failing this returned Effect, whose error channel is `never`.

## Examples

```ts
import { Fx } from "@typed/fx"
import { Share, unsafeMake } from "@typed/fx/Subject"

const shared = new Share(Fx.succeed(1), unsafeMake<number>())
```

```ts
import { Fx } from "@typed/fx"
import { Share, unsafeMake } from "@typed/fx/Subject"

const shared = new Share(Fx.succeed("ready"), unsafeMake<string>())
```

```ts
import { Fx } from "@typed/fx"
import { Share, unsafeMake } from "@typed/fx/Subject"

const shared = new Share(Fx.succeed(1), unsafeMake<number>())
const same = shared.pipe()
```

```ts
import { Effect } from "effect"
import { Fx } from "@typed/fx"
import * as Sink from "@typed/fx/Sink"
import { Share, unsafeMake } from "@typed/fx/Subject"

const shared = new Share(Fx.succeed(1), unsafeMake<number>())
const run = shared.run(
  Sink.make(
    () => Effect.void,
    (value) => Effect.sync(() => console.log(value))
  )
)
```