errore 0.0.1 → 0.1.0

package/dist/index.d.mts

@@ -1,3 +1,291 @@
-declare const version = "0.0.1";
+/**
+ * The core type: either an Error or a value T.
+ * Unlike Result<T, E>, this is just a union - no wrapper needed.
+ */
+type Errore<T, E extends Error = Error> = E | T;
+/**
+ * Extract the error type from an Errore union.
+ * @example InferError<NetworkError | User> // NetworkError
+ */
+type InferError<T> = T extends Error ? T : never;
+/**
+ * Extract the value type from an Errore union.
+ * @example InferValue<NetworkError | User> // User
+ */
+type InferValue<T> = T extends Error ? never : T;
+/**
+ * Utility to ensure T is not an Error type.
+ * Used to prevent ambiguous unions like Error | Error.
+ */
+type EnsureNotError<T> = T extends Error ? 'Error: Value type T cannot extend Error - this would make the union ambiguous' : T;
 
-export { version };
+/**
+ * Any tagged error (for generic constraints)
+ */
+type AnyTaggedError = Error & {
+    readonly _tag: string;
+};
+/**
+ * Instance type produced by TaggedError factory
+ */
+type TaggedErrorInstance<Tag extends string, Props> = Error & {
+    readonly _tag: Tag;
+    toJSON(): object;
+} & Readonly<Props>;
+/**
+ * Class type produced by TaggedError factory
+ */
+type TaggedErrorClass<Tag extends string, Props> = {
+    new (...args: keyof Props extends never ? [args?: {}] : [args: Props]): TaggedErrorInstance<Tag, Props>;
+    /** Type guard for this error class */
+    is(value: unknown): value is TaggedErrorInstance<Tag, Props>;
+};
+/**
+ * Factory for tagged error classes with discriminated _tag property.
+ * Enables exhaustive pattern matching on error unions.
+ *
+ * @example
+ * class NotFoundError extends TaggedError("NotFoundError")<{
+ *   id: string;
+ *   message: string;
+ * }>() {}
+ *
+ * const err = new NotFoundError({ id: "123", message: "Not found" });
+ * err._tag    // "NotFoundError"
+ * err.id      // "123"
+ *
+ * // Type guard
+ * NotFoundError.is(err) // true
+ * TaggedError.is(err)   // true (any tagged error)
+ */
+declare const TaggedError: {
+    <Tag extends string>(tag: Tag): <Props extends Record<string, unknown> = {}>() => TaggedErrorClass<Tag, Props>;
+    /** Type guard for any TaggedError instance */
+    is(value: unknown): value is AnyTaggedError;
+};
+/**
+ * Type guard for tagged error instances.
+ *
+ * @example
+ * if (isTaggedError(value)) { value._tag }
+ */
+declare const isTaggedError: (value: unknown) => value is AnyTaggedError;
+/**
+ * Handler map for exhaustive matching
+ */
+type MatchHandlers<E extends AnyTaggedError, R> = {
+    [K in E['_tag']]: (err: Extract<E, {
+        _tag: K;
+    }>) => R;
+};
+/**
+ * Exhaustive pattern match on tagged error union by _tag.
+ *
+ * @example
+ * matchError(err, {
+ *   NotFoundError: (e) => `Missing: ${e.id}`,
+ *   ValidationError: (e) => `Invalid: ${e.field}`,
+ * });
+ */
+declare function matchError<E extends AnyTaggedError, R>(err: E, handlers: MatchHandlers<E, R>): R;
+/**
+ * Partial pattern match with fallback for unhandled tags.
+ *
+ * @example
+ * matchErrorPartial(err, {
+ *   NotFoundError: (e) => `Missing: ${e.id}`,
+ * }, (e) => `Unknown: ${e.message}`);
+ */
+declare function matchErrorPartial<E extends AnyTaggedError, R>(err: E, handlers: Partial<MatchHandlers<E, R>>, fallback: (e: E) => R): R;
+declare const UnhandledError_base: TaggedErrorClass<"UnhandledError", {
+    message: string;
+    cause: unknown;
+}>;
+/**
+ * Default error type when catching unknown exceptions.
+ */
+declare class UnhandledError extends UnhandledError_base {
+    constructor(args: {
+        cause: unknown;
+    });
+}
+
+/**
+ * Type guard: checks if value is an Error.
+ * After this check, TypeScript narrows the type.
+ *
+ * @example
+ * const result = await fetchUser(id)
+ * if (isError(result)) {
+ *   // result is narrowed to the error type
+ *   return result
+ * }
+ * // result is narrowed to User
+ * console.log(result.name)
+ */
+declare function isError<T, E extends Error>(value: E | T): value is E;
+/**
+ * Type guard: checks if value is NOT an Error.
+ * Inverse of isError for convenience.
+ *
+ * @example
+ * const result = await fetchUser(id)
+ * if (isOk(result)) {
+ *   console.log(result.name) // result is User
+ * }
+ */
+declare function isOk<T, E extends Error>(value: E | T): value is T;
+/**
+ * Execute a sync function and return either the value or an error.
+ *
+ * @overload Simple form - wraps exceptions in UnhandledError
+ * @example
+ * const result = tryFn(() => JSON.parse(input))
+ * // result: UnhandledError | unknown
+ *
+ * @overload With custom catch - you control the error type
+ * @example
+ * const result = tryFn({
+ *   try: () => JSON.parse(input),
+ *   catch: (e) => new ParseError({ cause: e })
+ * })
+ * // result: ParseError | unknown
+ */
+declare function tryFn<T>(fn: () => T): UnhandledError | T;
+declare function tryFn<T, E extends Error>(opts: {
+    try: () => T;
+    catch: (e: unknown) => E;
+}): E | T;
+/**
+ * Execute an async function and return either the value or an error.
+ *
+ * @overload Simple form - wraps exceptions in UnhandledError
+ * @example
+ * const result = await tryAsync(() => fetch(url).then(r => r.json()))
+ * // result: UnhandledError | unknown
+ *
+ * @overload With custom catch - you control the error type
+ * @example
+ * const result = await tryAsync({
+ *   try: () => fetch(url),
+ *   catch: (e) => new NetworkError({ cause: e })
+ * })
+ * // result: NetworkError | Response
+ */
+declare function tryAsync<T>(fn: () => Promise<T>): Promise<UnhandledError | T>;
+declare function tryAsync<T, E extends Error>(opts: {
+    try: () => Promise<T>;
+    catch: (e: unknown) => E | Promise<E>;
+}): Promise<E | T>;
+
+/**
+ * Transform the value if not an error.
+ * If the value is an error, returns it unchanged.
+ *
+ * @example
+ * const result = map(user, u => u.name)
+ * // If user is User, result is string
+ * // If user is NotFoundError, result is NotFoundError
+ */
+declare function map<T, U, E extends Error>(value: E | T, fn: (v: T) => U): E | U;
+/**
+ * Transform the error if it is an error.
+ * If the value is not an error, returns it unchanged.
+ *
+ * @example
+ * const result = mapError(fetchResult, e => new AppError({ cause: e }))
+ * // Converts any error type to AppError
+ */
+declare function mapError<T, E extends Error, E2 extends Error>(value: E | T, fn: (e: E) => E2): E2 | T;
+/**
+ * Chain another errore-returning function.
+ * If the value is an error, returns it unchanged.
+ * If successful, runs fn and returns its result.
+ *
+ * @example
+ * const result = andThen(userId, id => fetchUser(id))
+ * // If userId is ValidationError, result is ValidationError
+ * // If userId is string, result is whatever fetchUser returns
+ */
+declare function andThen<T, U, E extends Error, E2 extends Error>(value: E | T, fn: (v: T) => E2 | U): E | E2 | U;
+/**
+ * Async version of andThen.
+ *
+ * @example
+ * const result = await andThenAsync(userId, async id => {
+ *   const user = await fetchUser(id)
+ *   return user
+ * })
+ */
+declare function andThenAsync<T, U, E extends Error, E2 extends Error>(value: E | T, fn: (v: T) => Promise<E2 | U>): Promise<E | E2 | U>;
+/**
+ * Run a side effect if the value is not an error.
+ * Returns the original value unchanged.
+ *
+ * @example
+ * const result = tap(user, u => console.log('Got user:', u.name))
+ */
+declare function tap<T, E extends Error>(value: E | T, fn: (v: T) => void): E | T;
+/**
+ * Async version of tap.
+ *
+ * @example
+ * const result = await tapAsync(user, async u => {
+ *   await logToService(u)
+ * })
+ */
+declare function tapAsync<T, E extends Error>(value: E | T, fn: (v: T) => Promise<void>): Promise<E | T>;
+
+/**
+ * Extract the value or throw if it's an error.
+ *
+ * @example
+ * const user = unwrap(result) // throws if result is an error
+ * console.log(user.name)
+ *
+ * @example With custom message
+ * const user = unwrap(result, 'Failed to get user')
+ */
+declare function unwrap<T, E extends Error>(value: E | T, message?: string): T;
+/**
+ * Extract the value or return a fallback if it's an error.
+ *
+ * @example
+ * const name = unwrapOr(result, 'Anonymous')
+ * // If result is User, returns user
+ * // If result is Error, returns 'Anonymous'
+ */
+declare function unwrapOr<T, U, E extends Error>(value: E | T, fallback: U): T | U;
+/**
+ * Pattern match on an errore value.
+ * Handles both success and error cases.
+ *
+ * @example
+ * const message = match(result, {
+ *   ok: user => `Hello, ${user.name}`,
+ *   err: error => `Failed: ${error.message}`
+ * })
+ */
+declare function match<T, E extends Error, R>(value: E | T, handlers: {
+    ok: (v: T) => R;
+    err: (e: E) => R;
+}): R;
+/**
+ * Partition an array of errore values into [successes, errors].
+ *
+ * @example
+ * const results = await Promise.all(ids.map(fetchUser))
+ * const [users, errors] = partition(results)
+ */
+declare function partition<T, E extends Error>(values: (E | T)[]): [T[], E[]];
+/**
+ * Flatten a nested errore: (E1 | (E2 | T)) becomes (E1 | E2 | T).
+ * Useful when chaining operations that can fail.
+ *
+ * @example
+ * const nested: NetworkError | (ParseError | User) = await fetchAndParse()
+ * const flat: NetworkError | ParseError | User = flatten(nested)
+ */
+declare function flatten<T, E1 extends Error, E2 extends Error>(value: E1 | (E2 | T)): E1 | E2 | T;
+
+export { type EnsureNotError, type Errore, type InferError, type InferValue, TaggedError, type TaggedErrorClass, type TaggedErrorInstance, UnhandledError, andThen, andThenAsync, flatten, isError, isOk, isTaggedError, map, mapError, match, matchError, matchErrorPartial, partition, tap, tapAsync, tryAsync, tryFn, unwrap, unwrapOr };

package/dist/index.d.ts

@@ -1,3 +1,291 @@
-declare const version = "0.0.1";
+/**
+ * The core type: either an Error or a value T.
+ * Unlike Result<T, E>, this is just a union - no wrapper needed.
+ */
+type Errore<T, E extends Error = Error> = E | T;
+/**
+ * Extract the error type from an Errore union.
+ * @example InferError<NetworkError | User> // NetworkError
+ */
+type InferError<T> = T extends Error ? T : never;
+/**
+ * Extract the value type from an Errore union.
+ * @example InferValue<NetworkError | User> // User
+ */
+type InferValue<T> = T extends Error ? never : T;
+/**
+ * Utility to ensure T is not an Error type.
+ * Used to prevent ambiguous unions like Error | Error.
+ */
+type EnsureNotError<T> = T extends Error ? 'Error: Value type T cannot extend Error - this would make the union ambiguous' : T;
 
-export { version };
+/**
+ * Any tagged error (for generic constraints)
+ */
+type AnyTaggedError = Error & {
+    readonly _tag: string;
+};
+/**
+ * Instance type produced by TaggedError factory
+ */
+type TaggedErrorInstance<Tag extends string, Props> = Error & {
+    readonly _tag: Tag;
+    toJSON(): object;
+} & Readonly<Props>;
+/**
+ * Class type produced by TaggedError factory
+ */
+type TaggedErrorClass<Tag extends string, Props> = {
+    new (...args: keyof Props extends never ? [args?: {}] : [args: Props]): TaggedErrorInstance<Tag, Props>;
+    /** Type guard for this error class */
+    is(value: unknown): value is TaggedErrorInstance<Tag, Props>;
+};
+/**
+ * Factory for tagged error classes with discriminated _tag property.
+ * Enables exhaustive pattern matching on error unions.
+ *
+ * @example
+ * class NotFoundError extends TaggedError("NotFoundError")<{
+ *   id: string;
+ *   message: string;
+ * }>() {}
+ *
+ * const err = new NotFoundError({ id: "123", message: "Not found" });
+ * err._tag    // "NotFoundError"
+ * err.id      // "123"
+ *
+ * // Type guard
+ * NotFoundError.is(err) // true
+ * TaggedError.is(err)   // true (any tagged error)
+ */
+declare const TaggedError: {
+    <Tag extends string>(tag: Tag): <Props extends Record<string, unknown> = {}>() => TaggedErrorClass<Tag, Props>;
+    /** Type guard for any TaggedError instance */
+    is(value: unknown): value is AnyTaggedError;
+};
+/**
+ * Type guard for tagged error instances.
+ *
+ * @example
+ * if (isTaggedError(value)) { value._tag }
+ */
+declare const isTaggedError: (value: unknown) => value is AnyTaggedError;
+/**
+ * Handler map for exhaustive matching
+ */
+type MatchHandlers<E extends AnyTaggedError, R> = {
+    [K in E['_tag']]: (err: Extract<E, {
+        _tag: K;
+    }>) => R;
+};
+/**
+ * Exhaustive pattern match on tagged error union by _tag.
+ *
+ * @example
+ * matchError(err, {
+ *   NotFoundError: (e) => `Missing: ${e.id}`,
+ *   ValidationError: (e) => `Invalid: ${e.field}`,
+ * });
+ */
+declare function matchError<E extends AnyTaggedError, R>(err: E, handlers: MatchHandlers<E, R>): R;
+/**
+ * Partial pattern match with fallback for unhandled tags.
+ *
+ * @example
+ * matchErrorPartial(err, {
+ *   NotFoundError: (e) => `Missing: ${e.id}`,
+ * }, (e) => `Unknown: ${e.message}`);
+ */
+declare function matchErrorPartial<E extends AnyTaggedError, R>(err: E, handlers: Partial<MatchHandlers<E, R>>, fallback: (e: E) => R): R;
+declare const UnhandledError_base: TaggedErrorClass<"UnhandledError", {
+    message: string;
+    cause: unknown;
+}>;
+/**
+ * Default error type when catching unknown exceptions.
+ */
+declare class UnhandledError extends UnhandledError_base {
+    constructor(args: {
+        cause: unknown;
+    });
+}
+
+/**
+ * Type guard: checks if value is an Error.
+ * After this check, TypeScript narrows the type.
+ *
+ * @example
+ * const result = await fetchUser(id)
+ * if (isError(result)) {
+ *   // result is narrowed to the error type
+ *   return result
+ * }
+ * // result is narrowed to User
+ * console.log(result.name)
+ */
+declare function isError<T, E extends Error>(value: E | T): value is E;
+/**
+ * Type guard: checks if value is NOT an Error.
+ * Inverse of isError for convenience.
+ *
+ * @example
+ * const result = await fetchUser(id)
+ * if (isOk(result)) {
+ *   console.log(result.name) // result is User
+ * }
+ */
+declare function isOk<T, E extends Error>(value: E | T): value is T;
+/**
+ * Execute a sync function and return either the value or an error.
+ *
+ * @overload Simple form - wraps exceptions in UnhandledError
+ * @example
+ * const result = tryFn(() => JSON.parse(input))
+ * // result: UnhandledError | unknown
+ *
+ * @overload With custom catch - you control the error type
+ * @example
+ * const result = tryFn({
+ *   try: () => JSON.parse(input),
+ *   catch: (e) => new ParseError({ cause: e })
+ * })
+ * // result: ParseError | unknown
+ */
+declare function tryFn<T>(fn: () => T): UnhandledError | T;
+declare function tryFn<T, E extends Error>(opts: {
+    try: () => T;
+    catch: (e: unknown) => E;
+}): E | T;
+/**
+ * Execute an async function and return either the value or an error.
+ *
+ * @overload Simple form - wraps exceptions in UnhandledError
+ * @example
+ * const result = await tryAsync(() => fetch(url).then(r => r.json()))
+ * // result: UnhandledError | unknown
+ *
+ * @overload With custom catch - you control the error type
+ * @example
+ * const result = await tryAsync({
+ *   try: () => fetch(url),
+ *   catch: (e) => new NetworkError({ cause: e })
+ * })
+ * // result: NetworkError | Response
+ */
+declare function tryAsync<T>(fn: () => Promise<T>): Promise<UnhandledError | T>;
+declare function tryAsync<T, E extends Error>(opts: {
+    try: () => Promise<T>;
+    catch: (e: unknown) => E | Promise<E>;
+}): Promise<E | T>;
+
+/**
+ * Transform the value if not an error.
+ * If the value is an error, returns it unchanged.
+ *
+ * @example
+ * const result = map(user, u => u.name)
+ * // If user is User, result is string
+ * // If user is NotFoundError, result is NotFoundError
+ */
+declare function map<T, U, E extends Error>(value: E | T, fn: (v: T) => U): E | U;
+/**
+ * Transform the error if it is an error.
+ * If the value is not an error, returns it unchanged.
+ *
+ * @example
+ * const result = mapError(fetchResult, e => new AppError({ cause: e }))
+ * // Converts any error type to AppError
+ */
+declare function mapError<T, E extends Error, E2 extends Error>(value: E | T, fn: (e: E) => E2): E2 | T;
+/**
+ * Chain another errore-returning function.
+ * If the value is an error, returns it unchanged.
+ * If successful, runs fn and returns its result.
+ *
+ * @example
+ * const result = andThen(userId, id => fetchUser(id))
+ * // If userId is ValidationError, result is ValidationError
+ * // If userId is string, result is whatever fetchUser returns
+ */
+declare function andThen<T, U, E extends Error, E2 extends Error>(value: E | T, fn: (v: T) => E2 | U): E | E2 | U;
+/**
+ * Async version of andThen.
+ *
+ * @example
+ * const result = await andThenAsync(userId, async id => {
+ *   const user = await fetchUser(id)
+ *   return user
+ * })
+ */
+declare function andThenAsync<T, U, E extends Error, E2 extends Error>(value: E | T, fn: (v: T) => Promise<E2 | U>): Promise<E | E2 | U>;
+/**
+ * Run a side effect if the value is not an error.
+ * Returns the original value unchanged.
+ *
+ * @example
+ * const result = tap(user, u => console.log('Got user:', u.name))
+ */
+declare function tap<T, E extends Error>(value: E | T, fn: (v: T) => void): E | T;
+/**
+ * Async version of tap.
+ *
+ * @example
+ * const result = await tapAsync(user, async u => {
+ *   await logToService(u)
+ * })
+ */
+declare function tapAsync<T, E extends Error>(value: E | T, fn: (v: T) => Promise<void>): Promise<E | T>;
+
+/**
+ * Extract the value or throw if it's an error.
+ *
+ * @example
+ * const user = unwrap(result) // throws if result is an error
+ * console.log(user.name)
+ *
+ * @example With custom message
+ * const user = unwrap(result, 'Failed to get user')
+ */
+declare function unwrap<T, E extends Error>(value: E | T, message?: string): T;
+/**
+ * Extract the value or return a fallback if it's an error.
+ *
+ * @example
+ * const name = unwrapOr(result, 'Anonymous')
+ * // If result is User, returns user
+ * // If result is Error, returns 'Anonymous'
+ */
+declare function unwrapOr<T, U, E extends Error>(value: E | T, fallback: U): T | U;
+/**
+ * Pattern match on an errore value.
+ * Handles both success and error cases.
+ *
+ * @example
+ * const message = match(result, {
+ *   ok: user => `Hello, ${user.name}`,
+ *   err: error => `Failed: ${error.message}`
+ * })
+ */
+declare function match<T, E extends Error, R>(value: E | T, handlers: {
+    ok: (v: T) => R;
+    err: (e: E) => R;
+}): R;
+/**
+ * Partition an array of errore values into [successes, errors].
+ *
+ * @example
+ * const results = await Promise.all(ids.map(fetchUser))
+ * const [users, errors] = partition(results)
+ */
+declare function partition<T, E extends Error>(values: (E | T)[]): [T[], E[]];
+/**
+ * Flatten a nested errore: (E1 | (E2 | T)) becomes (E1 | E2 | T).
+ * Useful when chaining operations that can fail.
+ *
+ * @example
+ * const nested: NetworkError | (ParseError | User) = await fetchAndParse()
+ * const flat: NetworkError | ParseError | User = flatten(nested)
+ */
+declare function flatten<T, E1 extends Error, E2 extends Error>(value: E1 | (E2 | T)): E1 | E2 | T;
+
+export { type EnsureNotError, type Errore, type InferError, type InferValue, TaggedError, type TaggedErrorClass, type TaggedErrorInstance, UnhandledError, andThen, andThenAsync, flatten, isError, isOk, isTaggedError, map, mapError, match, matchError, matchErrorPartial, partition, tap, tapAsync, tryAsync, tryFn, unwrap, unwrapOr };

package/dist/index.js

@@ -1,3 +1,4 @@
+"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -19,11 +20,224 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  version: () => version
+  TaggedError: () => TaggedError,
+  UnhandledError: () => UnhandledError,
+  andThen: () => andThen,
+  andThenAsync: () => andThenAsync,
+  flatten: () => flatten,
+  isError: () => isError,
+  isOk: () => isOk,
+  isTaggedError: () => isTaggedError,
+  map: () => map,
+  mapError: () => mapError,
+  match: () => match,
+  matchError: () => matchError,
+  matchErrorPartial: () => matchErrorPartial,
+  partition: () => partition,
+  tap: () => tap,
+  tapAsync: () => tapAsync,
+  tryAsync: () => tryAsync,
+  tryFn: () => tryFn,
+  unwrap: () => unwrap,
+  unwrapOr: () => unwrapOr
 });
 module.exports = __toCommonJS(index_exports);
-var version = "0.0.1";
+
+// src/error.ts
+var serializeCause = (cause) => {
+  if (cause instanceof Error) {
+    return { name: cause.name, message: cause.message, stack: cause.stack };
+  }
+  return cause;
+};
+var isAnyTaggedError = (value) => {
+  return value instanceof Error && "_tag" in value && typeof value._tag === "string";
+};
+var TaggedError = Object.assign(
+  (tag) => () => {
+    class Base extends Error {
+      _tag = tag;
+      /** Type guard for this error class */
+      static is(value) {
+        return value instanceof Base;
+      }
+      constructor(args) {
+        const message = args && "message" in args && typeof args.message === "string" ? args.message : void 0;
+        const cause = args && "cause" in args ? args.cause : void 0;
+        super(message, cause !== void 0 ? { cause } : void 0);
+        if (args) {
+          Object.assign(this, args);
+        }
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = tag;
+        if (cause instanceof Error && cause.stack) {
+          const indented = cause.stack.replace(/\n/g, "\n  ");
+          this.stack = `${this.stack}
+Caused by: ${indented}`;
+        }
+      }
+      toJSON() {
+        return {
+          ...this,
+          _tag: this._tag,
+          name: this.name,
+          message: this.message,
+          cause: serializeCause(this.cause),
+          stack: this.stack
+        };
+      }
+    }
+    return Base;
+  },
+  { is: isAnyTaggedError }
+);
+var isTaggedError = isAnyTaggedError;
+function matchError(err, handlers) {
+  const handler = handlers[err._tag];
+  return handler(err);
+}
+function matchErrorPartial(err, handlers, fallback) {
+  const handler = handlers[err._tag];
+  if (handler) {
+    return handler(err);
+  }
+  return fallback(err);
+}
+var UnhandledError = class extends TaggedError("UnhandledError")() {
+  constructor(args) {
+    const message = args.cause instanceof Error ? `Unhandled exception: ${args.cause.message}` : `Unhandled exception: ${String(args.cause)}`;
+    super({ message, cause: args.cause });
+  }
+};
+
+// src/core.ts
+function isError(value) {
+  return value instanceof Error;
+}
+function isOk(value) {
+  return !(value instanceof Error);
+}
+function tryFn(fnOrOpts) {
+  if (typeof fnOrOpts === "function") {
+    try {
+      return fnOrOpts();
+    } catch (cause) {
+      return new UnhandledError({ cause });
+    }
+  }
+  try {
+    return fnOrOpts.try();
+  } catch (cause) {
+    return fnOrOpts.catch(cause);
+  }
+}
+async function tryAsync(fnOrOpts) {
+  if (typeof fnOrOpts === "function") {
+    try {
+      return await fnOrOpts();
+    } catch (cause) {
+      return new UnhandledError({ cause });
+    }
+  }
+  try {
+    return await fnOrOpts.try();
+  } catch (cause) {
+    return await fnOrOpts.catch(cause);
+  }
+}
+
+// src/transform.ts
+function map(value, fn) {
+  if (value instanceof Error) {
+    return value;
+  }
+  return fn(value);
+}
+function mapError(value, fn) {
+  if (value instanceof Error) {
+    return fn(value);
+  }
+  return value;
+}
+function andThen(value, fn) {
+  if (value instanceof Error) {
+    return value;
+  }
+  return fn(value);
+}
+async function andThenAsync(value, fn) {
+  if (value instanceof Error) {
+    return value;
+  }
+  return fn(value);
+}
+function tap(value, fn) {
+  if (!(value instanceof Error)) {
+    fn(value);
+  }
+  return value;
+}
+async function tapAsync(value, fn) {
+  if (!(value instanceof Error)) {
+    await fn(value);
+  }
+  return value;
+}
+
+// src/extract.ts
+function unwrap(value, message) {
+  if (value instanceof Error) {
+    throw new Error(message ?? `Unwrap called on error: ${value.message}`, { cause: value });
+  }
+  return value;
+}
+function unwrapOr(value, fallback) {
+  if (value instanceof Error) {
+    return fallback;
+  }
+  return value;
+}
+function match(value, handlers) {
+  if (value instanceof Error) {
+    return handlers.err(value);
+  }
+  return handlers.ok(value);
+}
+function partition(values) {
+  const oks = [];
+  const errs = [];
+  for (const v of values) {
+    if (v instanceof Error) {
+      errs.push(v);
+    } else {
+      oks.push(v);
+    }
+  }
+  return [oks, errs];
+}
+function flatten(value) {
+  return value;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  version
+  TaggedError,
+  UnhandledError,
+  andThen,
+  andThenAsync,
+  flatten,
+  isError,
+  isOk,
+  isTaggedError,
+  map,
+  mapError,
+  match,
+  matchError,
+  matchErrorPartial,
+  partition,
+  tap,
+  tapAsync,
+  tryAsync,
+  tryFn,
+  unwrap,
+  unwrapOr
 });

package/dist/index.mjs

@@ -1,5 +1,197 @@
-// src/index.ts
-var version = "0.0.1";
+// src/error.ts
+var serializeCause = (cause) => {
+  if (cause instanceof Error) {
+    return { name: cause.name, message: cause.message, stack: cause.stack };
+  }
+  return cause;
+};
+var isAnyTaggedError = (value) => {
+  return value instanceof Error && "_tag" in value && typeof value._tag === "string";
+};
+var TaggedError = Object.assign(
+  (tag) => () => {
+    class Base extends Error {
+      _tag = tag;
+      /** Type guard for this error class */
+      static is(value) {
+        return value instanceof Base;
+      }
+      constructor(args) {
+        const message = args && "message" in args && typeof args.message === "string" ? args.message : void 0;
+        const cause = args && "cause" in args ? args.cause : void 0;
+        super(message, cause !== void 0 ? { cause } : void 0);
+        if (args) {
+          Object.assign(this, args);
+        }
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = tag;
+        if (cause instanceof Error && cause.stack) {
+          const indented = cause.stack.replace(/\n/g, "\n  ");
+          this.stack = `${this.stack}
+Caused by: ${indented}`;
+        }
+      }
+      toJSON() {
+        return {
+          ...this,
+          _tag: this._tag,
+          name: this.name,
+          message: this.message,
+          cause: serializeCause(this.cause),
+          stack: this.stack
+        };
+      }
+    }
+    return Base;
+  },
+  { is: isAnyTaggedError }
+);
+var isTaggedError = isAnyTaggedError;
+function matchError(err, handlers) {
+  const handler = handlers[err._tag];
+  return handler(err);
+}
+function matchErrorPartial(err, handlers, fallback) {
+  const handler = handlers[err._tag];
+  if (handler) {
+    return handler(err);
+  }
+  return fallback(err);
+}
+var UnhandledError = class extends TaggedError("UnhandledError")() {
+  constructor(args) {
+    const message = args.cause instanceof Error ? `Unhandled exception: ${args.cause.message}` : `Unhandled exception: ${String(args.cause)}`;
+    super({ message, cause: args.cause });
+  }
+};
+
+// src/core.ts
+function isError(value) {
+  return value instanceof Error;
+}
+function isOk(value) {
+  return !(value instanceof Error);
+}
+function tryFn(fnOrOpts) {
+  if (typeof fnOrOpts === "function") {
+    try {
+      return fnOrOpts();
+    } catch (cause) {
+      return new UnhandledError({ cause });
+    }
+  }
+  try {
+    return fnOrOpts.try();
+  } catch (cause) {
+    return fnOrOpts.catch(cause);
+  }
+}
+async function tryAsync(fnOrOpts) {
+  if (typeof fnOrOpts === "function") {
+    try {
+      return await fnOrOpts();
+    } catch (cause) {
+      return new UnhandledError({ cause });
+    }
+  }
+  try {
+    return await fnOrOpts.try();
+  } catch (cause) {
+    return await fnOrOpts.catch(cause);
+  }
+}
+
+// src/transform.ts
+function map(value, fn) {
+  if (value instanceof Error) {
+    return value;
+  }
+  return fn(value);
+}
+function mapError(value, fn) {
+  if (value instanceof Error) {
+    return fn(value);
+  }
+  return value;
+}
+function andThen(value, fn) {
+  if (value instanceof Error) {
+    return value;
+  }
+  return fn(value);
+}
+async function andThenAsync(value, fn) {
+  if (value instanceof Error) {
+    return value;
+  }
+  return fn(value);
+}
+function tap(value, fn) {
+  if (!(value instanceof Error)) {
+    fn(value);
+  }
+  return value;
+}
+async function tapAsync(value, fn) {
+  if (!(value instanceof Error)) {
+    await fn(value);
+  }
+  return value;
+}
+
+// src/extract.ts
+function unwrap(value, message) {
+  if (value instanceof Error) {
+    throw new Error(message ?? `Unwrap called on error: ${value.message}`, { cause: value });
+  }
+  return value;
+}
+function unwrapOr(value, fallback) {
+  if (value instanceof Error) {
+    return fallback;
+  }
+  return value;
+}
+function match(value, handlers) {
+  if (value instanceof Error) {
+    return handlers.err(value);
+  }
+  return handlers.ok(value);
+}
+function partition(values) {
+  const oks = [];
+  const errs = [];
+  for (const v of values) {
+    if (v instanceof Error) {
+      errs.push(v);
+    } else {
+      oks.push(v);
+    }
+  }
+  return [oks, errs];
+}
+function flatten(value) {
+  return value;
+}
 export {
-  version
+  TaggedError,
+  UnhandledError,
+  andThen,
+  andThenAsync,
+  flatten,
+  isError,
+  isOk,
+  isTaggedError,
+  map,
+  mapError,
+  match,
+  matchError,
+  matchErrorPartial,
+  partition,
+  tap,
+  tapAsync,
+  tryAsync,
+  tryFn,
+  unwrap,
+  unwrapOr
 };

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "errore",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Type-safe errors as values for TypeScript. Like Go, but with full type inference.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.js"
     }
   },
   "files": [