A structured, discriminable error.

Span/log attributes a failure declares for tracing: failure.code plus whatever its factory's trace mapper (see define) explicitly allowlisted from data. A failure whose factory declared no mapper yields the code alone — unmapped payload fields never leave the process, which is what makes redaction (passwords, tokens) the default rather than a discipline.

Flattens an error's cause chain into an array, error first and the root cause last.

define() overload for failures that carry no payload.

define() overload for failures whose message is derived from their payload.

Renders an error and its whole cause chain as indented, human-readable lines.

Coerces any caught value into a Failure, leaving existing Failures untouched.

Revives a SerializedFailure into a real Failure, reconstructing the cause chain.

Narrows a Failure to one of several codes — the multi-code sibling of Factory.is.

Builds a .catch() handler for a failure that genuinely has no consequence — but says so under QUNITX_DEBUG instead of vanishing. This is the raw handler; the ergonomic spelling at call sites is Task(promise).ignore(context), which wraps exactly this function.

Whether value is a Failure — from this realm or any other.

Whether value is a Failure — from this realm or any other.

True for a factory made by define. A factory carries the code it produces and its own is guard; a plain error-mapper carries neither, so an API can accept both in one position and tell them apart exactly, without guessing from arity.

Whether value is a Failure — from this realm or any other.

Whether value is a Failure — from this realm or any other.

Reports a declared failure to the observation seam — onObserved plus the OBSERVED_CHANNEL_NAME channel. Task's consuming methods call this at their classification points; call it yourself only for a synchronous Result flow that never crossed a Task, so a tracing adapter sees those failures too.

Installs a process-wide observer for every ignored failure — the interception seam for "list everything the program decided not to handle". Costs one null check on the failure path only (nothing on success, nothing per Task), and retains nothing itself: whether the suppressed failures accumulate, sample, or stream somewhere is the observer's decision. Pass null to detach.

Installs a process-wide observer for every handled declared failure — the portable (browser-friendly) counterpart of subscribing to OBSERVED_CHANNEL_NAME. Single slot, one null check on the failure path, nothing retained; pass null to detach.

The deepest cause in the chain — the original failure, whatever wrapped it since.

Toggles ignored-failure reporting at runtime, overriding the QUNITX_DEBUG default.

Converts a Failure (or any error) into plain JSON.

The producer half of StreamClass.channel: emit into it, consume stream out of it.

How a Channel behaves when its consumer cannot keep up.

Per-kind options accepted by define().

A callable failure constructor produced by define(), carrying its own type guard.

Options accepted by the Failure constructor and by every generated factory.

The wire form of a Failure — what toJSON emits and fromJSON accepts.

Structured, discriminable failures — the E elements of a Stream.

The failure element a 'fail' channel ends with.

Any Failure at all — the type to reach for when a signature accepts failures it does not enumerate, e.g. Result<T, Failure.Any> at a boundary that only logs.

The callback shape onIgnored installs: every ignored failure arrives with the label its call site declared.

The callback shape onObserved installs: every declared failure a consumer classified arrives right as it is handed to application code.

The Failure type a factory produces: Failure.Of<typeof FileMissing>.

The attribute primitives tracing systems accept (OpenTelemetry's span-attribute values) — what a trace mapper returns and attributes yields.

What a full channel does — the two GenStage :buffer_keep choices, named for the element that goes rather than the one that stays, plus the option of refusing to lose anything silently.

Anything a Stream can be built from or flattened into: sync or async iterables (a web ReadableStream is async-iterable on every modern runtime).

A channel with overflow: 'fail' filled up: the consumer fell far enough behind that the buffer could not hold the difference, and dropping was not on the table.

Name of the diagnostics_channel that ignore publishes to on Node and Deno — subscribe with the platform API, no qunitx registry involved. Messages are { context: string, error: unknown }. Browsers have no channel; use onIgnored.

Name of the diagnostics_channel that observed publishes to on Node and Deno. Messages are { error: Failure.Any }. This is what a tracing adapter subscribes to — e.g. OpenTelemetry, in its entirety:

The failure from() produces for a throwable that is not already a Failure.

The exported value: builders (Stream.from, Stream.unfold, Stream.lines) are the only entry points — there is no public constructor and no call form.

The exported value: builders (Stream.from, Stream.unfold, Stream.lines) are the only entry points — there is no public constructor and no call form.

Call-or-construct, like Boolean/Date: Task(recipe) and new Task(recipe) build the same lazy Task. ES classes reject the call form, so the export is a Proxy whose apply forwards to construction — statics, instanceof, and the prototype all pass through.

Call-or-construct, like Boolean/Date: Task(recipe) and new Task(recipe) build the same lazy Task. ES classes reject the call form, so the export is a Proxy whose apply forwards to construction — statics, instanceof, and the prototype all pass through.