# flatMap

Maps each source value to an inner Fx and merges every inner concurrently.

## Signatures

```ts
export declare const flatMap: FlatMapLike;
```

## Why

`flatMap` is the unconstrained merge policy for independent pushed work. It
preserves push-based production instead of collecting an inner Fx before the
next source value can be handled.

## Concurrency, ordering, and cardinality

Every source value creates exactly one inner Fx with no concurrency limit.
Each inner retains its own emission order, but values from different inners
interleave according to arrival time. There is no output buffer or global
ordering guarantee.

## Ownership and lifetime

Source and inner failures are forwarded; their required services are unioned.
A `FiberSet` in the required `Scope` owns all inner fibers. Source completion
waits for the set to empty. Interrupting observation closes the Scope and
interrupts every active inner, running each inner Scope's finalizers.

## Examples

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

const rows = Fx.flatMap(Fx.fromIterable([
  { id: "slow", wait: "20 millis" as const },
  { id: "fast", wait: "1 millis" as const }
]), ({ id, wait }) => Fx.at(id, wait))

Effect.runPromise(Effect.scoped(Fx.collectAll(rows))).then(console.log)
// ["fast", "slow"]: inners overlap and results arrive by production time
```