unthrownExplicit errors as values

A small, focused Result type with a separate defect channel for the unexpected — and qualification enforced at every boundary.

Get Started

Why unthrown?

GitHub

🎯

Errors as values

Ordinary errors are returned in a Result, not thrown. Only a true defect ever throws — and only at unwrap.

🧯

A separate defect channel

Unmodeled failures become a Defect — a third runtime state invisible to the type. A bug in a .map can't masquerade as a domain error.

🛂

Qualification at every boundary

fromPromise / fromThrowable force you to triage each failure into a modeled error or a defect. No path ever yields `unknown` in E.

🪶

Small and done-able

Zero runtime dependencies, ESM-first, dual CJS/ESM, fully typed. One concept, one name. Small enough to be "done".

At a glance

import { ok, err, fromPromise, type Result } from "unthrown";

class NotFound extends TaggedError("NotFound") {}

function findUser(id: string): Result<User, NotFound> {
  const user = users.get(id);
  return user ? ok(user) : err(new NotFound());
}

// Cross an async boundary — every rejection MUST be triaged.
const profile = fromPromise(fetch(`/u/${id}`), (cause) =>
  cause instanceof Response ? new NotFound() : defect(cause),
);

// Handle every channel once, at the edge — no surrounding try/catch.
const status = await profile.match({
  ok: () => 200,
  err: () => 404,
  defect: () => 500,
});

Ordinary errors travel as values through map / flatMap / match. A thrown bug becomes a defect that short-circuits to the edge — never silently folded into your domain errors.