go-go-try 7.4.0 → 8.0.0

package/README.md

@@ -408,15 +408,50 @@ const [errors, results] = await goTryAll([
 // - Limit expensive computation resources
 ```
 
-### `goTryAllRaw<T>(items, options?)`
+### `goTryAllRaw<T, E>(items, options?)`
 
 Like `goTryAll`, but returns raw Error objects instead of error messages.
+Non-tagged errors are wrapped in `UnknownError` by default (consistent with `goTryRaw`).
+Tagged errors pass through unchanged.
+
+Supports the same `errorClass` and `systemErrorClass` options as `goTryRaw`, plus `concurrency` control.
 
 ```ts
-function goTryAllRaw<T extends readonly unknown[]>(
+interface GoTryAllRawOptions<E> {
+  concurrency?: number
+  // errorClass and systemErrorClass are mutually exclusive
+  errorClass?: ErrorConstructor<E>        // Wrap ALL errors
+  systemErrorClass?: ErrorConstructor<E>  // Only wrap non-tagged errors
+}
+
+function goTryAllRaw<T extends readonly unknown[], E = UnknownError>(
   items: { [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>) },
-  options?: GoTryAllOptions
-): Promise<[{ [K in keyof T]: Error | undefined }, { [K in keyof T]: T[K] | undefined }]>
+  options?: GoTryAllRawOptions<E>
+): Promise<[{ [K in keyof T]: E | undefined }, { [K in keyof T]: T[K] | undefined }]>
+```
+
+**Example:**
+```ts
+const DatabaseError = taggedError('DatabaseError')
+
+// Default behavior - non-tagged errors wrapped in UnknownError
+const [errors1] = await goTryAllRaw([
+  fetchUser(1),
+  fetchUser(2),
+])
+
+// Wrap all errors in DatabaseError
+const [errors2] = await goTryAllRaw([
+  fetchUser(1),
+  fetchUser(2),
+], { errorClass: DatabaseError })
+
+// Combine concurrency control with errorClass
+const [errors3] = await goTryAllRaw([
+  () => fetchUser(1),
+  () => fetchUser(2),
+  () => fetchUser(3),
+], { concurrency: 2, errorClass: DatabaseError })
 ```
 
 ### `goTryOr<T>(value, defaultValue)`
@@ -591,6 +626,12 @@ type GoTryRawOptions<E> =
   | { errorClass: ErrorConstructor<E>; systemErrorClass?: never }
   | { errorClass?: never; systemErrorClass: ErrorConstructor<E> }
   | { errorClass?: never; systemErrorClass?: never }
+
+// Options for goTryAllRaw (includes concurrency + error class options)
+type GoTryAllRawOptions<E> =
+  | { concurrency?: number; errorClass: ErrorConstructor<E>; systemErrorClass?: never }
+  | { concurrency?: number; errorClass?: never; systemErrorClass: ErrorConstructor<E> }
+  | { concurrency?: number; errorClass?: never; systemErrorClass?: never }
 ```
 
 ## License

package/dist/index.cjs

@@ -28,7 +28,7 @@ function getErrorMessage(error) {
     return String(error);
   }
 }
-function isPromise(value) {
+function isPromise$1(value) {
   return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
 }
 function isError(value) {
@@ -41,7 +41,7 @@ function resolveDefault(defaultValue) {
 function goTry(value) {
   try {
     const result = typeof value === "function" ? value() : value;
-    if (isPromise(result)) {
+    if (isPromise$1(result)) {
       return result.then((resolvedValue) => success(resolvedValue)).catch((err) => failure(getErrorMessage(err)));
     }
     return success(result);
@@ -63,7 +63,7 @@ function taggedError(tag) {
 
 const UnknownError = taggedError("UnknownError");
 
-function isTaggedError(err) {
+function isTaggedError$1(err) {
   return isError(err) && "_tag" in err && typeof err._tag === "string";
 }
 function goTryRaw(value, options) {
@@ -80,7 +80,7 @@ function goTryRaw(value, options) {
       return new errorClass(String(err));
     }
     if (actualSystemErrorClass) {
-      if (isTaggedError(err)) {
+      if (isTaggedError$1(err)) {
         return err;
       }
       if (err === void 0) {
@@ -98,7 +98,7 @@ function goTryRaw(value, options) {
   };
   try {
     const result = typeof value === "function" ? value() : value;
-    if (isPromise(result)) {
+    if (isPromise$1(result)) {
       return result.then((resolvedValue) => success(resolvedValue)).catch((err) => failure(wrapError(err)));
     }
     return success(result);
@@ -110,7 +110,7 @@ function goTryRaw(value, options) {
 function goTryOr(value, defaultValue) {
   try {
     const result = typeof value === "function" ? value() : value;
-    if (isPromise(result)) {
+    if (isPromise$1(result)) {
       return result.then((resolvedValue) => success(resolvedValue)).catch((err) => [getErrorMessage(err), resolveDefault(defaultValue)]);
     }
     return success(result);
@@ -119,6 +119,31 @@ function goTryOr(value, defaultValue) {
   }
 }
 
+function isTaggedError(err) {
+  return isError(err) && "_tag" in err && typeof err._tag === "string";
+}
+function wrapError(err, errorClass, systemErrorClass) {
+  if (errorClass) {
+    if (err === void 0) {
+      return new errorClass("undefined");
+    }
+    if (isError(err)) {
+      return new errorClass(err.message, { cause: err });
+    }
+    return new errorClass(String(err));
+  }
+  const actualSystemErrorClass = systemErrorClass ?? UnknownError;
+  if (isTaggedError(err)) {
+    return err;
+  }
+  if (err === void 0) {
+    return new actualSystemErrorClass("undefined");
+  }
+  if (isError(err)) {
+    return new actualSystemErrorClass(err.message, { cause: err });
+  }
+  return new actualSystemErrorClass(String(err));
+}
 async function runWithConcurrency(items, concurrency) {
   if (items.length === 0) {
     return [];
@@ -166,6 +191,7 @@ async function goTryAll(items, options) {
   return [errors, results];
 }
 async function goTryAllRaw(items, options) {
+  const { errorClass, systemErrorClass } = options || {};
   const settled = await runWithConcurrency(items, options?.concurrency ?? 0);
   const errors = [];
   const results = [];
@@ -176,7 +202,7 @@ async function goTryAllRaw(items, options) {
       results[i] = item.value;
     } else {
       const reason = item.reason;
-      errors[i] = isError(reason) ? reason : new Error(String(reason));
+      errors[i] = wrapError(reason, errorClass, systemErrorClass);
       results[i] = void 0;
     }
   }
@@ -195,10 +221,72 @@ function assert(condition, errorOrClass, message) {
   }
 }
 
+function isPromise(value) {
+  return value instanceof Promise;
+}
+function isErrorConstructor(error) {
+  return typeof error === "function" && error.prototype !== void 0 && error.prototype instanceof Error;
+}
+function throwError(value, error) {
+  if (isErrorConstructor(error)) {
+    throw new error(String(value), { cause: value });
+  }
+  throw error(value);
+}
+function ensure(value, predicate, error = UnknownError) {
+  if (typeof value === "function") {
+    const result = value();
+    if (isPromise(result)) {
+      return result.then((resolved) => {
+        if (!predicate(resolved)) {
+          throwError(resolved, error);
+        }
+        return resolved;
+      });
+    }
+    if (!predicate(result)) {
+      throwError(result, error);
+    }
+    return result;
+  }
+  if (isPromise(value)) {
+    return value.then((resolved) => {
+      if (!predicate(resolved)) {
+        throwError(resolved, error);
+      }
+      return resolved;
+    });
+  }
+  if (!predicate(value)) {
+    throwError(value, error);
+  }
+  return value;
+}
+
+function goElse(value, defaultValue) {
+  try {
+    const result = typeof value === "function" ? value() : value;
+    if (isPromise$1(result)) {
+      return result.then((resolvedValue) => [void 0, resolvedValue]).catch((err) => {
+        const error = err instanceof Error ? err : new Error(String(err));
+        return [error, resolveDefault(defaultValue)];
+      });
+    }
+    return [void 0, result];
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    return [error, resolveDefault(defaultValue)];
+  }
+}
+
 exports.UnknownError = UnknownError;
 exports.assert = assert;
 exports.assertNever = assertNever;
+exports.ensure = ensure;
 exports.failure = failure;
+exports.go = goTryRaw;
+exports.goAll = goTryAllRaw;
+exports.goElse = goElse;
 exports.goTry = goTry;
 exports.goTryAll = goTryAll;
 exports.goTryAllRaw = goTryAllRaw;

package/dist/index.d.cts

@@ -4,7 +4,7 @@
 type Success<T> = readonly [undefined, T];
 type Failure<E> = readonly [E, undefined];
 type Result<E, T> = Success<T> | Failure<E>;
-type ResultWithDefault<E, T> = readonly [E | undefined, T];
+type ResultWithDefault$1<E, T> = readonly [E | undefined, T];
 type MaybePromise<T> = T | Promise<T>;
 /**
  * Base interface for tagged errors.
@@ -25,7 +25,7 @@ interface GoTryAllOptions {
 /**
  * Type for error constructors that can be used with goTryRaw.
  */
-type ErrorConstructor<E> = new (message: string, options?: {
+type ErrorConstructor$1<E> = new (message: string, options?: {
     cause?: unknown;
 }) => E;
 /**
@@ -33,15 +33,33 @@ type ErrorConstructor<E> = new (message: string, options?: {
  * errorClass and systemErrorClass are mutually exclusive - you can only provide one.
  */
 type GoTryRawOptions<E = Error> = {
-    errorClass: ErrorConstructor<E>;
+    errorClass: ErrorConstructor$1<E>;
     systemErrorClass?: never;
 } | {
     errorClass?: never;
-    systemErrorClass: ErrorConstructor<E>;
+    systemErrorClass: ErrorConstructor$1<E>;
 } | {
     errorClass?: never;
     systemErrorClass?: never;
 };
+/**
+ * Options for goTryAllRaw function.
+ * Includes concurrency control and error class options.
+ * errorClass and systemErrorClass are mutually exclusive.
+ */
+type GoTryAllRawOptions<E = Error> = {
+    concurrency?: number;
+    errorClass: ErrorConstructor$1<E>;
+    systemErrorClass?: never;
+} | {
+    concurrency?: number;
+    errorClass?: never;
+    systemErrorClass: ErrorConstructor$1<E>;
+} | {
+    concurrency?: number;
+    errorClass?: never;
+    systemErrorClass?: never;
+};
 /**
  * Creates a union type from multiple tagged error classes.
  *
@@ -55,8 +73,8 @@ type GoTryRawOptions<E = Error> = {
  * type AppError = TaggedUnion<[typeof DatabaseError, typeof NetworkError]>
  * // Equivalent to: DatabaseError | NetworkError
  */
-type TaggedUnion<T extends readonly ErrorConstructor<unknown>[]> = {
-    [K in keyof T]: T[K] extends ErrorConstructor<infer E> ? E : never;
+type TaggedUnion<T extends readonly ErrorConstructor$1<unknown>[]> = {
+    [K in keyof T]: T[K] extends ErrorConstructor$1<infer E> ? E : never;
 }[number];
 
 /**
@@ -180,11 +198,11 @@ declare function goTryRaw<T, E = InstanceType<typeof UnknownError>>(value: T, op
  *   name: 'Guest'
  * }))
  */
-declare function goTryOr<T>(fn: () => never, defaultValue: T | (() => T)): ResultWithDefault<string, T>;
-declare function goTryOr<T>(fn: () => Promise<T>, defaultValue: T | (() => T)): Promise<ResultWithDefault<string, T>>;
-declare function goTryOr<T>(promise: Promise<T>, defaultValue: T | (() => T)): Promise<ResultWithDefault<string, T>>;
-declare function goTryOr<T>(fn: () => T, defaultValue: T | (() => T)): ResultWithDefault<string, T>;
-declare function goTryOr<T>(value: T, defaultValue: T | (() => T)): ResultWithDefault<string, T>;
+declare function goTryOr<T>(fn: () => never, defaultValue: T | (() => T)): ResultWithDefault$1<string, T>;
+declare function goTryOr<T>(fn: () => Promise<T>, defaultValue: T | (() => T)): Promise<ResultWithDefault$1<string, T>>;
+declare function goTryOr<T>(promise: Promise<T>, defaultValue: T | (() => T)): Promise<ResultWithDefault$1<string, T>>;
+declare function goTryOr<T>(fn: () => T, defaultValue: T | (() => T)): ResultWithDefault$1<string, T>;
+declare function goTryOr<T>(value: T, defaultValue: T | (() => T)): ResultWithDefault$1<string, T>;
 
 /**
  * Executes multiple promises or factory functions in parallel (or with limited concurrency)
@@ -227,18 +245,25 @@ declare function goTryAll<T extends readonly unknown[]>(items: {
 }]>;
 /**
  * Like `goTryAll`, but returns raw Error objects instead of error messages.
+ * Non-tagged errors are wrapped in `UnknownError` by default (consistent with `goTryRaw`).
+ * Tagged errors pass through unchanged.
+ *
+ * Supports `errorClass` and `systemErrorClass` options (mutually exclusive):
+ * - `errorClass`: Wrap ALL errors in the specified class
+ * - `systemErrorClass`: Only wrap non-tagged errors (defaults to UnknownError)
  *
  * @template T The tuple type of all promise results
+ * @template E The type of the error
  * @param {readonly [...{ [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>) }]} items - Array of promises or factories
- * @param {GoTryAllOptions} options - Optional configuration
- * @returns {Promise<[{ [K in keyof T]: Error | undefined }, { [K in keyof T]: T[K] | undefined }]>}
+ * @param {GoTryAllRawOptions<E>} options - Optional configuration
+ * @returns {Promise<[{ [K in keyof T]: E | undefined }, { [K in keyof T]: T[K] | undefined }]>}
  *          A tuple where the first element is a tuple of Error objects (or undefined) and
  *          the second element is a tuple of results (or undefined), preserving input order
  */
-declare function goTryAllRaw<T extends readonly unknown[]>(items: {
+declare function goTryAllRaw<T extends readonly unknown[], E = InstanceType<typeof UnknownError>>(items: {
     [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>);
-}, options?: GoTryAllOptions): Promise<[{
-    [K in keyof T]: Error | undefined;
+}, options?: GoTryAllRawOptions<E>): Promise<[{
+    [K in keyof T]: E | undefined;
 }, {
     [K in keyof T]: T[K] | undefined;
 }]>;
@@ -319,6 +344,47 @@ declare function assert(condition: unknown, error: Error | string): asserts cond
  */
 declare function assert<T extends Error>(condition: unknown, ErrorClass: new (message: string) => T, message: string): asserts condition;
 
+/**
+ * Error class constructor type.
+ */
+type ErrorConstructor<E extends Error = Error> = new (message: string, options?: {
+    cause?: unknown;
+}) => E;
+/**
+ * Ensures a value satisfies a predicate, throwing an error if not.
+ * Returns the value if the predicate passes.
+ *
+ * Accepts sync values, promises, or functions - just like `go`.
+ *
+ * The error can be either:
+ * - An Error class constructor (instantiated with the value as cause)
+ * - A function that creates and returns an Error
+ * - If omitted, defaults to UnknownError
+ *
+ * @example
+ * ```typescript
+ * // With sync value (uses UnknownError by default)
+ * ensure(42, n => n > 0)
+ *
+ * // With promise (awaited internally)
+ * const res = await ensure(fetch('/api'), r => r.ok, RequestFailedError)
+ *
+ * // With function
+ * const res = ensure(() => parseInt('42'), n => !isNaN(n), Error)
+ *
+ * // With error factory function
+ * const res = ensure(
+ *   await fetch('/api'),
+ *   r => r.ok,
+ *   r => new Error(`HTTP ${r.status}`)
+ * )
+ * ```
+ */
+declare function ensure<T>(value: Promise<T>, predicate: (value: T) => boolean, error?: ErrorConstructor<Error> | ((value: T) => Error)): Promise<T>;
+declare function ensure<T>(fn: () => Promise<T>, predicate: (value: T) => boolean, error?: ErrorConstructor<Error> | ((value: T) => Error)): Promise<T>;
+declare function ensure<T>(fn: () => T, predicate: (value: T) => boolean, error?: ErrorConstructor<Error> | ((value: T) => Error)): T;
+declare function ensure<T>(value: T, predicate: (value: T) => boolean, error?: ErrorConstructor<Error> | ((value: T) => Error)): T;
+
 declare function isSuccess<E, T>(result: Result<E, T>): result is Success<T>;
 declare function isFailure<E, T>(result: Result<E, T>): result is Failure<E>;
 declare function success<T>(value: T): Success<T>;
@@ -350,6 +416,40 @@ declare function failure<E>(error: E): Failure<E>;
  */
 declare function assertNever(value: never): never;
 
-export { UnknownError, assert, assertNever, failure, goTry, goTryAll, goTryAllRaw, goTryOr, goTryRaw, isFailure, isSuccess, success, taggedError };
-export type { ErrorConstructor, Failure, GoTryAllOptions, GoTryRawOptions, MaybePromise, Result, ResultWithDefault, Success, TaggedError, TaggedUnion };
+/**
+ * Result type with Error and a default value.
+ * On error, returns [Error, DefaultT]
+ * On success, returns [undefined, T]
+ */
+type ResultWithDefault<E, T, D = T> = readonly [E, D] | readonly [undefined, T];
+/**
+ * Executes a function, promise, or value and returns a Result type with a fallback default.
+ * If an error occurs, it returns the actual Error object and the default value.
+ *
+ * @template T The type of the successful result
+ * @template D The type of the default value (defaults to T)
+ * @param {T | Promise<T> | (() => T | Promise<T>)} value - The value, promise, or function to execute
+ * @param {D | (() => D)} defaultValue - The default value or a function to compute it (only called on failure)
+ * @returns {ResultWithDefault<Error, T, D> | Promise<ResultWithDefault<Error, T, D>>} A tuple of [error, value] or Promise thereof
+ *
+ * @example
+ * // With a static default
+ * const [err, config] = goElse(() => JSON.parse('invalid'), { port: 3000 })
+ * // err is the Error object, config is { port: 3000 }
+ *
+ * @example
+ * // With a computed default (lazy evaluation)
+ * const [err, user] = await goElse(fetchUser(id), () => ({
+ *   id: 'anonymous',
+ *   name: 'Guest'
+ * }))
+ */
+declare function goElse<T, D = T>(fn: () => never, defaultValue: D | (() => D)): ResultWithDefault<Error, never, D>;
+declare function goElse<T, D = T>(fn: () => Promise<T>, defaultValue: D | (() => D)): Promise<ResultWithDefault<Error, T, D>>;
+declare function goElse<T, D = T>(promise: Promise<T>, defaultValue: D | (() => D)): Promise<ResultWithDefault<Error, T, D>>;
+declare function goElse<T, D = T>(fn: () => T, defaultValue: D | (() => D)): ResultWithDefault<Error, T, D>;
+declare function goElse<T, D = T>(value: T, defaultValue: D | (() => D)): ResultWithDefault<Error, T, D>;
+
+export { UnknownError, assert, assertNever, ensure, failure, goTryRaw as go, goTryAllRaw as goAll, goElse, goTry, goTryAll, goTryAllRaw, goTryOr, goTryRaw, isFailure, isSuccess, success, taggedError };
+export type { ErrorConstructor$1 as ErrorConstructor, Failure, GoTryAllOptions, GoTryAllRawOptions, GoTryRawOptions, MaybePromise, Result, ResultWithDefault$1 as ResultWithDefault, Success, TaggedError, TaggedUnion };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","sources":["../src/types.ts","../src/goTry.ts","../src/unknown-error.ts","../src/goTryRaw.ts","../src/goTryOr.ts","../src/goTryAll.ts","../src/tagged-error.ts","../src/assert.ts","../src/result-helpers.ts"],"mappings":"AAAA;;;AAIM,KAAM,OAAO;AACb,KAAM,OAAO;AACb,KAAM,MAAM,SAAS,OAAO,MAAM,OAAO;AAEzC,KAAM,iBAAiB;AAEvB,KAAM,YAAY,UAAU,OAAO;AAEzC;;;;AAIM,UAAW,WAAW;;;;;AAMtB,UAAW,eAAe;;;;;;;AAQhC;;;AAGM,KAAM,gBAAgB;;;AAO5B;;;;AAIM,KAAM,eAAe,KAAK,KAAK;gBACnB,gBAAgB;;;;sBACU,gBAAgB;;;;;AAG5D;;;;;;;;;;;;;AAaM,KAAM,WAAW,oBAAoB,gBAAgB;iCAC1B,gBAAgB;;;AC3DjD;;;;;;;;;;;;;;;;;;;;AAoBA,iBAAgB,KAAK,sBAAsB,MAAM;AACjD,iBAAgB,KAAK,cAAc,OAAO,MAAM,OAAO,CAAC,MAAM;AAC9D,iBAAgB,KAAK,aAAa,OAAO,MAAM,OAAO,CAAC,MAAM;AAC7D,iBAAgB,KAAK,kBAAkB,MAAM;AAC7C,iBAAgB,KAAK,eAAe,MAAM;;AC1B1C;;;;;;;;;;;;;;;;;AAiBA,cAAa,YAAY;;;;;;;;;;;;;ACPzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,iBAAgB,QAAQ,sBAAsB,MAAM,CAAC,KAAK;AAC1D,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,6BAA6B,eAAe,MAAM,MAAM;AACxH,iBAAgB,QAAQ,cACZ,OAAO,MAChB,OAAO,CAAC,MAAM,CAAC,KAAK;AACvB,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,aACpD,OAAO,cACR,eAAe,MACvB,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,aACb,OAAO,MACf,OAAO,CAAC,MAAM,CAAC,KAAK;AACvB,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,YACrD,OAAO,cACP,eAAe,MACvB,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,kBAAkB,MAAM,CAAC,KAAK;AACtD,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,yBAAyB,eAAe,MAAM,MAAM;AACpH,iBAAgB,QAAQ,eAAe,MAAM,CAAC,KAAK;AACnD,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,sBAAsB,eAAe,MAAM,MAAM;;AC5DjH;;;;;;;;;;;;;;;;;;;;;AAqBA,iBAAgB,OAAO,mDAAmD,iBAAiB;AAC3F,iBAAgB,OAAO,cACX,OAAO,mCAEhB,OAAO,CAAC,iBAAiB;AAC5B,iBAAgB,OAAO,aACZ,OAAO,mCAEf,OAAO,CAAC,iBAAiB;AAC5B,iBAAgB,OAAO,+CAA+C,iBAAiB;AACvF,iBAAgB,OAAO,4CAA4C,iBAAiB;;ACgBpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,iBAAsB,QAAQ;oBACH,OAAO,gBAAgB,OAAO;aAC7C,eAAe,GACxB,OAAO;;;;;AAoBV;;;;;;;;;;AAUA,iBAAsB,WAAW;oBACN,OAAO,gBAAgB,OAAO;aAC7C,eAAe,GACxB,OAAO;oBAAoB,KAAK;;;;;ACrHnC;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,iBAAgB,WAAW;;;;;;;;;;;;;AC1B3B;;;;;;;;;;;;;;;;;;;;;;AAsBA,iBAAgB,MAAM,4BAA4B,KAAK;AAEvD;;;;;;;;;;;;;;AAcA,iBAAgB,MAAM,WAAW,KAAK;;ACpCtC,iBAAgB,SAAS,eAAe,MAAM,mBAAmB,OAAO;AAIxE,iBAAgB,SAAS,eAAe,MAAM,mBAAmB,OAAO;AAIxE,iBAAgB,OAAO,eAAe,OAAO;AAI7C,iBAAgB,OAAO,eAAe,OAAO;AAI7C;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,iBAAgB,WAAW","names":[]}
+{"version":3,"file":"index.d.cts","sources":["../src/types.ts","../src/goTry.ts","../src/unknown-error.ts","../src/goTryRaw.ts","../src/goTryOr.ts","../src/goTryAll.ts","../src/tagged-error.ts","../src/assert.ts","../src/ensure.ts","../src/result-helpers.ts","../src/goElse.ts"],"mappings":"AAAA;;;AAIM,KAAM,OAAO;AACb,KAAM,OAAO;AACb,KAAM,MAAM,SAAS,OAAO,MAAM,OAAO;AAEzC,KAAMA,mBAAiB;AAEvB,KAAM,YAAY,UAAU,OAAO;AAEzC;;;;AAIM,UAAW,WAAW;;;;;AAMtB,UAAW,eAAe;;;;;;;AAQhC;;;AAGM,KAAMC,kBAAgB;;;AAO5B;;;;AAIM,KAAM,eAAe,KAAK,KAAK;gBACnBA,kBAAgB;;;;sBACUA,kBAAgB;;;;;AAG5D;;;;;AAKM,KAAM,kBAAkB,KAAK,KAAK;;gBACAA,kBAAgB;;;;;sBACUA,kBAAgB;;;;;;AAGlF;;;;;;;;;;;;;AAaM,KAAM,WAAW,oBAAoBA,kBAAgB;iCAC1BA,kBAAgB;;;ACrEjD;;;;;;;;;;;;;;;;;;;;AAoBA,iBAAgB,KAAK,sBAAsB,MAAM;AACjD,iBAAgB,KAAK,cAAc,OAAO,MAAM,OAAO,CAAC,MAAM;AAC9D,iBAAgB,KAAK,aAAa,OAAO,MAAM,OAAO,CAAC,MAAM;AAC7D,iBAAgB,KAAK,kBAAkB,MAAM;AAC7C,iBAAgB,KAAK,eAAe,MAAM;;AC1B1C;;;;;;;;;;;;;;;;;AAiBA,cAAa,YAAY;;;;;;;;;;;;;ACPzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,iBAAgB,QAAQ,sBAAsB,MAAM,CAAC,KAAK;AAC1D,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,6BAA6B,eAAe,MAAM,MAAM;AACxH,iBAAgB,QAAQ,cACZ,OAAO,MAChB,OAAO,CAAC,MAAM,CAAC,KAAK;AACvB,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,aACpD,OAAO,cACR,eAAe,MACvB,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,aACb,OAAO,MACf,OAAO,CAAC,MAAM,CAAC,KAAK;AACvB,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,YACrD,OAAO,cACP,eAAe,MACvB,OAAO,CAAC,MAAM;AACjB,iBAAgB,QAAQ,kBAAkB,MAAM,CAAC,KAAK;AACtD,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,yBAAyB,eAAe,MAAM,MAAM;AACpH,iBAAgB,QAAQ,eAAe,MAAM,CAAC,KAAK;AACnD,iBAAgB,QAAQ,QAAQ,YAAY,QAAQ,YAAY,sBAAsB,eAAe,MAAM,MAAM;;AC5DjH;;;;;;;;;;;;;;;;;;;;;AAqBA,iBAAgB,OAAO,mDAAmDD,mBAAiB;AAC3F,iBAAgB,OAAO,cACX,OAAO,mCAEhB,OAAO,CAACA,mBAAiB;AAC5B,iBAAgB,OAAO,aACZ,OAAO,mCAEf,OAAO,CAACA,mBAAiB;AAC5B,iBAAgB,OAAO,+CAA+CA,mBAAiB;AACvF,iBAAgB,OAAO,4CAA4CA,mBAAiB;;ACsDpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,iBAAsB,QAAQ;oBACH,OAAO,gBAAgB,OAAO;aAC7C,eAAe,GACxB,OAAO;;;;;AAoBV;;;;;;;;;;;;;;;;;AAiBA,iBAAsB,WAAW,mCAAmC,YAAY,QAAQ,YAAY;oBACzE,OAAO,gBAAgB,OAAO;aAC7C,kBAAkB,MAC3B,OAAO;;;;;;AClKV;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,iBAAgB,WAAW;;;;;;;;;;;;;AC1B3B;;;;;;;;;;;;;;;;;;;;;;AAsBA,iBAAgB,MAAM,4BAA4B,KAAK;AAEvD;;;;;;;;;;;;;;AAcA,iBAAgB,MAAM,WAAW,KAAK;;ACpCtC;;;AAGA,KAAK,gBAAgB,WAAW,KAAK,GAAG,KAAK;;;AAwC7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,iBAAgB,MAAM,WACd,OAAO,+CAEN,gBAAgB,CAAC,KAAK,mBAAmB,KAAK,IACpD,OAAO;AAEV,iBAAgB,MAAM,cACX,OAAO,+CAET,gBAAgB,CAAC,KAAK,mBAAmB,KAAK,IACpD,OAAO;AAEV,iBAAgB,MAAM,2DAGb,gBAAgB,CAAC,KAAK,mBAAmB,KAAK;AAGvD,iBAAgB,MAAM,wDAGb,gBAAgB,CAAC,KAAK,mBAAmB,KAAK;;AC/FvD,iBAAgB,SAAS,eAAe,MAAM,mBAAmB,OAAO;AAIxE,iBAAgB,SAAS,eAAe,MAAM,mBAAmB,OAAO;AAIxE,iBAAgB,OAAO,eAAe,OAAO;AAI7C,iBAAgB,OAAO,eAAe,OAAO;AAI7C;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,iBAAgB,WAAW;;ACzC3B;;;;;AAKM,KAAM,iBAAiB;AAE7B;;;;;;;;;;;;;;;;;;;;;;AAsBA,iBAAgB,MAAM,0DAGnB,iBAAiB,CAAC,KAAK;AAC1B,iBAAgB,MAAM,qBACX,OAAO,mCAEf,OAAO,CAAC,iBAAiB,CAAC,KAAK;AAClC,iBAAgB,MAAM,oBACZ,OAAO,mCAEd,OAAO,CAAC,iBAAiB,CAAC,KAAK;AAClC,iBAAgB,MAAM,sDAGnB,iBAAiB,CAAC,KAAK;AAC1B,iBAAgB,MAAM,mDAGnB,iBAAiB,CAAC,KAAK","names":["ResultWithDefault","ErrorConstructor"]}

package/dist/index.d.mts

@@ -4,7 +4,7 @@
 type Success<T> = readonly [undefined, T];
 type Failure<E> = readonly [E, undefined];
 type Result<E, T> = Success<T> | Failure<E>;
-type ResultWithDefault<E, T> = readonly [E | undefined, T];
+type ResultWithDefault$1<E, T> = readonly [E | undefined, T];
 type MaybePromise<T> = T | Promise<T>;
 /**
  * Base interface for tagged errors.
@@ -25,7 +25,7 @@ interface GoTryAllOptions {
 /**
  * Type for error constructors that can be used with goTryRaw.
  */
-type ErrorConstructor<E> = new (message: string, options?: {
+type ErrorConstructor$1<E> = new (message: string, options?: {
     cause?: unknown;
 }) => E;
 /**
@@ -33,15 +33,33 @@ type ErrorConstructor<E> = new (message: string, options?: {
  * errorClass and systemErrorClass are mutually exclusive - you can only provide one.
  */
 type GoTryRawOptions<E = Error> = {
-    errorClass: ErrorConstructor<E>;
+    errorClass: ErrorConstructor$1<E>;
     systemErrorClass?: never;
 } | {
     errorClass?: never;
-    systemErrorClass: ErrorConstructor<E>;
+    systemErrorClass: ErrorConstructor$1<E>;
 } | {
     errorClass?: never;
     systemErrorClass?: never;
 };
+/**
+ * Options for goTryAllRaw function.
+ * Includes concurrency control and error class options.
+ * errorClass and systemErrorClass are mutually exclusive.
+ */
+type GoTryAllRawOptions<E = Error> = {
+    concurrency?: number;
+    errorClass: ErrorConstructor$1<E>;
+    systemErrorClass?: never;
+} | {
+    concurrency?: number;
+    errorClass?: never;
+    systemErrorClass: ErrorConstructor$1<E>;
+} | {
+    concurrency?: number;
+    errorClass?: never;
+    systemErrorClass?: never;
+};
 /**
  * Creates a union type from multiple tagged error classes.
  *
@@ -55,8 +73,8 @@ type GoTryRawOptions<E = Error> = {
  * type AppError = TaggedUnion<[typeof DatabaseError, typeof NetworkError]>
  * // Equivalent to: DatabaseError | NetworkError
  */
-type TaggedUnion<T extends readonly ErrorConstructor<unknown>[]> = {
-    [K in keyof T]: T[K] extends ErrorConstructor<infer E> ? E : never;
+type TaggedUnion<T extends readonly ErrorConstructor$1<unknown>[]> = {
+    [K in keyof T]: T[K] extends ErrorConstructor$1<infer E> ? E : never;
 }[number];
 
 /**
@@ -180,11 +198,11 @@ declare function goTryRaw<T, E = InstanceType<typeof UnknownError>>(value: T, op
  *   name: 'Guest'
  * }))
  */
-declare function goTryOr<T>(fn: () => never, defaultValue: T | (() => T)): ResultWithDefault<string, T>;
-declare function goTryOr<T>(fn: () => Promise<T>, defaultValue: T | (() => T)): Promise<ResultWithDefault<string, T>>;
-declare function goTryOr<T>(promise: Promise<T>, defaultValue: T | (() => T)): Promise<ResultWithDefault<string, T>>;
-declare function goTryOr<T>(fn: () => T, defaultValue: T | (() => T)): ResultWithDefault<string, T>;
-declare function goTryOr<T>(value: T, defaultValue: T | (() => T)): ResultWithDefault<string, T>;
+declare function goTryOr<T>(fn: () => never, defaultValue: T | (() => T)): ResultWithDefault$1<string, T>;
+declare function goTryOr<T>(fn: () => Promise<T>, defaultValue: T | (() => T)): Promise<ResultWithDefault$1<string, T>>;
+declare function goTryOr<T>(promise: Promise<T>, defaultValue: T | (() => T)): Promise<ResultWithDefault$1<string, T>>;
+declare function goTryOr<T>(fn: () => T, defaultValue: T | (() => T)): ResultWithDefault$1<string, T>;
+declare function goTryOr<T>(value: T, defaultValue: T | (() => T)): ResultWithDefault$1<string, T>;
 
 /**
  * Executes multiple promises or factory functions in parallel (or with limited concurrency)
@@ -227,18 +245,25 @@ declare function goTryAll<T extends readonly unknown[]>(items: {
 }]>;
 /**
  * Like `goTryAll`, but returns raw Error objects instead of error messages.
+ * Non-tagged errors are wrapped in `UnknownError` by default (consistent with `goTryRaw`).
+ * Tagged errors pass through unchanged.
+ *
+ * Supports `errorClass` and `systemErrorClass` options (mutually exclusive):
+ * - `errorClass`: Wrap ALL errors in the specified class
+ * - `systemErrorClass`: Only wrap non-tagged errors (defaults to UnknownError)
  *
  * @template T The tuple type of all promise results
+ * @template E The type of the error
  * @param {readonly [...{ [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>) }]} items - Array of promises or factories
- * @param {GoTryAllOptions} options - Optional configuration
- * @returns {Promise<[{ [K in keyof T]: Error | undefined }, { [K in keyof T]: T[K] | undefined }]>}
+ * @param {GoTryAllRawOptions<E>} options - Optional configuration
+ * @returns {Promise<[{ [K in keyof T]: E | undefined }, { [K in keyof T]: T[K] | undefined }]>}
  *          A tuple where the first element is a tuple of Error objects (or undefined) and
  *          the second element is a tuple of results (or undefined), preserving input order
  */
-declare function goTryAllRaw<T extends readonly unknown[]>(items: {
+declare function goTryAllRaw<T extends readonly unknown[], E = InstanceType<typeof UnknownError>>(items: {
     [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>);
-}, options?: GoTryAllOptions): Promise<[{
-    [K in keyof T]: Error | undefined;
+}, options?: GoTryAllRawOptions<E>): Promise<[{
+    [K in keyof T]: E | undefined;
 }, {
     [K in keyof T]: T[K] | undefined;
 }]>;
@@ -319,6 +344,47 @@ declare function assert(condition: unknown, error: Error | string): asserts cond
  */
 declare function assert<T extends Error>(condition: unknown, ErrorClass: new (message: string) => T, message: string): asserts condition;
 
+/**
+ * Error class constructor type.
+ */
+type ErrorConstructor<E extends Error = Error> = new (message: string, options?: {
+    cause?: unknown;
+}) => E;
+/**
+ * Ensures a value satisfies a predicate, throwing an error if not.
+ * Returns the value if the predicate passes.
+ *
+ * Accepts sync values, promises, or functions - just like `go`.
+ *
+ * The error can be either:
+ * - An Error class constructor (instantiated with the value as cause)
+ * - A function that creates and returns an Error
+ * - If omitted, defaults to UnknownError
+ *
+ * @example
+ * ```typescript
+ * // With sync value (uses UnknownError by default)
+ * ensure(42, n => n > 0)
+ *
+ * // With promise (awaited internally)
+ * const res = await ensure(fetch('/api'), r => r.ok, RequestFailedError)
+ *
+ * // With function
+ * const res = ensure(() => parseInt('42'), n => !isNaN(n), Error)
+ *
+ * // With error factory function
+ * const res = ensure(
+ *   await fetch('/api'),
+ *   r => r.ok,
+ *   r => new Error(`HTTP ${r.status}`)
+ * )
+ * ```
+ */
+declare function ensure<T>(value: Promise<T>, predicate: (value: T) => boolean, error?: ErrorConstructor<Error> | ((value: T) => Error)): Promise<T>;
+declare function ensure<T>(fn: () => Promise<T>, predicate: (value: T) => boolean, error?: ErrorConstructor<Error> | ((value: T) => Error)): Promise<T>;
+declare function ensure<T>(fn: () => T, predicate: (value: T) => boolean, error?: ErrorConstructor<Error> | ((value: T) => Error)): T;
+declare function ensure<T>(value: T, predicate: (value: T) => boolean, error?: ErrorConstructor<Error> | ((value: T) => Error)): T;
+
 declare function isSuccess<E, T>(result: Result<E, T>): result is Success<T>;
 declare function isFailure<E, T>(result: Result<E, T>): result is Failure<E>;
 declare function success<T>(value: T): Success<T>;
@@ -350,6 +416,40 @@ declare function failure<E>(error: E): Failure<E>;
  */
 declare function assertNever(value: never): never;
 
-export { UnknownError, assert, assertNever, failure, goTry, goTryAll, goTryAllRaw, goTryOr, goTryRaw, isFailure, isSuccess, success, taggedError };
-export type { ErrorConstructor, Failure, GoTryAllOptions, GoTryRawOptions, MaybePromise, Result, ResultWithDefault, Success, TaggedError, TaggedUnion };
+/**
+ * Result type with Error and a default value.
+ * On error, returns [Error, DefaultT]
+ * On success, returns [undefined, T]
+ */
+type ResultWithDefault<E, T, D = T> = readonly [E, D] | readonly [undefined, T];
+/**
+ * Executes a function, promise, or value and returns a Result type with a fallback default.
+ * If an error occurs, it returns the actual Error object and the default value.
+ *
+ * @template T The type of the successful result
+ * @template D The type of the default value (defaults to T)
+ * @param {T | Promise<T> | (() => T | Promise<T>)} value - The value, promise, or function to execute
+ * @param {D | (() => D)} defaultValue - The default value or a function to compute it (only called on failure)
+ * @returns {ResultWithDefault<Error, T, D> | Promise<ResultWithDefault<Error, T, D>>} A tuple of [error, value] or Promise thereof
+ *
+ * @example
+ * // With a static default
+ * const [err, config] = goElse(() => JSON.parse('invalid'), { port: 3000 })
+ * // err is the Error object, config is { port: 3000 }
+ *
+ * @example
+ * // With a computed default (lazy evaluation)
+ * const [err, user] = await goElse(fetchUser(id), () => ({
+ *   id: 'anonymous',
+ *   name: 'Guest'
+ * }))
+ */
+declare function goElse<T, D = T>(fn: () => never, defaultValue: D | (() => D)): ResultWithDefault<Error, never, D>;
+declare function goElse<T, D = T>(fn: () => Promise<T>, defaultValue: D | (() => D)): Promise<ResultWithDefault<Error, T, D>>;
+declare function goElse<T, D = T>(promise: Promise<T>, defaultValue: D | (() => D)): Promise<ResultWithDefault<Error, T, D>>;
+declare function goElse<T, D = T>(fn: () => T, defaultValue: D | (() => D)): ResultWithDefault<Error, T, D>;
+declare function goElse<T, D = T>(value: T, defaultValue: D | (() => D)): ResultWithDefault<Error, T, D>;
+
+export { UnknownError, assert, assertNever, ensure, failure, goTryRaw as go, goTryAllRaw as goAll, goElse, goTry, goTryAll, goTryAllRaw, goTryOr, goTryRaw, isFailure, isSuccess, success, taggedError };
+export type { ErrorConstructor$1 as ErrorConstructor, Failure, GoTryAllOptions, GoTryAllRawOptions, GoTryRawOptions, MaybePromise, Result, ResultWithDefault$1 as ResultWithDefault, Success, TaggedError, TaggedUnion };
 //# sourceMappingURL=index.d.mts.map