@twinedo/app-error 1.0.0 → 1.0.1

package/README.md

@@ -1,8 +1,51 @@
 # @twinedo/app-error
 
-A small, dependency-free error normalization layer that turns any thrown error
-(fetch, axios-like, or runtime) into a predictable `AppError` shape. Use it to
-standardize UI messaging, retry logic, and logging across mixed stacks.
+Framework-agnostic error normalization for fetch, axios-like clients, and runtime failures.
+
+## Why this exists
+
+Most teams talk to more than one backend.
+Each backend returns a different error shape (Project A vs Project B).
+fetch and axios surface errors in different ways.
+So every project rewrites the same parsing, message, and retry rules.
+This library produces one predictable AppError for UI, logging, and retries.
+
+## Features
+
+- Predictable `AppError` shape for UI, logging, and retry logic
+- Works with `fetch` responses and axios-like errors
+- Configurable per backend via `defineErrorPolicy`
+- Framework-agnostic (React, React Native, Vue, Angular, Node)
+- TypeScript-first with exported types
+- Defensive normalization that never throws
+- Retry decision helpers like `isRetryable`
+- Zero dependencies
+
+## Guarantees & Non-Goals
+
+### Guarantees
+This library guarantees that:
+
+- Every normalization function (`toAppError`, `fromFetch`, `fromFetchResponse`) **never throws**
+- You always receive a **predictable `AppError` shape**
+- `message` is always safe to display in UI
+- Original errors are preserved via `cause` for debugging
+- No input error is mutated
+- Behavior is deterministic and side-effect free
+- Fully TypeScript-friendly with stable public types
+
+### Non-Goals
+This library intentionally does NOT:
+
+- Automatically guess backend-specific error schemas
+- Perform logging, reporting, or analytics
+- Display UI or toast notifications
+- Enforce localization or translations
+- Replace HTTP clients like fetch or axios
+- Hide errors or swallow failures silently
+
+If your project has backend-specific error formats, use
+`defineErrorPolicy` to explicitly describe how errors should be interpreted.
 
 ## Install
 
@@ -10,119 +53,134 @@ standardize UI messaging, retry logic, and logging across mixed stacks.
 npm install @twinedo/app-error
 ```
 
-## What problem this solves
+Published as the scoped package `@twinedo/app-error`. Ships ESM + CJS builds
+with TypeScript types and works in Node and browser runtimes.
 
-Different APIs and HTTP clients emit wildly different error shapes. This library
-normalizes them into a single `AppError` so your app can consistently:
-- show a safe UI message
-- decide whether to retry
-- log a stable fingerprint
+## Examples
 
-## Axios example
+### Example 1 — Axios with try/catch
 
 ```ts
 import axios from "axios";
-import { toAppError } from "@twinedo/app-error";
+import { defineErrorPolicy, isRetryable, toAppError } from "@twinedo/app-error";
+
+const policy = defineErrorPolicy();
 
 try {
-  await axios.get("/api/user");
-} catch (error) {
-  const appError = toAppError(error);
-  console.log(appError.kind, appError.status, appError.message);
+  const response = await axios.get<{ id: string; name: string }>("/api/user");
+  console.log("User:", response.data.name);
+} catch (err) {
+  const appError = toAppError(err, policy);
+  console.error(appError.message);
+
+  if (isRetryable(appError)) {
+    // show a retry action or schedule a retry
+  }
 }
 ```
 
-## Fetch example
+### Example 2 — Fetch handling non-OK responses
 
 ```ts
-import { fromFetch } from "@twinedo/app-error";
+import { defineErrorPolicy, fromFetchResponse, toAppError } from "@twinedo/app-error";
+
+const policy = defineErrorPolicy();
 
-const response = await fetch("/api/user");
-const body = await response.json().catch(() => undefined);
+try {
+  const res = await fetch("/api/user");
+
+  if (!res.ok) {
+    throw await fromFetchResponse(res, policy);
+  }
 
-if (!response.ok) {
-  throw fromFetch(response, body);
+  const data = await res.json();
+  console.log("User:", data);
+} catch (err) {
+  const appError = toAppError(err, policy);
+  console.error(appError.message);
 }
 ```
 
-## Project A vs Project B policy configuration
+### Example 3 — Project A vs Project B backend policies
 
 ```ts
-import { defineErrorPolicy } from "@twinedo/app-error";
+import axios from "axios";
+import { defineErrorPolicy, toAppError } from "@twinedo/app-error";
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null;
 
+const readString = (value: unknown): string | undefined =>
+  typeof value === "string" ? value : undefined;
+
+const readHeader = (headers: unknown, name: string): string | undefined => {
+  if (!headers) return undefined;
+  const getter = (headers as { get?: (key: string) => string | null | undefined })
+    .get;
+  if (typeof getter === "function") {
+    return getter.call(headers, name) ?? undefined;
+  }
+  return readString((headers as Record<string, unknown>)[name]);
+};
+
+// Project A (Tony backend): { error: { message, code } }, header x-request-id
 const projectAPolicy = defineErrorPolicy({
   http: {
-    message: (data) => (typeof data === "object" && data ? data.message : undefined),
-    code: (data) => (typeof data === "object" && data ? data.code : undefined),
-    requestId: (headers) => headers?.get?.("x-request-id") ?? undefined,
+    message: (data) =>
+      isRecord(data) && isRecord(data.error)
+        ? readString(data.error.message)
+        : undefined,
+    code: (data) =>
+      isRecord(data) && isRecord(data.error)
+        ? readString(data.error.code)
+        : undefined,
+    requestId: (headers) => readHeader(headers, "x-request-id"),
   },
 });
 
+// Project B (Bobby backend): { message | msg, code }, header x-correlation-id
 const projectBPolicy = defineErrorPolicy({
   http: {
     message: (data) =>
-      typeof data === "object" && data && "error" in data
-        ? String((data as { error: unknown }).error)
-        : undefined,
-    code: (data) =>
-      typeof data === "object" && data && "errorCode" in data
-        ? String((data as { errorCode: unknown }).errorCode)
+      isRecord(data)
+        ? readString(data.message) ?? readString(data.msg)
         : undefined,
-    requestId: (headers) => headers?.get?.("x-correlation-id") ?? undefined,
-    retryable: (status) => status === 429 || (status ? status >= 500 : false),
+    code: (data) => (isRecord(data) ? readString(data.code) : undefined),
+    requestId: (headers) => readHeader(headers, "x-correlation-id"),
   },
 });
-```
 
-## React / React Native usage
-
-```tsx
-import { useEffect, useState } from "react";
-import { fromFetch, isRetryable, toAppError } from "@twinedo/app-error";
-
-export function ProfileScreen() {
-  const [error, setError] = useState<ReturnType<typeof toAppError> | null>(null);
-
-  useEffect(() => {
-    let mounted = true;
-    fetch("/api/profile")
-      .then(async (response) => {
-        const body = await response.json().catch(() => undefined);
-        if (!response.ok) throw fromFetch(response, body);
-        return body;
-      })
-      .catch((err) => {
-        if (!mounted) return;
-        setError(toAppError(err));
-      });
-
-    return () => {
-      mounted = false;
-    };
-  }, []);
-
-  if (!error) return null;
-
-  return (
-    <>
-      <Text>{error.message}</Text>
-      {isRetryable(error) ? <Button title="Retry" /> : null}
-    </>
-  );
+const handleError = (
+  err: unknown,
+  policy: ReturnType<typeof defineErrorPolicy>
+) => {
+  const appError = toAppError(err, policy);
+  console.error(appError.message, appError.code, appError.requestId);
+};
+
+try {
+  await axios.get("/api/user");
+} catch (err) {
+  handleError(err, projectAPolicy);
+}
+
+try {
+  await axios.get("/api/user");
+} catch (err) {
+  handleError(err, projectBPolicy);
 }
 ```
 
-## Retry decision example
+### Example 4 — attempt() helper
 
 ```ts
-import { isRetryable, toAppError } from "@twinedo/app-error";
+import { attempt } from "@twinedo/app-error";
 
-try {
-  await apiCall();
-} catch (error) {
-  const appError = toAppError(error);
-  if (isRetryable(appError)) {
-    // show retry action or auto-retry
-  }
+const result = await attempt(() => apiCall());
+
+if (result.ok) {
+  console.log("Data:", result.data);
+} else {
+  console.error(result.error.message);
 }
 ```

package/dist/index.cjs

@@ -24,6 +24,7 @@ __export(index_exports, {
   defineErrorPolicy: () => defineErrorPolicy,
   errorKey: () => errorKey,
   fromFetch: () => fromFetch,
+  fromFetchResponse: () => fromFetchResponse,
   isAppError: () => isAppError,
   isRetryable: () => isRetryable,
   toAppError: () => toAppError
@@ -237,6 +238,34 @@ var fromFetch = (response, body, policy) => {
   };
 };
 
+// src/fromFetchResponse.ts
+var readResponseBody = async (response) => {
+  const reader = response.text;
+  if (typeof reader !== "function") return void 0;
+  if (response.bodyUsed) return void 0;
+  let text;
+  try {
+    text = await reader.call(response);
+  } catch {
+    return void 0;
+  }
+  if (text.trim().length === 0) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+};
+var fromFetchResponse = async (response, policy) => {
+  const safeResponse = response ?? {};
+  try {
+    const body = await readResponseBody(safeResponse);
+    return fromFetch(safeResponse, body, policy);
+  } catch {
+    return fromFetch(safeResponse, void 0, policy);
+  }
+};
+
 // src/adapters/axiosLike.ts
 var TIMEOUT_CODES = /* @__PURE__ */ new Set(["ECONNABORTED", "ETIMEDOUT", "ESOCKETTIMEDOUT"]);
 var NETWORK_CODES = /* @__PURE__ */ new Set([
@@ -546,6 +575,7 @@ var attempt = async (fn, policy) => {
   defineErrorPolicy,
   errorKey,
   fromFetch,
+  fromFetchResponse,
   isAppError,
   isRetryable,
   toAppError

package/dist/index.d.cts

@@ -41,6 +41,12 @@ type FetchResponseLike = {
 };
 declare const fromFetch: (response: FetchResponseLike, body?: unknown, policy?: ErrorPolicy) => AppError;
 
+type FetchResponseWithBody = FetchResponseLike & {
+    text?: () => Promise<string>;
+    bodyUsed?: boolean;
+};
+declare const fromFetchResponse: (response: FetchResponseWithBody, policy?: ErrorPolicy) => Promise<AppError>;
+
 declare const toAppError: (error: unknown, policy?: ErrorPolicy) => AppError;
 
 type AttemptResult<T> = {
@@ -55,4 +61,4 @@ declare const errorKey: (error: AppError | unknown) => string;
 declare const isRetryable: (error: AppError | unknown) => boolean;
 declare const attempt: <T>(fn: () => T | Promise<T>, policy?: ErrorPolicy) => Promise<AttemptResult<T>>;
 
-export { type AppError, type AppErrorKind, type ErrorPolicy, type HeadersLike, type HttpPolicy, type HttpResponseLike, type NormalizedErrorPolicy, attempt, defineErrorPolicy, errorKey, fromFetch, isAppError, isRetryable, toAppError };
+export { type AppError, type AppErrorKind, type ErrorPolicy, type HeadersLike, type HttpPolicy, type HttpResponseLike, type NormalizedErrorPolicy, attempt, defineErrorPolicy, errorKey, fromFetch, fromFetchResponse, isAppError, isRetryable, toAppError };

package/dist/index.d.ts

@@ -41,6 +41,12 @@ type FetchResponseLike = {
 };
 declare const fromFetch: (response: FetchResponseLike, body?: unknown, policy?: ErrorPolicy) => AppError;
 
+type FetchResponseWithBody = FetchResponseLike & {
+    text?: () => Promise<string>;
+    bodyUsed?: boolean;
+};
+declare const fromFetchResponse: (response: FetchResponseWithBody, policy?: ErrorPolicy) => Promise<AppError>;
+
 declare const toAppError: (error: unknown, policy?: ErrorPolicy) => AppError;
 
 type AttemptResult<T> = {
@@ -55,4 +61,4 @@ declare const errorKey: (error: AppError | unknown) => string;
 declare const isRetryable: (error: AppError | unknown) => boolean;
 declare const attempt: <T>(fn: () => T | Promise<T>, policy?: ErrorPolicy) => Promise<AttemptResult<T>>;
 
-export { type AppError, type AppErrorKind, type ErrorPolicy, type HeadersLike, type HttpPolicy, type HttpResponseLike, type NormalizedErrorPolicy, attempt, defineErrorPolicy, errorKey, fromFetch, isAppError, isRetryable, toAppError };
+export { type AppError, type AppErrorKind, type ErrorPolicy, type HeadersLike, type HttpPolicy, type HttpResponseLike, type NormalizedErrorPolicy, attempt, defineErrorPolicy, errorKey, fromFetch, fromFetchResponse, isAppError, isRetryable, toAppError };

package/dist/index.js

@@ -205,6 +205,34 @@ var fromFetch = (response, body, policy) => {
   };
 };
 
+// src/fromFetchResponse.ts
+var readResponseBody = async (response) => {
+  const reader = response.text;
+  if (typeof reader !== "function") return void 0;
+  if (response.bodyUsed) return void 0;
+  let text;
+  try {
+    text = await reader.call(response);
+  } catch {
+    return void 0;
+  }
+  if (text.trim().length === 0) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+};
+var fromFetchResponse = async (response, policy) => {
+  const safeResponse = response ?? {};
+  try {
+    const body = await readResponseBody(safeResponse);
+    return fromFetch(safeResponse, body, policy);
+  } catch {
+    return fromFetch(safeResponse, void 0, policy);
+  }
+};
+
 // src/adapters/axiosLike.ts
 var TIMEOUT_CODES = /* @__PURE__ */ new Set(["ECONNABORTED", "ETIMEDOUT", "ESOCKETTIMEDOUT"]);
 var NETWORK_CODES = /* @__PURE__ */ new Set([
@@ -513,6 +541,7 @@ export {
   defineErrorPolicy,
   errorKey,
   fromFetch,
+  fromFetchResponse,
   isAppError,
   isRetryable,
   toAppError

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@twinedo/app-error",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "A configurable error normalization layer for fetch, axios-like, and runtime errors.",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -40,4 +40,4 @@
     "url": "https://github.com/twinedo/app-error/issues"
   },
   "homepage": "https://github.com/twinedo/app-error#readme"
-}
+}

package/dist/index.mjs

@@ -1,510 +0,0 @@
-// src/policy.ts
-var DEFAULT_REQUEST_ID_HEADERS = [
-  "x-request-id",
-  "x-correlation-id",
-  "x-trace-id",
-  "traceparent",
-  "x-amzn-trace-id"
-];
-var isRecord = (value) => typeof value === "object" && value !== null;
-var normalizeString = (value) => {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-};
-var normalizeHeaderValue = (value) => {
-  if (typeof value === "number") return String(value);
-  if (typeof value === "string") return value;
-  return void 0;
-};
-var getHeaderValue = (headers, name) => {
-  if (!headers) return void 0;
-  const lowerName = name.toLowerCase();
-  const getter = headers.get;
-  if (typeof getter === "function") {
-    const value = getter.call(headers, name) ?? getter.call(headers, lowerName);
-    const normalized = normalizeString(value);
-    if (normalized) return normalized;
-  }
-  if (isRecord(headers)) {
-    for (const key of Object.keys(headers)) {
-      if (key.toLowerCase() !== lowerName) continue;
-      const raw = headers[key];
-      if (Array.isArray(raw)) {
-        const first = normalizeHeaderValue(raw[0]);
-        const normalized = normalizeString(first);
-        if (normalized) return normalized;
-      } else {
-        const normalized = normalizeString(normalizeHeaderValue(raw));
-        if (normalized) return normalized;
-      }
-    }
-  }
-  return void 0;
-};
-var extractString = (value) => normalizeString(value);
-var extractFromArray = (value) => {
-  for (const item of value) {
-    const message = extractMessageFromData(item);
-    if (message) return message;
-  }
-  return void 0;
-};
-var extractMessageFromData = (data) => {
-  const direct = extractString(data);
-  if (direct) return direct;
-  if (Array.isArray(data)) return extractFromArray(data);
-  if (!isRecord(data)) return void 0;
-  const directKeys = ["message", "error", "detail", "title", "description"];
-  for (const key of directKeys) {
-    const value = extractString(data[key]);
-    if (value) return value;
-  }
-  const errorValue = data.error;
-  if (isRecord(errorValue)) {
-    const nested = extractString(errorValue.message) ?? extractString(errorValue.detail);
-    if (nested) return nested;
-  }
-  const errorsValue = data.errors;
-  if (Array.isArray(errorsValue)) {
-    const nested = extractFromArray(errorsValue);
-    if (nested) return nested;
-  }
-  if (isRecord(errorsValue)) {
-    for (const key of Object.keys(errorsValue)) {
-      const fieldValue = errorsValue[key];
-      if (Array.isArray(fieldValue)) {
-        const nested = extractFromArray(fieldValue);
-        if (nested) return nested;
-      } else {
-        const nested = extractString(fieldValue);
-        if (nested) return nested;
-      }
-    }
-  }
-  return void 0;
-};
-var extractCodeFromData = (data) => {
-  if (Array.isArray(data)) {
-    for (const item of data) {
-      const code = extractCodeFromData(item);
-      if (code) return code;
-    }
-    return void 0;
-  }
-  if (!isRecord(data)) return void 0;
-  const directKeys = ["code", "errorCode", "error_code"];
-  for (const key of directKeys) {
-    const value = extractString(data[key]);
-    if (value) return value;
-  }
-  const errorValue = data.error;
-  if (isRecord(errorValue)) {
-    const nested = extractString(errorValue.code) ?? extractString(errorValue.errorCode);
-    if (nested) return nested;
-  }
-  return void 0;
-};
-var defaultHttpMessage = (data, response) => {
-  const fromData = extractMessageFromData(data);
-  if (fromData) return fromData;
-  return extractString(response?.statusText);
-};
-var defaultHttpCode = (data) => extractCodeFromData(data);
-var defaultRequestId = (headers) => {
-  for (const header of DEFAULT_REQUEST_ID_HEADERS) {
-    const value = getHeaderValue(headers, header);
-    if (value) return value;
-  }
-  return void 0;
-};
-var defaultHttpRetryable = (status) => {
-  if (typeof status !== "number") return false;
-  return status >= 500 && status <= 599;
-};
-var DEFAULT_HTTP_POLICY = {
-  message: defaultHttpMessage,
-  code: defaultHttpCode,
-  requestId: defaultRequestId,
-  retryable: defaultHttpRetryable
-};
-var defineErrorPolicy = (...configs) => {
-  const merged = {};
-  for (const config of configs) {
-    if (!config?.http) continue;
-    Object.assign(merged, config.http);
-  }
-  return {
-    http: {
-      message: merged.message ?? DEFAULT_HTTP_POLICY.message,
-      code: merged.code ?? DEFAULT_HTTP_POLICY.code,
-      requestId: merged.requestId ?? DEFAULT_HTTP_POLICY.requestId,
-      retryable: merged.retryable ?? DEFAULT_HTTP_POLICY.retryable
-    }
-  };
-};
-
-// src/types.ts
-var APP_ERROR_KINDS = {
-  http: true,
-  network: true,
-  timeout: true,
-  parse: true,
-  validation: true,
-  unknown: true
-};
-var isRecord2 = (value) => typeof value === "object" && value !== null;
-var isAppError = (value) => {
-  if (!isRecord2(value)) return false;
-  const kind = value.kind;
-  if (typeof kind !== "string" || !(kind in APP_ERROR_KINDS)) return false;
-  return typeof value.message === "string";
-};
-
-// src/fromFetch.ts
-var DEFAULT_MESSAGE = "Something went wrong";
-var normalizeMessage = (value) => {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-};
-var defaultRetryable = (status) => {
-  if (typeof status !== "number") return false;
-  return status >= 500 && status <= 599;
-};
-var safeInvoke = (fn) => {
-  try {
-    return fn();
-  } catch {
-    return void 0;
-  }
-};
-var fromFetch = (response, body, policy) => {
-  const resolvedPolicy = defineErrorPolicy(policy);
-  const status = typeof response.status === "number" ? response.status : void 0;
-  const message = normalizeMessage(
-    safeInvoke(() => resolvedPolicy.http.message(body, response))
-  ) ?? DEFAULT_MESSAGE;
-  const code = normalizeMessage(
-    safeInvoke(() => resolvedPolicy.http.code(body, response))
-  );
-  const requestId = normalizeMessage(
-    safeInvoke(() => resolvedPolicy.http.requestId(response.headers))
-  );
-  const retryable = safeInvoke(() => resolvedPolicy.http.retryable(status)) ?? defaultRetryable(status);
-  return {
-    kind: "http",
-    message,
-    retryable,
-    ...status !== void 0 ? { status } : {},
-    ...code ? { code } : {},
-    ...requestId ? { requestId } : {},
-    ...body !== void 0 ? { details: body } : {},
-    ...response !== void 0 ? { cause: response } : {}
-  };
-};
-
-// src/adapters/axiosLike.ts
-var TIMEOUT_CODES = /* @__PURE__ */ new Set(["ECONNABORTED", "ETIMEDOUT", "ESOCKETTIMEDOUT"]);
-var NETWORK_CODES = /* @__PURE__ */ new Set([
-  "ERR_NETWORK",
-  "ENOTFOUND",
-  "ECONNREFUSED",
-  "ECONNRESET",
-  "EAI_AGAIN",
-  "ETIMEDOUT",
-  "EHOSTUNREACH",
-  "ENETUNREACH"
-]);
-var isRecord3 = (value) => typeof value === "object" && value !== null;
-var getString = (value) => typeof value === "string" ? value : void 0;
-var getStatus = (value) => typeof value === "number" ? value : void 0;
-var getResponseLike = (value) => {
-  if (!isRecord3(value)) return void 0;
-  return {
-    status: getStatus(value.status),
-    statusText: getString(value.statusText),
-    data: value.data,
-    headers: value.headers
-  };
-};
-var getAxiosLikeErrorInfo = (error) => {
-  if (!isRecord3(error)) return null;
-  const isAxiosMarker = error.isAxiosError === true;
-  const response = getResponseLike(error.response);
-  const request = error.request;
-  const looksAxios = isAxiosMarker || response !== void 0 || request !== void 0;
-  if (!looksAxios) return null;
-  const code = getString(error.code);
-  const message = getString(error.message);
-  const status = response?.status;
-  const data = response?.data;
-  const headers = response?.headers;
-  const messageLower = message?.toLowerCase();
-  const isTimeout = (code ? TIMEOUT_CODES.has(code) : false) || (messageLower ? messageLower.includes("timeout") : false);
-  const isNetworkError2 = !response && (request !== void 0 || (code ? NETWORK_CODES.has(code) : false) || (messageLower ? messageLower.includes("network error") : false));
-  return {
-    response,
-    status,
-    data,
-    headers,
-    code,
-    message,
-    isTimeout,
-    isNetworkError: isNetworkError2
-  };
-};
-var toHttpResponseLike = (info) => {
-  if (!info.response) return void 0;
-  return {
-    status: info.status,
-    statusText: info.response.statusText,
-    headers: info.headers
-  };
-};
-
-// src/toAppError.ts
-var DEFAULT_MESSAGE2 = "Something went wrong";
-var NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
-  "ENOTFOUND",
-  "ECONNREFUSED",
-  "ECONNRESET",
-  "EAI_AGAIN",
-  "EHOSTUNREACH",
-  "ENETUNREACH",
-  "ERR_NETWORK"
-]);
-var TIMEOUT_ERROR_CODES = /* @__PURE__ */ new Set([
-  "ETIMEDOUT",
-  "ESOCKETTIMEDOUT",
-  "ECONNABORTED"
-]);
-var isRecord4 = (value) => typeof value === "object" && value !== null;
-var getString2 = (value) => typeof value === "string" ? value : void 0;
-var normalizeMessage2 = (value) => {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-};
-var defaultRetryable2 = (kind, status) => {
-  if (kind === "network") return true;
-  if (kind === "http" && typeof status === "number") {
-    return status >= 500 && status <= 599;
-  }
-  return false;
-};
-var safeInvoke2 = (fn) => {
-  try {
-    return fn();
-  } catch {
-    return void 0;
-  }
-};
-var getErrorInfo = (error) => {
-  if (!isRecord4(error)) return { name: void 0, message: void 0, code: void 0 };
-  return {
-    name: getString2(error.name),
-    message: getString2(error.message),
-    code: getString2(error.code)
-  };
-};
-var isTimeoutError = (name, message, code) => {
-  if (name === "AbortError") return true;
-  if (code && TIMEOUT_ERROR_CODES.has(code)) return true;
-  const lowered = message?.toLowerCase();
-  return lowered ? lowered.includes("timeout") : false;
-};
-var isNetworkError = (name, message, code) => {
-  if (name === "TypeError") {
-    const lowered2 = message?.toLowerCase() ?? "";
-    if (lowered2.includes("failed to fetch") || lowered2.includes("network request failed") || lowered2.includes("networkerror") || lowered2.includes("load failed")) {
-      return true;
-    }
-  }
-  if (code && NETWORK_ERROR_CODES.has(code)) return true;
-  const lowered = message?.toLowerCase() ?? "";
-  return lowered.includes("network error");
-};
-var isParseError = (name) => name === "SyntaxError";
-var isValidationError = (error, name) => {
-  if (name && name.toLowerCase().includes("validation")) return true;
-  if (!isRecord4(error)) return false;
-  return Array.isArray(error.issues) || Array.isArray(error.errors);
-};
-var normalizeExisting = (error) => {
-  const message = normalizeMessage2(error.message) ?? DEFAULT_MESSAGE2;
-  const retryable = typeof error.retryable === "boolean" ? error.retryable : defaultRetryable2(error.kind, error.status);
-  return {
-    ...error,
-    message,
-    retryable
-  };
-};
-var buildAppError = (options) => ({
-  kind: options.kind,
-  message: options.message,
-  retryable: options.retryable,
-  ...options.status !== void 0 ? { status: options.status } : {},
-  ...options.code ? { code: options.code } : {},
-  ...options.requestId ? { requestId: options.requestId } : {},
-  ...options.details !== void 0 ? { details: options.details } : {},
-  ...options.cause !== void 0 ? { cause: options.cause } : {}
-});
-var fromStatusObject = (error, policy) => {
-  if (!isRecord4(error)) return null;
-  if (typeof error.status !== "number" || error.status < 400) return null;
-  const response = {
-    status: error.status,
-    statusText: getString2(error.statusText),
-    headers: error.headers
-  };
-  const details = error.data !== void 0 ? error.data : error.body !== void 0 ? error.body : error.details;
-  const message = normalizeMessage2(safeInvoke2(() => policy.http.message(details, response))) ?? DEFAULT_MESSAGE2;
-  const code = safeInvoke2(() => policy.http.code(details, response));
-  const requestId = safeInvoke2(() => policy.http.requestId(response.headers));
-  const retryable = safeInvoke2(() => policy.http.retryable(error.status)) ?? defaultRetryable2("http", error.status);
-  return buildAppError({
-    kind: "http",
-    message,
-    status: error.status,
-    code: normalizeMessage2(code),
-    retryable,
-    requestId: normalizeMessage2(requestId),
-    details,
-    cause: error
-  });
-};
-var toAppError = (error, policy) => {
-  const resolvedPolicy = defineErrorPolicy(policy);
-  try {
-    if (isAppError(error)) return normalizeExisting(error);
-    const axiosInfo = getAxiosLikeErrorInfo(error);
-    if (axiosInfo) {
-      if (axiosInfo.response) {
-        const response = toHttpResponseLike(axiosInfo);
-        const message2 = normalizeMessage2(
-          safeInvoke2(() => resolvedPolicy.http.message(axiosInfo.data, response))
-        ) ?? DEFAULT_MESSAGE2;
-        const code2 = safeInvoke2(
-          () => resolvedPolicy.http.code(axiosInfo.data, response)
-        );
-        const requestId = safeInvoke2(
-          () => resolvedPolicy.http.requestId(axiosInfo.headers)
-        );
-        const retryable = safeInvoke2(() => resolvedPolicy.http.retryable(axiosInfo.status)) ?? defaultRetryable2("http", axiosInfo.status);
-        return buildAppError({
-          kind: "http",
-          message: message2,
-          status: axiosInfo.status,
-          code: normalizeMessage2(code2),
-          retryable,
-          requestId: normalizeMessage2(requestId),
-          details: axiosInfo.data,
-          cause: error
-        });
-      }
-      if (axiosInfo.isTimeout) {
-        return buildAppError({
-          kind: "timeout",
-          message: DEFAULT_MESSAGE2,
-          retryable: false,
-          cause: error
-        });
-      }
-      if (axiosInfo.isNetworkError) {
-        return buildAppError({
-          kind: "network",
-          message: DEFAULT_MESSAGE2,
-          retryable: true,
-          cause: error
-        });
-      }
-    }
-    const { name, message, code } = getErrorInfo(error);
-    if (isTimeoutError(name, message, code)) {
-      return buildAppError({
-        kind: "timeout",
-        message: DEFAULT_MESSAGE2,
-        retryable: false,
-        cause: error
-      });
-    }
-    if (isNetworkError(name, message, code)) {
-      return buildAppError({
-        kind: "network",
-        message: DEFAULT_MESSAGE2,
-        retryable: true,
-        cause: error
-      });
-    }
-    if (isParseError(name)) {
-      return buildAppError({
-        kind: "parse",
-        message: DEFAULT_MESSAGE2,
-        retryable: false,
-        cause: error
-      });
-    }
-    if (isValidationError(error, name)) {
-      return buildAppError({
-        kind: "validation",
-        message: DEFAULT_MESSAGE2,
-        retryable: false,
-        cause: error,
-        details: error
-      });
-    }
-    const httpFromStatus = fromStatusObject(error, resolvedPolicy);
-    if (httpFromStatus) return httpFromStatus;
-  } catch {
-  }
-  return buildAppError({
-    kind: "unknown",
-    message: DEFAULT_MESSAGE2,
-    retryable: false,
-    cause: error
-  });
-};
-
-// src/helpers.ts
-var normalizeMessage3 = (value) => {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-};
-var errorKey = (error) => {
-  const normalized = isAppError(error) ? error : toAppError(error);
-  const parts = [
-    normalized.kind,
-    normalized.status !== void 0 ? String(normalized.status) : void 0,
-    normalizeMessage3(normalized.code),
-    normalizeMessage3(normalized.message)
-  ].filter((value) => Boolean(value));
-  return parts.join("|");
-};
-var isRetryable = (error) => {
-  const normalized = isAppError(error) ? error : toAppError(error);
-  if (typeof normalized.retryable === "boolean") return normalized.retryable;
-  if (normalized.kind === "network") return true;
-  if (normalized.kind === "http") {
-    return typeof normalized.status === "number" && normalized.status >= 500;
-  }
-  return false;
-};
-var attempt = async (fn, policy) => {
-  try {
-    const data = await fn();
-    return { ok: true, data };
-  } catch (error) {
-    return { ok: false, error: toAppError(error, policy) };
-  }
-};
-export {
-  attempt,
-  defineErrorPolicy,
-  errorKey,
-  fromFetch,
-  isAppError,
-  isRetryable,
-  toAppError
-};