# make

Creates an Fx from a function that provides values to a Sink.

This is the lowest-level constructor for Fx, giving you full control over
the stream's behavior.

## Signatures

```ts
export declare const make: <A, E = never, R = never>(run: <RSink = never>(sink: Sink<A, E, RSink>) => Effect.Effect<unknown, never, R | RSink>) => Fx<A, E, R>;
```

## Why

`make` is the protocol boundary for custom producers. It exposes the real `Sink`
operation so libraries can define cardinality, ordering, concurrency, causes, and
services without an opinionated source wrapper.

## Ownership and lifetime

`make` stores the callback without invoking it. Calling `fx.run(sink)` asks the
callback to construct its Effect; executing that Effect performs the subscription.
Keep acquisition, publication, and cleanup inside the returned Effect or a required
`Scope`, rather than performing side effects while constructing it. The returned
Effect has no typed failure channel because producer failures are delivered through
`sink.onFailure`; defects and interruption can still affect the run.

## Examples

```ts
import { Effect } from "effect"
import { collectAll, make } from "@typed/fx/Fx"

const pair = make<number>((sink) =>
  Effect.andThen(sink.onSuccess(1), sink.onSuccess(2))
)
const program = collectAll(pair)
```