Follow one execution
Layer acquisition starts background observation and returns without waiting for its exit. The Layer Scope owns interruption.
observeLayerTick 0. Layer Scope: start.
Read this diagram
Follow each lane from left to right. Events stacked vertically share a tick; the green cursor marks the current time across every lane.
- A value
The text inside the pill is the emitted value. - Work starts
The raised chevron starts an inner run (^in the source). - The run returns
The vertical bar ends this lane’s run. - A cause is delivered
The exclamation mark belongs to this lane. - Work is interrupted
The cross marks cancellation of this run. - Current time
The line and diamond move together across all lanes. - Happening now
A highlighted event is at the current tick. - Still ahead
Muted, dashed values have not happened yet. - Time continues
The lane’s arrow is not a return marker. An empty stretch can be quiet work that is still running.
Illustrated ticks start at 0. At 1×, one illustrated tick takes one second; captions specify real durations when timing matters. A cause or interruption belongs to its lane, and other work may continue. Scroll horizontally to inspect the rest of a long timeline.
Building the Layer forks observe(fx, f) in its scope and completes acquisition after registration. Releasing the Layer interrupts the observer and source. Source and callback failures terminate the discarded child Fiber; they do not fail Layer acquisition, and this API exposes no Fiber handle from which to await the exit. Handle or report those failures inside the source/callback, or use observe/fork when the caller must observe them. The annotated E | E2 Layer error remains in the public type even though this implementation does not propagate the background exit. Scope is supplied internally; delivery behavior remains that of observe.
Import
import { Fx } from "@typed/fx";Access Fx.observeLayer through the imported Fx export. Its declaration below describes the member.
This public exposure is a re-export. Its import path is supported; declaration documentation is shared with the other public exposures below.
Signatures
export declare const observeLayer: {
<A, E2 = never, R2 = never>(f: (value: A) => void | Effect<unknown, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Layer<never, E | E2, Exclude<R | R2, Scope>>;
<A, E, R, E2 = never, R2 = never>(fx: Fx<A, E, R>, f: (value: A) => void | Effect<unknown, E2, R2>): Layer<never, E | E2, Exclude<R | R2, Scope>>;
};Why
Observation side effects can be installed as application infrastructure and share the Layer graph’s typed dependencies and shutdown behavior.
Ownership and lifetime
Building the Layer forks observe(fx, f) in its scope and completes acquisition
after registration. Releasing the Layer interrupts the observer and source. Source
and callback failures terminate the discarded child Fiber; they do not fail Layer
acquisition, and this API exposes no Fiber handle from which to await the exit.
Handle or report those failures inside the source/callback, or use observe/fork
when the caller must observe them. The annotated E | E2 Layer error remains in the
public type even though this implementation does not propagate the background exit.
Scope is supplied internally; delivery behavior remains that of observe.
Examples
import { Effect } from "effect"
import { fromIterable, observeLayer } from "@typed/fx/Fx"
const report = (value: number) =>
Effect.try({ try: () => JSON.stringify(BigInt(value)), catch: String }).pipe(
Effect.catch((error) => Effect.logError(error))
)
const LogValues = observeLayer(fromIterable([1, 2]), report)
const program = Effect.void.pipe(Effect.provide(LogValues))Other public imports
These import paths expose the same declaration. Each page retains its own public name and signature.