@cometloop/safe 0.0.1

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/safe/types.ts","../src/safe/safe.ts","../src/safe/createSafe.ts","../src/safe/withObjects.ts"],"sourcesContent":["// Falsy types that would break the `if (error)` check pattern.\n// parseError returning any of these makes the error undetectable via truthiness.\ntype Falsy = false | 0 | '' | null | undefined | 0n | void\n\n/**\n * Strips falsy members from E via distributive conditional.\n * When E is purely falsy (e.g. null, false, 0), the result is `never`,\n * making the parseError return type unsatisfiable — a compile error.\n *\n * For union types like `string | null`, the falsy member (`null`) is\n * stripped, so `parseError` must return `string` — which means\n * `(e: unknown) => e?.message ?? null` correctly fails to compile.\n */\nexport type NonFalsy<E> = E extends Falsy ? never : E\n\n// Tagged result types: tuple intersection with discriminant properties\nexport type SafeOk<T> = readonly [T, null] & {\n  readonly ok: true\n  readonly value: T\n  readonly error: null\n}\n\nexport type SafeErr<E> = readonly [null, E] & {\n  readonly ok: false\n  readonly value: null\n  readonly error: E\n}\n\nexport type SafeResult<T, E = Error> = SafeOk<T> | SafeErr<E>\n\n// Object-style result types\nexport type SafeOkObj<T> = {\n  readonly ok: true\n  readonly data: T\n  readonly error: null\n}\n\nexport type SafeErrObj<E> = {\n  readonly ok: false\n  readonly data: null\n  readonly error: E\n}\n\nexport type SafeResultObj<T, E = Error> = SafeOkObj<T> | SafeErrObj<E>\n\n// Construct a success result\nexport function ok<T>(value: T): SafeOk<T> {\n  const tuple = [value, null] as readonly [T, null]\n  Object.defineProperties(tuple, {\n    ok: { value: true, enumerable: false },\n    value: { value, enumerable: false },\n    error: { value: null, enumerable: false },\n  })\n  return tuple as SafeOk<T>\n}\n\n// Construct an error result\nexport function err<E>(error: E): SafeErr<E> {\n  const tuple = [null, error] as readonly [null, E]\n  Object.defineProperties(tuple, {\n    ok: { value: false, enumerable: false },\n    value: { value: null, enumerable: false },\n    error: { value: error, enumerable: false },\n  })\n  return tuple as SafeErr<E>\n}\n\n// Construct a success object result\nexport function okObj<T>(data: T): SafeOkObj<T> {\n  return { ok: true, data, error: null }\n}\n\n// Construct an error object result\nexport function errObj<E>(error: E): SafeErrObj<E> {\n  return { ok: false, data: null, error }\n}\n\n// Timeout error class for abortAfter functionality\nexport class TimeoutError extends Error {\n  constructor(ms: number) {\n    super(`Operation timed out after ${ms}ms`)\n    this.name = 'TimeoutError'\n  }\n}\n\n// Retry configuration for async operations\nexport type RetryConfig = {\n  times: number\n  waitBefore?: (attempt: number) => number\n}\n\n// Hooks for side effects on success/error/settled\n// TOut defaults to T — when parseResult is provided, it overrides the result type\nexport type SafeHooks<T, E, TContext extends unknown[] = [], TOut = T> = {\n  parseResult?: (response: T) => TOut\n  onSuccess?: (result: TOut, context: TContext) => void\n  onError?: (error: E, context: TContext) => void\n  onSettled?: (result: TOut | null, error: E | null, context: TContext) => void\n  onHookError?: (error: unknown, hookName: string) => void\n  /** Fallback error value returned when `parseError` throws. */\n  defaultError?: E\n}\n\n// Extended hooks for async operations with retry and timeout support\nexport type SafeAsyncHooks<\n  T,\n  E,\n  TContext extends unknown[] = [],\n  TOut = T,\n> = SafeHooks<T, E, TContext, TOut> & {\n  onRetry?: (error: E, attempt: number, context: TContext) => void\n  retry?: RetryConfig\n  abortAfter?: number // timeout in milliseconds\n}\n\n/**\n * Configuration for creating a pre-configured safe instance\n * @typeParam E - The error type that parseError returns\n * @typeParam TResult - The return type of parseResult (inferred from parseResult)\n */\nexport type CreateSafeConfig<E, TResult = never> = {\n  /**\n   * Error mapping function applied to all caught errors.\n   *\n   * If `parseError` throws, the exception is caught and reported via `onHookError`\n   * (hookName `'parseError'`). The `defaultError` value is returned as the error\n   * result; if `defaultError` is not provided, the raw caught error is normalized\n   * to an `Error` instance via `new Error(String(e))`.\n   */\n  parseError: (e: unknown) => NonFalsy<E>\n  /**\n   * Fallback error value returned when `parseError` throws.\n   * Must be provided alongside `parseError` in `createSafe`.\n   */\n  defaultError: E\n  /** Optional response transform applied to all successful results. Per-call parseResult overrides this. */\n  parseResult?: (response: unknown) => TResult\n  /** Optional default success hook (result is unknown since T varies per call) */\n  onSuccess?: (result: unknown) => void\n  /** Optional default error hook (receives the mapped error type E) */\n  onError?: (error: E) => void\n  /** Optional default settled hook — fires after success or error */\n  onSettled?: (result: unknown, error: E | null) => void\n  /** Optional default retry hook for async operations */\n  onRetry?: (error: E, attempt: number) => void\n  /** Optional default retry configuration for async operations */\n  retry?: RetryConfig\n  /** Optional default timeout for all async operations in milliseconds */\n  abortAfter?: number\n  /** Optional callback invoked when any hook throws. Receives the thrown error and the hook name. */\n  onHookError?: (error: unknown, hookName: string) => void\n}\n\n/**\n * A pre-configured safe instance with a fixed error type\n * Methods do not accept parseError parameter (already configured)\n * @typeParam E - The error type used by all methods\n * @typeParam TResult - The factory parseResult return type (never = no factory parseResult)\n */\nexport type SafeInstance<E, TResult = never> = {\n  sync: <T, TOut = [TResult] extends [never] ? T : TResult>(\n    fn: () => T,\n    hooks?: SafeHooks<T, E, [], TOut>\n  ) => SafeResult<TOut, E>\n  async: <T, TOut = [TResult] extends [never] ? T : TResult>(\n    fn: (signal?: AbortSignal) => Promise<T>,\n    hooks?: SafeAsyncHooks<T, E, [], TOut>\n  ) => Promise<SafeResult<TOut, E>>\n  wrap: <\n    TArgs extends unknown[],\n    T,\n    TOut = [TResult] extends [never] ? T : TResult,\n  >(\n    fn: (...args: TArgs) => T,\n    hooks?: SafeHooks<T, E, TArgs, TOut>\n  ) => (...args: TArgs) => SafeResult<TOut, E>\n  wrapAsync: <\n    TArgs extends unknown[],\n    T,\n    TOut = [TResult] extends [never] ? T : TResult,\n  >(\n    fn: (...args: TArgs) => Promise<T>,\n    hooks?: SafeAsyncHooks<T, E, TArgs, TOut>\n  ) => (...args: TArgs) => Promise<SafeResult<TOut, E>>\n  all: <T extends Record<string, (signal?: AbortSignal) => Promise<any>>>(\n    fns: T\n  ) => Promise<\n    SafeResult<\n      {\n        [K in keyof T]: [TResult] extends [never]\n          ? T[K] extends (signal?: AbortSignal) => Promise<infer V>\n            ? V\n            : never\n          : TResult\n      },\n      E\n    >\n  >\n  allSettled: <\n    T extends Record<string, (signal?: AbortSignal) => Promise<any>>,\n  >(\n    fns: T\n  ) => Promise<{\n    [K in keyof T]: SafeResult<\n      [TResult] extends [never]\n        ? T[K] extends (signal?: AbortSignal) => Promise<infer V>\n          ? V\n          : never\n        : TResult,\n      E\n    >\n  }>\n}\n\n/**\n * Object-style variant of SafeInstance where all methods return SafeResultObj instead of SafeResult tuples.\n * Created by wrapping a SafeInstance with withObjects().\n */\nexport type SafeObjectInstance<E, TResult = never> = {\n  sync: <T, TOut = [TResult] extends [never] ? T : TResult>(\n    fn: () => T,\n    hooks?: SafeHooks<T, E, [], TOut>\n  ) => SafeResultObj<TOut, E>\n  async: <T, TOut = [TResult] extends [never] ? T : TResult>(\n    fn: (signal?: AbortSignal) => Promise<T>,\n    hooks?: SafeAsyncHooks<T, E, [], TOut>\n  ) => Promise<SafeResultObj<TOut, E>>\n  wrap: <\n    TArgs extends unknown[],\n    T,\n    TOut = [TResult] extends [never] ? T : TResult,\n  >(\n    fn: (...args: TArgs) => T,\n    hooks?: SafeHooks<T, E, TArgs, TOut>\n  ) => (...args: TArgs) => SafeResultObj<TOut, E>\n  wrapAsync: <\n    TArgs extends unknown[],\n    T,\n    TOut = [TResult] extends [never] ? T : TResult,\n  >(\n    fn: (...args: TArgs) => Promise<T>,\n    hooks?: SafeAsyncHooks<T, E, TArgs, TOut>\n  ) => (...args: TArgs) => Promise<SafeResultObj<TOut, E>>\n  all: <T extends Record<string, (signal?: AbortSignal) => Promise<any>>>(\n    fns: T\n  ) => Promise<\n    SafeResultObj<\n      {\n        [K in keyof T]: [TResult] extends [never]\n          ? T[K] extends (signal?: AbortSignal) => Promise<infer V>\n            ? V\n            : never\n          : TResult\n      },\n      E\n    >\n  >\n  allSettled: <\n    T extends Record<string, (signal?: AbortSignal) => Promise<any>>,\n  >(\n    fns: T\n  ) => Promise<{\n    [K in keyof T]: SafeResultObj<\n      [TResult] extends [never]\n        ? T[K] extends (signal?: AbortSignal) => Promise<infer V>\n          ? V\n          : never\n        : TResult,\n      E\n    >\n  }>\n}\n","import type { SafeResult, SafeHooks, SafeAsyncHooks, NonFalsy } from './types'\nimport { TimeoutError, ok, err } from './types'\n\n// Valid keys for SafeHooks and SafeAsyncHooks.\n// Using Record<keyof ..., true> ensures compile-time errors if a hook key is\n// added to SafeAsyncHooks but not listed here (missing key) or if a stale key\n// remains after removal (extra key).\nconst HOOK_KEY_MAP: Record<keyof SafeAsyncHooks<any, any, any>, true> = {\n  parseResult: true,\n  onSuccess: true,\n  onError: true,\n  onSettled: true,\n  onHookError: true,\n  defaultError: true,\n  onRetry: true,\n  retry: true,\n  abortAfter: true,\n}\nconst HOOK_KEYS: ReadonlySet<string> = new Set(Object.keys(HOOK_KEY_MAP))\n\n// Keys whose values must be functions when present and not undefined.\nconst FUNCTION_HOOK_KEYS: ReadonlySet<string> = new Set([\n  'parseResult',\n  'onSuccess',\n  'onError',\n  'onSettled',\n  'onHookError',\n  'onRetry',\n])\n\n// Type guard to distinguish hooks object from parseError function.\n// Requires at least one recognized key AND validates value types to\n// avoid false positives (e.g. { retry: 3 } misidentified as hooks).\nconst isHooks = <T, E, TContext extends unknown[]>(\n  arg: unknown\n): arg is SafeHooks<T, E, TContext> => {\n  if (typeof arg !== 'object' || arg === null || Array.isArray(arg))\n    return false\n  const keys = Object.keys(arg)\n  if (keys.length === 0) return false\n\n  const obj = arg as Record<string, unknown>\n  for (const key of keys) {\n    if (!HOOK_KEYS.has(key)) return false\n    const val = obj[key]\n    if (val === undefined) continue // optional property\n    if (FUNCTION_HOOK_KEYS.has(key)) {\n      if (typeof val !== 'function') return false\n    } else if (key === 'retry') {\n      if (typeof val !== 'object' || val === null) return false\n    } else if (key === 'abortAfter') {\n      if (typeof val !== 'number') return false\n    }\n    // defaultError: any type allowed\n  }\n  return true\n}\n\n// Safely call a hook, swallowing any errors it throws.\n// A logging hook throwing should never crash the application\n// or alter the returned SafeResult.\nconst callHook = (\n  fn: (() => void) | undefined,\n  onHookError?: (error: unknown, hookName: string) => void,\n  hookName?: string\n): void => {\n  try {\n    fn?.()\n  } catch (e) {\n    try {\n      onHookError?.(e, hookName ?? 'unknown')\n    } catch {\n      // onHookError itself must never throw\n    }\n  }\n}\n\n// Normalize unknown thrown values to Error instances.\n// Makes the `Error` default type truthful when no parseError is provided.\nconst toError = (e: unknown): Error => {\n  if (e instanceof Error) return e\n  const error = new Error(String(e))\n  ;(error as any).cause = e\n  return error\n}\n\n// Safely call parseError, falling back to defaultError or toError(e).\n// If parseError throws, the exception is reported via onHookError('parseError').\nconst callParseError = <E>(\n  e: unknown,\n  parseError: ((e: unknown) => E) | undefined,\n  onHookError?: (error: unknown, hookName: string) => void,\n  defaultError?: E\n): E => {\n  if (!parseError) return toError(e) as E\n  try {\n    return parseError(e)\n  } catch (parseErrorException) {\n    try {\n      onHookError?.(parseErrorException, 'parseError')\n    } catch {\n      // onHookError itself must never throw\n    }\n    return defaultError ?? (toError(e) as E)\n  }\n}\n\n// Call parseResult, letting errors propagate to the caller's catch block\n// so they are routed through the standard error path (parseError → onError → err).\nconst callParseResult = <T, TOut>(\n  parseResult: ((response: T) => TOut) | undefined,\n  rawResult: T\n): TOut => {\n  if (!parseResult) return rawResult as unknown as TOut\n  return parseResult(rawResult)\n}\n\n// Sanitise retry.times: floor to integer, clamp to >= 0, treat NaN as 0.\nconst sanitiseRetryTimes = (times: number | undefined): number => {\n  if (times === undefined) return 0\n  const n = Math.floor(times)\n  if (!Number.isFinite(n) || n < 0) return 0\n  return n\n}\n\n// Validate abortAfter: must be a finite number >= 0.\nconst validateAbortAfter = (ms: number | undefined): number | undefined => {\n  if (ms === undefined) return undefined\n  if (!Number.isFinite(ms) || ms < 0) {\n    throw new RangeError(\n      `abortAfter must be a non-negative finite number, got ${ms}`\n    )\n  }\n  return ms\n}\n\n// Helper for async delays\nconst sleep = (ms: number): Promise<void> =>\n  new Promise((resolve) => setTimeout(resolve, ms))\n\n// Helper to wrap a promise with timeout.\n// Uses Promise.race + finally so the timer is always cleaned up,\n// regardless of which settlement path wins.\nconst withTimeout = <T>(\n  promise: Promise<T>,\n  ms: number,\n  controller: AbortController\n): Promise<T> => {\n  let timeoutId: ReturnType<typeof setTimeout>\n\n  const timeoutPromise = new Promise<never>((_, reject) => {\n    timeoutId = setTimeout(() => {\n      controller.abort()\n      reject(new TimeoutError(ms))\n    }, ms)\n  })\n\n  return Promise.race([promise, timeoutPromise]).finally(() => {\n    clearTimeout(timeoutId)\n  })\n}\n\n/**\n * Execute a synchronous function and return a result tuple instead of throwing.\n *\n * Catches any error thrown by `fn` and returns `[null, error]`.\n * On success, returns `[result, null]`.\n *\n * @param fn - The synchronous function to execute.\n * @param parseError - Optional function to transform the caught error into a custom type `E`.\n *   If `parseError` throws, the exception is caught and reported via `onHookError`\n *   (hookName `'parseError'`). The `defaultError` value is returned if provided;\n *   otherwise the raw caught error is normalized to an `Error` instance.\n * @param hooks - Optional hooks for side effects (`parseResult`, `onSuccess`, `onError`, `onSettled`).\n * @returns A `SafeResult<T, E>` tuple: `[value, null]` on success or `[null, error]` on failure.\n *\n * @example\n * ```typescript\n * const [user, error] = safe.sync(() => JSON.parse(rawJson))\n *\n * // With custom error parsing and hooks\n * const [value, err] = safe.sync(\n *   () => riskyOperation(),\n *   (e) => ({ code: 'PARSE_ERROR', message: String(e) }),\n *   { onError: (error) => console.error(error.code) }\n * )\n * ```\n */\nfunction safeSync<T>(fn: () => T): SafeResult<T, Error>\nfunction safeSync<T, TOut = T>(\n  fn: () => T,\n  hooks: SafeHooks<T, Error, [], TOut>\n): SafeResult<TOut, Error>\nfunction safeSync<T, E>(\n  fn: () => T,\n  parseError: (e: unknown) => NonFalsy<E>\n): SafeResult<T, E>\nfunction safeSync<T, E, TOut = T>(\n  fn: () => T,\n  parseError: (e: unknown) => NonFalsy<E>,\n  hooks: SafeHooks<T, E, [], TOut> & { defaultError: E }\n): SafeResult<TOut, E>\nfunction safeSync<T, E = Error, TOut = T>(\n  fn: () => T,\n  parseErrorOrHooks?: ((e: unknown) => E) | SafeHooks<T, E, [], TOut>,\n  hooks?: SafeHooks<T, E, [], TOut>\n): SafeResult<TOut, E> {\n  const context: [] = []\n  let parseError: ((e: unknown) => E) | undefined\n  let resolvedHooks: SafeHooks<T, E, [], TOut> | undefined\n\n  if (isHooks<T, E, []>(parseErrorOrHooks)) {\n    resolvedHooks = parseErrorOrHooks as SafeHooks<T, E, [], TOut>\n  } else {\n    parseError = parseErrorOrHooks as ((e: unknown) => E) | undefined\n    resolvedHooks = hooks\n  }\n\n  const onHookError = resolvedHooks?.onHookError\n\n  try {\n    const rawResult = fn()\n    const result = callParseResult(resolvedHooks?.parseResult, rawResult)\n    callHook(\n      () => resolvedHooks?.onSuccess?.(result, context),\n      onHookError,\n      'onSuccess'\n    )\n    callHook(\n      () => resolvedHooks?.onSettled?.(result, null, context),\n      onHookError,\n      'onSettled'\n    )\n    return ok(result)\n  } catch (e) {\n    const error = callParseError(\n      e,\n      parseError,\n      onHookError,\n      resolvedHooks?.defaultError\n    )\n    callHook(\n      () => resolvedHooks?.onError?.(error, context),\n      onHookError,\n      'onError'\n    )\n    callHook(\n      () => resolvedHooks?.onSettled?.(null, error, context),\n      onHookError,\n      'onSettled'\n    )\n    return err(error)\n  }\n}\n\n/**\n * Execute an asynchronous function and return a result tuple instead of throwing.\n *\n * Catches any error thrown or rejected by `fn` and returns `[null, error]`.\n * On success, returns `[result, null]`. Supports retry and timeout via hooks.\n *\n * @param fn - The async function to execute. Receives an optional `AbortSignal` when `abortAfter` is configured.\n * @param parseError - Optional function to transform the caught error into a custom type `E`.\n *   If `parseError` throws, the exception is caught and reported via `onHookError`\n *   (hookName `'parseError'`). The `defaultError` value is returned if provided;\n *   otherwise the raw caught error is normalized to an `Error` instance.\n * @param hooks - Optional hooks including `retry`, `abortAfter`, `onRetry`, `parseResult`, `onSuccess`, `onError`, `onSettled`.\n * @returns A `Promise<SafeResult<T, E>>` tuple: `[value, null]` on success or `[null, error]` on failure.\n *\n * @example\n * ```typescript\n * const [data, error] = await safe.async(() => fetch('/api/users').then(r => r.json()))\n *\n * // With retry and timeout\n * const [data, error] = await safe.async(\n *   (signal) => fetch('/api/users', { signal }).then(r => r.json()),\n *   { retry: { times: 3 }, abortAfter: 5000 }\n * )\n * ```\n */\nfunction safeAsync<T>(\n  fn: (signal?: AbortSignal) => Promise<T>\n): Promise<SafeResult<T, Error>>\nfunction safeAsync<T, TOut = T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  hooks: SafeAsyncHooks<T, Error, [], TOut>\n): Promise<SafeResult<TOut, Error>>\nfunction safeAsync<T, E>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  parseError: (e: unknown) => NonFalsy<E>\n): Promise<SafeResult<T, E>>\nfunction safeAsync<T, E, TOut = T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  parseError: (e: unknown) => NonFalsy<E>,\n  hooks: SafeAsyncHooks<T, E, [], TOut> & { defaultError: E }\n): Promise<SafeResult<TOut, E>>\nasync function safeAsync<T, E = Error, TOut = T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  parseErrorOrHooks?: ((e: unknown) => E) | SafeAsyncHooks<T, E, [], TOut>,\n  hooks?: SafeAsyncHooks<T, E, [], TOut>\n): Promise<SafeResult<TOut, E>> {\n  const context: [] = []\n  let parseError: ((e: unknown) => E) | undefined\n  let resolvedHooks: SafeAsyncHooks<T, E, [], TOut> | undefined\n\n  if (isHooks<T, E, []>(parseErrorOrHooks)) {\n    resolvedHooks = parseErrorOrHooks as SafeAsyncHooks<T, E, [], TOut>\n  } else {\n    parseError = parseErrorOrHooks as ((e: unknown) => E) | undefined\n    resolvedHooks = hooks\n  }\n\n  const maxAttempts = sanitiseRetryTimes(resolvedHooks?.retry?.times) + 1\n  const abortAfter = validateAbortAfter(resolvedHooks?.abortAfter)\n  const onHookError = resolvedHooks?.onHookError\n  let lastError!: E\n\n  for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n    // Create a fresh AbortController for each attempt if timeout is configured\n    const controller =\n      abortAfter !== undefined ? new AbortController() : undefined\n\n    try {\n      let promise = fn(controller?.signal)\n\n      // Wrap with timeout if configured\n      if (abortAfter !== undefined && controller) {\n        promise = withTimeout(promise, abortAfter, controller)\n      }\n\n      const rawResult = await promise\n      const result = callParseResult(resolvedHooks?.parseResult, rawResult)\n      callHook(\n        () => resolvedHooks?.onSuccess?.(result, context),\n        onHookError,\n        'onSuccess'\n      )\n      callHook(\n        () => resolvedHooks?.onSettled?.(result, null, context),\n        onHookError,\n        'onSettled'\n      )\n      return ok(result)\n    } catch (e) {\n      lastError = callParseError(\n        e,\n        parseError,\n        onHookError,\n        resolvedHooks?.defaultError\n      )\n\n      // If not the last attempt, call onRetry and potentially wait\n      if (attempt < maxAttempts) {\n        callHook(\n          () => resolvedHooks?.onRetry?.(lastError, attempt, context),\n          onHookError,\n          'onRetry'\n        )\n        const waitMs = resolvedHooks?.retry?.waitBefore?.(attempt) ?? 0\n        if (waitMs > 0 && Number.isFinite(waitMs)) {\n          await sleep(waitMs)\n        }\n      }\n    }\n  }\n\n  callHook(\n    () => resolvedHooks?.onError?.(lastError, context),\n    onHookError,\n    'onError'\n  )\n  callHook(\n    () => resolvedHooks?.onSettled?.(null, lastError, context),\n    onHookError,\n    'onSettled'\n  )\n  return err(lastError)\n}\n\n/**\n * Wrap a synchronous function so it returns a result tuple instead of throwing.\n *\n * Returns a new function with the same parameter signature that catches\n * errors and returns `[null, error]` instead of throwing. The original\n * arguments are passed through to hooks as context.\n *\n * @param fn - The synchronous function to wrap.\n * @param parseError - Optional function to transform the caught error into a custom type `E`.\n *   If `parseError` throws, the exception is caught and reported via `onHookError`\n *   (hookName `'parseError'`). The `defaultError` value is returned if provided;\n *   otherwise the raw caught error is normalized to an `Error` instance.\n * @param hooks - Optional hooks for side effects (`parseResult`, `onSuccess`, `onError`, `onSettled`). Hooks receive the original call arguments as context.\n * @returns A wrapped function `(...args) => SafeResult<T, E>`.\n *\n * @example\n * ```typescript\n * const safeJsonParse = safe.wrap(JSON.parse)\n * const [data, error] = safeJsonParse('{\"valid\": true}')\n *\n * // With hooks that receive the original arguments\n * const safeDivide = safe.wrap(\n *   (a: number, b: number) => { if (b === 0) throw new Error('Division by zero'); return a / b },\n *   { onError: (error, [a, b]) => console.error(`Failed to divide ${a} by ${b}`) }\n * )\n * ```\n */\nfunction wrap<TArgs extends unknown[], T>(\n  fn: (...args: TArgs) => T\n): (...args: TArgs) => SafeResult<T, Error>\nfunction wrap<TArgs extends unknown[], T, TOut = T>(\n  fn: (...args: TArgs) => T,\n  hooks: SafeHooks<T, Error, TArgs, TOut>\n): (...args: TArgs) => SafeResult<TOut, Error>\nfunction wrap<TArgs extends unknown[], T, E>(\n  fn: (...args: TArgs) => T,\n  parseError: (e: unknown) => NonFalsy<E>\n): (...args: TArgs) => SafeResult<T, E>\nfunction wrap<TArgs extends unknown[], T, E, TOut = T>(\n  fn: (...args: TArgs) => T,\n  parseError: (e: unknown) => NonFalsy<E>,\n  hooks: SafeHooks<T, E, TArgs, TOut> & { defaultError: E }\n): (...args: TArgs) => SafeResult<TOut, E>\nfunction wrap<TArgs extends unknown[], T, E = Error, TOut = T>(\n  fn: (...args: TArgs) => T,\n  parseErrorOrHooks?: ((e: unknown) => E) | SafeHooks<T, E, TArgs, TOut>,\n  hooks?: SafeHooks<T, E, TArgs, TOut>\n): (...args: TArgs) => SafeResult<TOut, E> {\n  let parseError: ((e: unknown) => E) | undefined\n  let resolvedHooks: SafeHooks<T, E, TArgs, TOut> | undefined\n\n  if (isHooks<T, E, TArgs>(parseErrorOrHooks)) {\n    resolvedHooks = parseErrorOrHooks as SafeHooks<T, E, TArgs, TOut>\n  } else {\n    parseError = parseErrorOrHooks as ((e: unknown) => E) | undefined\n    resolvedHooks = hooks\n  }\n\n  const onHookError = resolvedHooks?.onHookError\n\n  return function (this: unknown, ...args: TArgs) {\n    try {\n      const rawResult = fn.call(this, ...args)\n      const result = callParseResult(resolvedHooks?.parseResult, rawResult)\n      callHook(\n        () => resolvedHooks?.onSuccess?.(result, args),\n        onHookError,\n        'onSuccess'\n      )\n      callHook(\n        () => resolvedHooks?.onSettled?.(result, null, args),\n        onHookError,\n        'onSettled'\n      )\n      return ok(result)\n    } catch (e) {\n      const error = callParseError(\n        e,\n        parseError,\n        onHookError,\n        resolvedHooks?.defaultError\n      )\n      callHook(\n        () => resolvedHooks?.onError?.(error, args),\n        onHookError,\n        'onError'\n      )\n      callHook(\n        () => resolvedHooks?.onSettled?.(null, error, args),\n        onHookError,\n        'onSettled'\n      )\n      return err(error)\n    }\n  }\n}\n\n/**\n * Wrap an asynchronous function so it returns a result tuple instead of throwing.\n *\n * Returns a new function with the same parameter signature that catches\n * errors and returns `[null, error]` instead of throwing. Supports retry\n * and timeout via hooks.\n *\n * **Note on `abortAfter`:** When configured, `abortAfter` acts as an external\n * deadline — the promise is rejected with a `TimeoutError` after the specified\n * duration, but the wrapped function does **not** receive an `AbortSignal`.\n * This means the underlying operation will continue running in the background\n * even after the timeout fires. If you need cooperative cancellation (e.g.\n * passing a signal to `fetch`), use {@link safeAsync | safe.async} instead,\n * which passes the signal directly to the function:\n *\n * ```typescript\n * // Cooperative cancellation with safe.async\n * const [data, error] = await safe.async(\n *   (signal) => fetch('/api/data', { signal }),\n *   { abortAfter: 5000 }\n * )\n * ```\n *\n * @param fn - The async function to wrap.\n * @param parseError - Optional function to transform the caught error into a custom type `E`.\n *   If `parseError` throws, the exception is caught and reported via `onHookError`\n *   (hookName `'parseError'`). The `defaultError` value is returned if provided;\n *   otherwise the raw caught error is normalized to an `Error` instance.\n * @param hooks - Optional hooks including `retry`, `abortAfter`, `onRetry`, `parseResult`, `onSuccess`, `onError`, `onSettled`. Hooks receive the original call arguments as context.\n * @returns A wrapped function `(...args) => Promise<SafeResult<T, E>>`.\n *\n * @example\n * ```typescript\n * const safeFetchUser = safe.wrapAsync(\n *   (id: string) => fetch(`/api/users/${id}`).then(r => r.json())\n * )\n * const [user, error] = await safeFetchUser('123')\n *\n * // With retry\n * const safeFetch = safe.wrapAsync(\n *   (url: string) => fetch(url).then(r => r.json()),\n *   { retry: { times: 3, waitBefore: (attempt) => attempt * 1000 } }\n * )\n * ```\n */\nfunction wrapAsync<TArgs extends unknown[], T>(\n  fn: (...args: TArgs) => Promise<T>\n): (...args: TArgs) => Promise<SafeResult<T, Error>>\nfunction wrapAsync<TArgs extends unknown[], T, TOut = T>(\n  fn: (...args: TArgs) => Promise<T>,\n  hooks: SafeAsyncHooks<T, Error, TArgs, TOut>\n): (...args: TArgs) => Promise<SafeResult<TOut, Error>>\nfunction wrapAsync<TArgs extends unknown[], T, E>(\n  fn: (...args: TArgs) => Promise<T>,\n  parseError: (e: unknown) => NonFalsy<E>\n): (...args: TArgs) => Promise<SafeResult<T, E>>\nfunction wrapAsync<TArgs extends unknown[], T, E, TOut = T>(\n  fn: (...args: TArgs) => Promise<T>,\n  parseError: (e: unknown) => NonFalsy<E>,\n  hooks: SafeAsyncHooks<T, E, TArgs, TOut> & { defaultError: E }\n): (...args: TArgs) => Promise<SafeResult<TOut, E>>\nfunction wrapAsync<TArgs extends unknown[], T, E = Error, TOut = T>(\n  fn: (...args: TArgs) => Promise<T>,\n  parseErrorOrHooks?: ((e: unknown) => E) | SafeAsyncHooks<T, E, TArgs, TOut>,\n  hooks?: SafeAsyncHooks<T, E, TArgs, TOut>\n): (...args: TArgs) => Promise<SafeResult<TOut, E>> {\n  let parseError: ((e: unknown) => E) | undefined\n  let resolvedHooks: SafeAsyncHooks<T, E, TArgs, TOut> | undefined\n\n  if (isHooks<T, E, TArgs>(parseErrorOrHooks)) {\n    resolvedHooks = parseErrorOrHooks as SafeAsyncHooks<T, E, TArgs, TOut>\n  } else {\n    parseError = parseErrorOrHooks as ((e: unknown) => E) | undefined\n    resolvedHooks = hooks\n  }\n\n  const maxAttempts = sanitiseRetryTimes(resolvedHooks?.retry?.times) + 1\n  const abortAfter = validateAbortAfter(resolvedHooks?.abortAfter)\n  const onHookError = resolvedHooks?.onHookError\n\n  return async function (this: unknown, ...args: TArgs) {\n    let lastError!: E\n\n    for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n      // Create a fresh AbortController for each attempt if timeout is configured\n      const controller =\n        abortAfter !== undefined ? new AbortController() : undefined\n\n      try {\n        let promise = fn.call(this, ...args)\n\n        // Wrap with timeout if configured\n        if (abortAfter !== undefined && controller) {\n          promise = withTimeout(promise, abortAfter, controller)\n        }\n\n        const rawResult = await promise\n        const result = callParseResult(resolvedHooks?.parseResult, rawResult)\n        callHook(\n          () => resolvedHooks?.onSuccess?.(result, args),\n          onHookError,\n          'onSuccess'\n        )\n        callHook(\n          () => resolvedHooks?.onSettled?.(result, null, args),\n          onHookError,\n          'onSettled'\n        )\n        return ok(result)\n      } catch (e) {\n        lastError = callParseError(\n          e,\n          parseError,\n          onHookError,\n          resolvedHooks?.defaultError\n        )\n\n        // If not the last attempt, call onRetry and potentially wait\n        if (attempt < maxAttempts) {\n          callHook(\n            () => resolvedHooks?.onRetry?.(lastError, attempt, args),\n            onHookError,\n            'onRetry'\n          )\n          const waitMs = resolvedHooks?.retry?.waitBefore?.(attempt) ?? 0\n          if (waitMs > 0 && Number.isFinite(waitMs)) {\n            await sleep(waitMs)\n          }\n        }\n      }\n    }\n\n    callHook(\n      () => resolvedHooks?.onError?.(lastError, args),\n      onHookError,\n      'onError'\n    )\n    callHook(\n      () => resolvedHooks?.onSettled?.(null, lastError, args),\n      onHookError,\n      'onSettled'\n    )\n    return err(lastError)\n  }\n}\n\n/**\n * Run multiple safe-wrapped async operations in parallel and return all values or the first error.\n *\n * Short-circuits: returns immediately when any operation fails, without waiting\n * for remaining operations to settle. If all succeed, returns\n * `ok({ key: value, ... })` with unwrapped values. If any fail, returns `err(firstError)`.\n *\n * @param promises - An object map of `Promise<SafeResult<T, E>>` entries.\n * @returns A `Promise<SafeResult<{ [K]: V }, E>>` — all values on success, first error on failure.\n *\n * @example\n * ```typescript\n * const [data, error] = await safe.all({\n *   user: safe.async(() => fetchUser()),\n *   posts: safe.async(() => fetchPosts()),\n * })\n * if (error) return handleError(error)\n * data.user   // User\n * data.posts  // Post[]\n * ```\n */\nfunction safeAll<T extends Record<string, Promise<SafeResult<any, any>>>>(\n  promises: T\n): Promise<\n  SafeResult<\n    {\n      [K in keyof T]: T[K] extends Promise<SafeResult<infer V, any>> ? V : never\n    },\n    T[keyof T] extends Promise<SafeResult<any, infer E>> ? E : never\n  >\n> {\n  type Values = {\n    [K in keyof T]: T[K] extends Promise<SafeResult<infer V, any>> ? V : never\n  }\n  type Err = T[keyof T] extends Promise<SafeResult<any, infer E>> ? E : never\n\n  const keys = Object.keys(promises)\n  const values = Object.values(promises)\n\n  if (values.length === 0) {\n    return Promise.resolve(ok({}) as SafeResult<Values, Err>)\n  }\n\n  // Race: resolve on first error OR when all succeed.\n  // Unlike Promise.all on never-rejecting promises, this returns\n  // to the caller immediately when any operation fails.\n  return new Promise<SafeResult<Values, Err>>((resolve) => {\n    const results = new Array<SafeResult<unknown, unknown>>(values.length)\n    let remaining = values.length\n    let done = false\n\n    for (let i = 0; i < values.length; i++) {\n      values[i].then(\n        (result) => {\n          if (done) return\n          if (!result.ok) {\n            done = true\n            resolve(err(result.error) as SafeResult<Values, Err>)\n            return\n          }\n          results[i] = result\n          remaining--\n          if (remaining === 0) {\n            done = true\n            const obj: Record<string, unknown> = {}\n            for (let j = 0; j < keys.length; j++) {\n              obj[keys[j]] = results[j].value\n            }\n            resolve(ok(obj) as SafeResult<Values, Err>)\n          }\n        },\n        // Safety net: safe-wrapped promises should never reject.\n        // No parseError is available in the standalone API, so toError is\n        // the best fallback. Use createSafe.all() if custom error mapping is needed.\n        (rejection) => {\n          if (done) return\n          done = true\n          resolve(err(toError(rejection)) as SafeResult<Values, Err>)\n        }\n      )\n    }\n  })\n}\n\n/**\n * Run multiple safe-wrapped async operations in parallel and return all individual results.\n *\n * Accepts an object map of `Promise<SafeResult>` entries. Always returns all results\n * as named SafeResult entries — never fails at the group level.\n *\n * @param promises - An object map of `Promise<SafeResult<T, E>>` entries.\n * @returns A `Promise<{ [K]: SafeResult<V, E> }>` — each key maps to its individual result.\n *\n * @example\n * ```typescript\n * const results = await safe.allSettled({\n *   user: safe.async(() => fetchUser()),\n *   posts: safe.async(() => fetchPosts()),\n * })\n * if (results.user.ok) {\n *   results.user.value  // User\n * }\n * if (!results.posts.ok) {\n *   results.posts.error  // Error\n * }\n * ```\n */\nasync function safeAllSettled<\n  T extends Record<string, Promise<SafeResult<any, any>>>,\n>(promises: T): Promise<{ [K in keyof T]: Awaited<T[K]> }> {\n  type Settled = { [K in keyof T]: Awaited<T[K]> }\n\n  const keys = Object.keys(promises)\n  const values = Object.values(promises)\n  const results = await Promise.all(\n    values.map((p) =>\n      p.catch(\n        (rejection): SafeResult<unknown, Error> => err(toError(rejection))\n      )\n    )\n  )\n\n  const obj: Record<string, unknown> = {}\n  for (let i = 0; i < keys.length; i++) {\n    obj[keys[i]] = results[i]\n  }\n\n  return obj as Settled\n}\n\nexport const safe = {\n  sync: safeSync,\n  async: safeAsync,\n  wrap,\n  wrapAsync,\n  all: safeAll,\n  allSettled: safeAllSettled,\n} as const\n\n// Export individual functions for use by createSafe\nexport {\n  safeSync,\n  safeAsync,\n  wrap,\n  wrapAsync,\n  safeAll,\n  safeAllSettled,\n  callHook,\n  toError,\n  callParseError,\n}\n","import type {\n  SafeResult,\n  SafeHooks,\n  SafeAsyncHooks,\n  CreateSafeConfig,\n  SafeInstance,\n} from './types'\nimport { ok, err } from './types'\nimport {\n  safeSync,\n  safeAsync,\n  wrap,\n  wrapAsync,\n  callHook,\n  callParseError,\n} from './safe'\n\n// Utility types for typed assertions in all/allSettled (mirrors SafeInstance declarations)\ntype AllValues<\n  T extends Record<string, (signal?: AbortSignal) => Promise<any>>,\n  TResult,\n> = {\n  [K in keyof T]: [TResult] extends [never]\n    ? T[K] extends (signal?: AbortSignal) => Promise<infer V>\n      ? V\n      : never\n    : TResult\n}\n\ntype AllSettledResults<\n  T extends Record<string, (signal?: AbortSignal) => Promise<any>>,\n  E,\n  TResult,\n> = {\n  [K in keyof T]: SafeResult<\n    [TResult] extends [never]\n      ? T[K] extends (signal?: AbortSignal) => Promise<infer V>\n        ? V\n        : never\n      : TResult,\n    E\n  >\n}\n\n/**\n * Create a pre-configured safe instance with a fixed error mapping function\n *\n * Returns a new safe object where all methods use the configured parseError.\n * The error type E is automatically inferred from the parseError return type.\n * If parseResult is provided, TResult is inferred from its return type\n * and becomes the default result type for all methods.\n *\n * @example\n * ```typescript\n * const appSafe = createSafe({\n *   parseError: (e) => ({\n *     code: 'UNKNOWN_ERROR',\n *     message: e instanceof Error ? e.message : 'Unknown error',\n *   }),\n *   onError: (error) => logger.error(error.code),\n * })\n *\n * const [result, error] = appSafe.sync(() => JSON.parse(data))\n * // error is typed as { code: string; message: string }\n *\n * // With parseResult for runtime validation:\n * const validatedSafe = createSafe({\n *   parseError: (e) => toAppError(e),\n *   parseResult: (response) => schema.parse(response),\n * })\n * // All methods return SafeResult<z.infer<typeof schema>, AppError>\n * ```\n */\nexport function createSafe<E, TResult = never>(\n  config: CreateSafeConfig<E, TResult>\n): SafeInstance<E, TResult> {\n  const {\n    parseError,\n    defaultError,\n    parseResult: defaultParseResult,\n    onSuccess: defaultOnSuccess,\n    onError: defaultOnError,\n    onSettled: defaultOnSettled,\n    onRetry: defaultOnRetry,\n    retry: defaultRetry,\n    abortAfter: defaultAbortAfter,\n    onHookError: defaultOnHookError,\n  } = config\n\n  const mergeHooks = <T, TContext extends unknown[], TOut>(\n    hooks?: SafeHooks<T, E, TContext, TOut>\n  ): SafeHooks<T, E, TContext, TOut> => {\n    const onHookError = hooks?.onHookError ?? defaultOnHookError\n    return {\n      parseResult: (hooks?.parseResult ?? defaultParseResult) as SafeHooks<\n        T,\n        E,\n        TContext,\n        TOut\n      >['parseResult'],\n      onSuccess: (result, context) => {\n        callHook(() => defaultOnSuccess?.(result), onHookError, 'onSuccess')\n        hooks?.onSuccess?.(result, context)\n      },\n      onError: (error, context) => {\n        callHook(() => defaultOnError?.(error), onHookError, 'onError')\n        hooks?.onError?.(error, context)\n      },\n      onSettled: (result, error, context) => {\n        callHook(\n          () => defaultOnSettled?.(result, error),\n          onHookError,\n          'onSettled'\n        )\n        hooks?.onSettled?.(result, error, context)\n      },\n      onHookError,\n      defaultError: hooks?.defaultError ?? defaultError,\n    }\n  }\n\n  const mergeAsyncHooks = <T, TContext extends unknown[], TOut>(\n    hooks?: SafeAsyncHooks<T, E, TContext, TOut>\n  ): SafeAsyncHooks<T, E, TContext, TOut> => {\n    const onHookError = hooks?.onHookError ?? defaultOnHookError\n    return {\n      parseResult: (hooks?.parseResult ?? defaultParseResult) as SafeAsyncHooks<\n        T,\n        E,\n        TContext,\n        TOut\n      >['parseResult'],\n      onSuccess: (result, context) => {\n        callHook(() => defaultOnSuccess?.(result), onHookError, 'onSuccess')\n        hooks?.onSuccess?.(result, context)\n      },\n      onError: (error, context) => {\n        callHook(() => defaultOnError?.(error), onHookError, 'onError')\n        hooks?.onError?.(error, context)\n      },\n      onSettled: (result, error, context) => {\n        callHook(\n          () => defaultOnSettled?.(result, error),\n          onHookError,\n          'onSettled'\n        )\n        hooks?.onSettled?.(result, error, context)\n      },\n      onRetry: (error, attempt, context) => {\n        callHook(() => defaultOnRetry?.(error, attempt), onHookError, 'onRetry')\n        hooks?.onRetry?.(error, attempt, context)\n      },\n      // Per-call retry completely overrides default retry\n      retry: hooks?.retry ?? defaultRetry,\n      // Per-call abortAfter overrides default abortAfter\n      abortAfter: hooks?.abortAfter ?? defaultAbortAfter,\n      onHookError,\n      defaultError: hooks?.defaultError ?? defaultError,\n    }\n  }\n\n  return {\n    sync: <T, TOut = [TResult] extends [never] ? T : TResult>(\n      fn: () => T,\n      hooks?: SafeHooks<T, E, [], TOut>\n    ): SafeResult<TOut, E> => {\n      return safeSync(\n        fn,\n        parseError,\n        mergeHooks<T, [], TOut>(hooks) as SafeHooks<T, E, [], TOut> & {\n          defaultError: E\n        }\n      )\n    },\n    async: <T, TOut = [TResult] extends [never] ? T : TResult>(\n      fn: (signal?: AbortSignal) => Promise<T>,\n      hooks?: SafeAsyncHooks<T, E, [], TOut>\n    ): Promise<SafeResult<TOut, E>> => {\n      return safeAsync(\n        fn,\n        parseError,\n        mergeAsyncHooks<T, [], TOut>(hooks) as SafeAsyncHooks<\n          T,\n          E,\n          [],\n          TOut\n        > & { defaultError: E }\n      )\n    },\n    wrap: <\n      TArgs extends unknown[],\n      T,\n      TOut = [TResult] extends [never] ? T : TResult,\n    >(\n      fn: (...args: TArgs) => T,\n      hooks?: SafeHooks<T, E, TArgs, TOut>\n    ): ((...args: TArgs) => SafeResult<TOut, E>) => {\n      return wrap(\n        fn,\n        parseError,\n        mergeHooks<T, TArgs, TOut>(hooks) as SafeHooks<T, E, TArgs, TOut> & {\n          defaultError: E\n        }\n      )\n    },\n    wrapAsync: <\n      TArgs extends unknown[],\n      T,\n      TOut = [TResult] extends [never] ? T : TResult,\n    >(\n      fn: (...args: TArgs) => Promise<T>,\n      hooks?: SafeAsyncHooks<T, E, TArgs, TOut>\n    ): ((...args: TArgs) => Promise<SafeResult<TOut, E>>) => {\n      return wrapAsync(\n        fn,\n        parseError,\n        mergeAsyncHooks<T, TArgs, TOut>(hooks) as SafeAsyncHooks<\n          T,\n          E,\n          TArgs,\n          TOut\n        > & { defaultError: E }\n      )\n    },\n    all: <T extends Record<string, (signal?: AbortSignal) => Promise<any>>>(\n      fns: T\n    ) => {\n      type Result = SafeResult<AllValues<T, TResult>, E>\n\n      const keys = Object.keys(fns)\n      const promises = keys.map((key) =>\n        safeAsync(\n          fns[key],\n          parseError,\n          mergeAsyncHooks<unknown, [], unknown>() as SafeAsyncHooks<\n            unknown,\n            E,\n            [],\n            unknown\n          > & { defaultError: E }\n        )\n      )\n\n      if (promises.length === 0) {\n        return Promise.resolve(ok({}) as Result)\n      }\n\n      return new Promise<Result>((resolve) => {\n        const results = new Array<SafeResult<unknown, unknown>>(promises.length)\n        let remaining = promises.length\n        let done = false\n\n        for (let i = 0; i < promises.length; i++) {\n          promises[i].then(\n            (result) => {\n              if (done) return\n              if (!result.ok) {\n                done = true\n                resolve(err(result.error) as Result)\n                return\n              }\n              results[i] = result\n              remaining--\n              if (remaining === 0) {\n                done = true\n                const obj: Record<string, unknown> = {}\n                for (let j = 0; j < keys.length; j++) {\n                  obj[keys[j]] = results[j].value\n                }\n                resolve(ok(obj) as Result)\n              }\n            },\n            (rejection) => {\n              if (done) return\n              done = true\n              resolve(\n                err(\n                  callParseError(\n                    rejection,\n                    parseError,\n                    defaultOnHookError,\n                    defaultError\n                  )\n                ) as Result\n              )\n            }\n          )\n        }\n      })\n    },\n    allSettled: async <\n      T extends Record<string, (signal?: AbortSignal) => Promise<any>>,\n    >(\n      fns: T\n    ) => {\n      type Settled = AllSettledResults<T, E, TResult>\n\n      const keys = Object.keys(fns)\n      const promises = keys.map((key) =>\n        safeAsync(\n          fns[key],\n          parseError,\n          mergeAsyncHooks<unknown, [], unknown>() as SafeAsyncHooks<\n            unknown,\n            E,\n            [],\n            unknown\n          > & { defaultError: E }\n        )\n      )\n      const results = await Promise.all(promises)\n\n      const obj: Record<string, unknown> = {}\n      for (let i = 0; i < keys.length; i++) {\n        obj[keys[i]] = results[i]\n      }\n\n      return obj as Settled\n    },\n  }\n}\n","import type {\n  SafeResult,\n  SafeResultObj,\n  SafeInstance,\n  SafeObjectInstance,\n} from './types'\nimport { okObj, errObj } from './types'\n\nfunction toObjectResult<T, E>(result: SafeResult<T, E>): SafeResultObj<T, E> {\n  if (result.ok) return okObj(result.value as T)\n  return errObj(result.error as E)\n}\n\n// Overload 1: Wrap a single SafeResult tuple → object\nexport function withObjects<T, E>(result: SafeResult<T, E>): SafeResultObj<T, E>\n// Overload 2: Wrap a Promise<SafeResult>\nexport function withObjects<T, E>(\n  result: Promise<SafeResult<T, E>>\n): Promise<SafeResultObj<T, E>>\n// Overload 3: Wrap a sync function returning SafeResult\nexport function withObjects<A extends unknown[], T, E>(\n  fn: (...args: A) => SafeResult<T, E>\n): (...args: A) => SafeResultObj<T, E>\n// Overload 4: Wrap an async function returning Promise<SafeResult>\nexport function withObjects<A extends unknown[], T, E>(\n  fn: (...args: A) => Promise<SafeResult<T, E>>\n): (...args: A) => Promise<SafeResultObj<T, E>>\n// Overload 5: Wrap a SafeInstance\nexport function withObjects<E, TResult>(\n  instance: SafeInstance<E, TResult>\n): SafeObjectInstance<E, TResult>\n// Implementation\nexport function withObjects(input: unknown): unknown {\n  // Overload 1: tuple result\n  if (Array.isArray(input)) {\n    return toObjectResult(input as unknown as SafeResult<unknown, unknown>)\n  }\n\n  // Overload 2: Promise\n  if (input instanceof Promise) {\n    return input.then((result) =>\n      toObjectResult(result as SafeResult<unknown, unknown>)\n    )\n  }\n\n  // Overloads 3/4: function\n  if (typeof input === 'function') {\n    return (...args: unknown[]) => {\n      const result = (input as (...args: unknown[]) => unknown)(...args)\n      if (result instanceof Promise) {\n        return result.then((r) =>\n          toObjectResult(r as SafeResult<unknown, unknown>)\n        )\n      }\n      return toObjectResult(result as SafeResult<unknown, unknown>)\n    }\n  }\n\n  // Overload 5: SafeInstance\n  if (\n    typeof input === 'object' &&\n    input !== null &&\n    'sync' in input &&\n    'async' in input\n  ) {\n    const instance = input as SafeInstance<any, any>\n    return {\n      sync: (fn: any, hooks?: any) => toObjectResult(instance.sync(fn, hooks)),\n      async: (fn: any, hooks?: any) =>\n        instance.async(fn, hooks).then(toObjectResult),\n      wrap: (fn: any, hooks?: any) => {\n        const wrapped = instance.wrap(fn, hooks)\n        return (...args: any[]) => toObjectResult(wrapped(...args))\n      },\n      wrapAsync: (fn: any, hooks?: any) => {\n        const wrapped = instance.wrapAsync(fn, hooks)\n        return (...args: any[]) => wrapped(...args).then(toObjectResult)\n      },\n      all: (fns: any) => instance.all(fns).then(toObjectResult),\n      allSettled: async (fns: any) => {\n        const results = (await instance.allSettled(fns)) as Record<\n          string,\n          SafeResult<unknown, unknown>\n        >\n        const obj: Record<string, SafeResultObj<unknown, unknown>> = {}\n        for (const key of Object.keys(results)) {\n          obj[key] = toObjectResult(results[key])\n        }\n        return obj\n      },\n    } as SafeObjectInstance<any, any>\n  }\n\n  throw new TypeError('withObjects: unsupported input type')\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@cometloop/safe",
+  "version": "0.0.1",
+  "description": "Zero-dependency, type-safe error handling using a result tuple pattern for TypeScript",
+  "author": "cometloop",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cometloop/safe.git",
+    "directory": "packages/safe"
+  },
+  "homepage": "https://github.com/cometloop/safe#readme",
+  "bugs": {
+    "url": "https://github.com/cometloop/safe/issues"
+  },
+  "keywords": [
+    "error-handling",
+    "result",
+    "typescript",
+    "safe",
+    "tuple",
+    "try-catch",
+    "type-safe"
+  ],
+  "engines": {
+    "node": ">=14"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "lint": "eslint \"**/*.ts\"",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage"
+  },
+  "devDependencies": {
+    "@core/eslint-config": "workspace:*",
+    "@core/typescript-config": "workspace:*",
+    "@vitest/coverage-v8": "^4.0.16",
+    "@vitest/ui": "^4.0.16",
+    "eslint": "^8.57.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.5.4",
+    "vitest": "^4.0.16"
+  }
+}