@ai-matrx/api 0.0.0-stage → 0.1.0

package/dist/chunk-2SXAAKGV.cjs

@@ -0,0 +1,279 @@
+'use strict';
+
+// src/net/errors.ts
+var NetError = class extends Error {
+  code;
+  cause;
+  status;
+  retryable;
+  constructor(code, message, opts = {}) {
+    super(message);
+    this.name = "NetError";
+    this.code = code;
+    this.cause = opts.cause;
+    if (opts.status !== void 0) this.status = opts.status;
+    this.retryable = opts.retryable ?? false;
+  }
+};
+var ConnectTimeoutError = class extends NetError {
+  constructor(ms, cause) {
+    super("connect-timeout", `Connection timed out after ${ms}ms`, {
+      cause,
+      retryable: true
+    });
+    this.name = "ConnectTimeoutError";
+  }
+};
+var TotalTimeoutError = class extends NetError {
+  constructor(ms, cause) {
+    super("total-timeout", `Request exceeded ${ms}ms total budget`, {
+      cause,
+      retryable: false
+    });
+    this.name = "TotalTimeoutError";
+  }
+};
+var HeartbeatTimeoutError = class extends NetError {
+  constructor(ms, cause) {
+    super(
+      "heartbeat-timeout",
+      `No server activity for ${ms}ms \u2014 stream considered dead`,
+      { cause, retryable: false }
+    );
+    this.name = "HeartbeatTimeoutError";
+  }
+};
+var NetworkError = class extends NetError {
+  constructor(message, cause) {
+    super("network", message, { cause, retryable: true });
+    this.name = "NetworkError";
+  }
+};
+var HttpError = class extends NetError {
+  constructor(status, message, cause) {
+    const retryable = status === 408 || status === 429 || status >= 500;
+    super("http", message, { cause, status, retryable });
+    this.name = "HttpError";
+  }
+};
+var AbortedError = class extends NetError {
+  constructor(cause) {
+    super("aborted", "Request was aborted", { cause, retryable: false });
+    this.name = "AbortedError";
+  }
+};
+var OfflineError = class extends NetError {
+  constructor() {
+    super("offline", "Browser is offline", { retryable: true });
+    this.name = "OfflineError";
+  }
+};
+function isNetError(err) {
+  return err instanceof NetError;
+}
+function extractErrorMessage(err, fallback = "An unexpected error occurred") {
+  if (!err) return "Unknown error";
+  if (typeof err === "string") return err;
+  if (err instanceof Error) return err.message;
+  if (typeof err === "object") {
+    const e = err;
+    const parts = [];
+    if (typeof e.message === "string" && e.message) parts.push(e.message);
+    if (parts.length === 0) {
+      if (typeof e.detail === "string" && e.detail) parts.push(e.detail);
+      else if (e.detail && typeof e.detail === "object") {
+        const d = e.detail;
+        if (typeof d.message === "string" && d.message) parts.push(d.message);
+      }
+    }
+    if (typeof e.details === "string" && e.details) parts.push(e.details);
+    if (typeof e.hint === "string" && e.hint) parts.push(`Hint: ${e.hint}`);
+    if (typeof e.code === "string" && e.code) parts.push(`Code: ${e.code}`);
+    if (parts.length > 0) return parts.join(" \xB7 ");
+    const nested = extractNestedErrorMessage(e, 0);
+    if (nested !== null) return nested;
+    try {
+      const s = JSON.stringify(err);
+      if (s && s !== "{}") return s;
+    } catch {
+    }
+  }
+  return fallback;
+}
+function extractNestedErrorMessage(e, depth) {
+  if (depth > 4) return null;
+  for (const key of ["error", "exception", "cause"]) {
+    const value = e[key];
+    if (typeof value === "string" && value) return value;
+    if (value && typeof value === "object") {
+      const inner = value;
+      if (typeof inner.message === "string" && inner.message) return inner.message;
+      if (typeof inner.detail === "string" && inner.detail) return inner.detail;
+      const deeper = extractNestedErrorMessage(inner, depth + 1);
+      if (deeper !== null) return deeper;
+    }
+  }
+  return null;
+}
+function isTransportFailure(err) {
+  if (err instanceof NetworkError || err instanceof OfflineError) return true;
+  if (typeof navigator !== "undefined" && navigator.onLine === false) return true;
+  if (err instanceof TypeError) return true;
+  if (err && typeof err === "object") {
+    const e = err;
+    if (e.code || e.status) return false;
+    const text = `${typeof e.name === "string" ? e.name : ""} ${typeof e.message === "string" ? e.message : ""}`.toLowerCase();
+    return text.includes("failed to fetch") || text.includes("networkerror") || text.includes("network request failed") || text.includes("load failed") || // Safari's wording for the same condition
+    text.includes("upstream connect error or disconnect/reset before headers");
+  }
+  return false;
+}
+function toNetError(err) {
+  if (isNetError(err)) return err;
+  if (err instanceof DOMException && err.name === "AbortError") {
+    return new AbortedError(err);
+  }
+  if (err instanceof TypeError) {
+    return new NetworkError(err.message || "Network request failed", err);
+  }
+  return new NetError(
+    "unknown",
+    extractErrorMessage(err),
+    { cause: err }
+  );
+}
+
+// src/net/resilient-fetch.ts
+var DEFAULTS = {
+  connectTimeoutMs: 15e3,
+  totalTimeoutMs: 12e4
+};
+function linkAbort(target, signal) {
+  if (signal.aborted) {
+    target.abort(signal.reason);
+    return () => {
+    };
+  }
+  const onAbort = () => target.abort(signal.reason);
+  signal.addEventListener("abort", onAbort, { once: true });
+  return () => signal.removeEventListener("abort", onAbort);
+}
+async function resilientFetch(url, init = {}, opts = {}) {
+  const connectTimeoutMs = opts.connectTimeoutMs ?? DEFAULTS.connectTimeoutMs;
+  const totalTimeoutMs = opts.totalTimeoutMs === void 0 ? DEFAULTS.totalTimeoutMs : opts.totalTimeoutMs;
+  const throwOnHttpError = opts.throwOnHttpError ?? true;
+  const controller = new AbortController();
+  const unlinkCaller = opts.signal ? linkAbort(controller, opts.signal) : () => {
+  };
+  let connectTimedOut = false;
+  let totalTimedOut = false;
+  const connectTimer = setTimeout(() => {
+    connectTimedOut = true;
+    controller.abort("connect-timeout");
+  }, connectTimeoutMs);
+  const totalTimer = totalTimeoutMs !== null ? setTimeout(() => {
+    totalTimedOut = true;
+    controller.abort("total-timeout");
+  }, totalTimeoutMs) : null;
+  try {
+    const response = await fetch(url, { ...init, signal: controller.signal });
+    clearTimeout(connectTimer);
+    if (totalTimer !== null) clearTimeout(totalTimer);
+    if (throwOnHttpError && !response.ok) {
+      throw new HttpError(
+        response.status,
+        `HTTP ${response.status} ${response.statusText}`
+      );
+    }
+    return { response, controller };
+  } catch (err) {
+    clearTimeout(connectTimer);
+    if (totalTimer !== null) clearTimeout(totalTimer);
+    if (connectTimedOut) throw new ConnectTimeoutError(connectTimeoutMs, err);
+    if (totalTimedOut)
+      throw new TotalTimeoutError(totalTimeoutMs, err);
+    if (err instanceof DOMException && err.name === "AbortError") {
+      throw new AbortedError(err);
+    }
+    if (opts.signal?.aborted) {
+      throw new AbortedError(err);
+    }
+    if (err instanceof TypeError) {
+      if (typeof navigator !== "undefined" && navigator.onLine === false) {
+        throw new OfflineError();
+      }
+      throw new NetworkError(err.message || "Network request failed", err);
+    }
+    if (err instanceof HttpError) throw err;
+    throw new NetworkError(extractErrorMessage(err), err);
+  } finally {
+    unlinkCaller();
+  }
+}
+
+// src/net/retry.ts
+function defaultRetryOn(err) {
+  return isNetError(err) && err.retryable;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      resolve();
+      if (signal) signal.removeEventListener("abort", onAbort);
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason ?? new Error("Aborted"));
+    };
+    if (signal) {
+      if (signal.aborted) {
+        clearTimeout(timer);
+        reject(signal.reason);
+      } else {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+    }
+  });
+}
+async function withRetry(fn, opts = {}) {
+  const attempts = Math.max(1, opts.attempts ?? 3);
+  const initialDelayMs = opts.initialDelayMs ?? 250;
+  const maxDelayMs = opts.maxDelayMs ?? 4e3;
+  const factor = opts.backoffFactor ?? 2;
+  const jitter = Math.max(0, Math.min(1, opts.jitter ?? 0.25));
+  const retryOn = opts.retryOn ?? defaultRetryOn;
+  let lastErr;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    if (opts.signal?.aborted) throw opts.signal.reason;
+    try {
+      return await fn(attempt);
+    } catch (err) {
+      lastErr = err;
+      if (attempt === attempts || !retryOn(err)) throw err;
+      const base = Math.min(
+        maxDelayMs,
+        initialDelayMs * Math.pow(factor, attempt - 1)
+      );
+      const jitterAmount = base * jitter * (Math.random() * 2 - 1);
+      const delayMs = Math.max(0, Math.round(base + jitterAmount));
+      opts.onRetry?.(attempt, err, delayMs);
+      await sleep(delayMs, opts.signal);
+    }
+  }
+  throw lastErr;
+}
+
+exports.AbortedError = AbortedError;
+exports.ConnectTimeoutError = ConnectTimeoutError;
+exports.HeartbeatTimeoutError = HeartbeatTimeoutError;
+exports.HttpError = HttpError;
+exports.NetError = NetError;
+exports.NetworkError = NetworkError;
+exports.OfflineError = OfflineError;
+exports.TotalTimeoutError = TotalTimeoutError;
+exports.extractErrorMessage = extractErrorMessage;
+exports.isNetError = isNetError;
+exports.isTransportFailure = isTransportFailure;
+exports.resilientFetch = resilientFetch;
+exports.toNetError = toNetError;
+exports.withRetry = withRetry;

package/dist/chunk-AY5N6EA4.js

@@ -0,0 +1,43 @@
+// src/credentials.ts
+var MATRX_HEADERS = {
+  authorization: "Authorization",
+  fingerprint: "X-Fingerprint-ID",
+  organization: "X-Organization-Id",
+  actingUser: "X-Matrx-User-Id",
+  requestId: "X-Request-Id"
+};
+var API_KEY_PREFIX = "mx_";
+function credentialToHeaders(credential) {
+  if (credential === null) return {};
+  switch (credential.kind) {
+    case "user":
+      return { [MATRX_HEADERS.authorization]: `Bearer ${credential.accessToken}` };
+    case "guest":
+      return { [MATRX_HEADERS.fingerprint]: credential.fingerprintId };
+    case "scoped":
+      return { [MATRX_HEADERS.authorization]: `Bearer ${credential.token}` };
+    case "service": {
+      const header = credential.secretHeader ?? MATRX_HEADERS.authorization;
+      const headers = header.toLowerCase() === "authorization" ? { [MATRX_HEADERS.authorization]: `Bearer ${credential.secret}` } : { [header]: credential.secret };
+      if (credential.actingUserId) headers[MATRX_HEADERS.actingUser] = credential.actingUserId;
+      return headers;
+    }
+    case "api_key": {
+      if (!credential.apiKey.startsWith(API_KEY_PREFIX)) {
+        throw new Error(
+          `credentialToHeaders: an api_key credential must start with "${API_KEY_PREFIX}" (AI Matrx API keys look like mx_live_...)`
+        );
+      }
+      return { [MATRX_HEADERS.authorization]: `Bearer ${credential.apiKey}` };
+    }
+  }
+}
+function toCredentialsPort(setting) {
+  if (setting === void 0 || setting === null) return { get: async () => null };
+  if (typeof setting === "function") return { get: async () => setting() };
+  if ("get" in setting && typeof setting.get === "function") return setting;
+  const fixed = setting;
+  return { get: async () => fixed };
+}
+
+export { API_KEY_PREFIX, MATRX_HEADERS, credentialToHeaders, toCredentialsPort };

package/dist/chunk-BMQI7UET.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+// src/credentials.ts
+var MATRX_HEADERS = {
+  authorization: "Authorization",
+  fingerprint: "X-Fingerprint-ID",
+  organization: "X-Organization-Id",
+  actingUser: "X-Matrx-User-Id",
+  requestId: "X-Request-Id"
+};
+var API_KEY_PREFIX = "mx_";
+function credentialToHeaders(credential) {
+  if (credential === null) return {};
+  switch (credential.kind) {
+    case "user":
+      return { [MATRX_HEADERS.authorization]: `Bearer ${credential.accessToken}` };
+    case "guest":
+      return { [MATRX_HEADERS.fingerprint]: credential.fingerprintId };
+    case "scoped":
+      return { [MATRX_HEADERS.authorization]: `Bearer ${credential.token}` };
+    case "service": {
+      const header = credential.secretHeader ?? MATRX_HEADERS.authorization;
+      const headers = header.toLowerCase() === "authorization" ? { [MATRX_HEADERS.authorization]: `Bearer ${credential.secret}` } : { [header]: credential.secret };
+      if (credential.actingUserId) headers[MATRX_HEADERS.actingUser] = credential.actingUserId;
+      return headers;
+    }
+    case "api_key": {
+      if (!credential.apiKey.startsWith(API_KEY_PREFIX)) {
+        throw new Error(
+          `credentialToHeaders: an api_key credential must start with "${API_KEY_PREFIX}" (AI Matrx API keys look like mx_live_...)`
+        );
+      }
+      return { [MATRX_HEADERS.authorization]: `Bearer ${credential.apiKey}` };
+    }
+  }
+}
+function toCredentialsPort(setting) {
+  if (setting === void 0 || setting === null) return { get: async () => null };
+  if (typeof setting === "function") return { get: async () => setting() };
+  if ("get" in setting && typeof setting.get === "function") return setting;
+  const fixed = setting;
+  return { get: async () => fixed };
+}
+
+exports.API_KEY_PREFIX = API_KEY_PREFIX;
+exports.MATRX_HEADERS = MATRX_HEADERS;
+exports.credentialToHeaders = credentialToHeaders;
+exports.toCredentialsPort = toCredentialsPort;

package/dist/chunk-FNIYADWI.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+var chunk2SXAAKGV_cjs = require('./chunk-2SXAAKGV.cjs');
+
+// src/net/stream-monitor.ts
+var DEFAULTS = {
+  heartbeatTimeoutMs: 3e4,
+  maxLifetimeMs: 6e5
+};
+async function* monitorStream(source, opts = {}) {
+  const heartbeatTimeoutMs = opts.heartbeatTimeoutMs ?? DEFAULTS.heartbeatTimeoutMs;
+  const maxLifetimeMs = opts.maxLifetimeMs ?? DEFAULTS.maxLifetimeMs;
+  const abort = opts.abortController;
+  const startedAt = Date.now();
+  const iter = source[Symbol.asyncIterator]();
+  while (true) {
+    const elapsed = Date.now() - startedAt;
+    const remainingLifetime = maxLifetimeMs - elapsed;
+    if (remainingLifetime <= 0) {
+      abort?.abort("total-timeout");
+      throw new chunk2SXAAKGV_cjs.TotalTimeoutError(maxLifetimeMs);
+    }
+    const deadline = Math.min(heartbeatTimeoutMs, remainingLifetime);
+    let timer = null;
+    let timedOutKind = null;
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        timedOutKind = deadline === remainingLifetime ? "total" : "heartbeat";
+        abort?.abort(
+          timedOutKind === "total" ? "total-timeout" : "heartbeat-timeout"
+        );
+        reject(
+          timedOutKind === "total" ? new chunk2SXAAKGV_cjs.TotalTimeoutError(maxLifetimeMs) : new chunk2SXAAKGV_cjs.HeartbeatTimeoutError(heartbeatTimeoutMs)
+        );
+      }, deadline);
+    });
+    let result;
+    try {
+      result = await Promise.race([iter.next(), timeoutPromise]);
+    } catch (err) {
+      if (timer !== null) clearTimeout(timer);
+      try {
+        const cleanup = iter.return?.(void 0);
+        if (cleanup) {
+          void Promise.resolve(cleanup).catch(() => {
+          });
+        }
+      } catch {
+      }
+      throw err;
+    }
+    if (timer !== null) clearTimeout(timer);
+    if (result.done) return;
+    opts.onHeartbeat?.(Date.now());
+    yield result.value;
+  }
+}
+
+exports.monitorStream = monitorStream;

package/dist/chunk-KIEAFMKB.js

@@ -0,0 +1,264 @@
+// src/net/errors.ts
+var NetError = class extends Error {
+  code;
+  cause;
+  status;
+  retryable;
+  constructor(code, message, opts = {}) {
+    super(message);
+    this.name = "NetError";
+    this.code = code;
+    this.cause = opts.cause;
+    if (opts.status !== void 0) this.status = opts.status;
+    this.retryable = opts.retryable ?? false;
+  }
+};
+var ConnectTimeoutError = class extends NetError {
+  constructor(ms, cause) {
+    super("connect-timeout", `Connection timed out after ${ms}ms`, {
+      cause,
+      retryable: true
+    });
+    this.name = "ConnectTimeoutError";
+  }
+};
+var TotalTimeoutError = class extends NetError {
+  constructor(ms, cause) {
+    super("total-timeout", `Request exceeded ${ms}ms total budget`, {
+      cause,
+      retryable: false
+    });
+    this.name = "TotalTimeoutError";
+  }
+};
+var HeartbeatTimeoutError = class extends NetError {
+  constructor(ms, cause) {
+    super(
+      "heartbeat-timeout",
+      `No server activity for ${ms}ms \u2014 stream considered dead`,
+      { cause, retryable: false }
+    );
+    this.name = "HeartbeatTimeoutError";
+  }
+};
+var NetworkError = class extends NetError {
+  constructor(message, cause) {
+    super("network", message, { cause, retryable: true });
+    this.name = "NetworkError";
+  }
+};
+var HttpError = class extends NetError {
+  constructor(status, message, cause) {
+    const retryable = status === 408 || status === 429 || status >= 500;
+    super("http", message, { cause, status, retryable });
+    this.name = "HttpError";
+  }
+};
+var AbortedError = class extends NetError {
+  constructor(cause) {
+    super("aborted", "Request was aborted", { cause, retryable: false });
+    this.name = "AbortedError";
+  }
+};
+var OfflineError = class extends NetError {
+  constructor() {
+    super("offline", "Browser is offline", { retryable: true });
+    this.name = "OfflineError";
+  }
+};
+function isNetError(err) {
+  return err instanceof NetError;
+}
+function extractErrorMessage(err, fallback = "An unexpected error occurred") {
+  if (!err) return "Unknown error";
+  if (typeof err === "string") return err;
+  if (err instanceof Error) return err.message;
+  if (typeof err === "object") {
+    const e = err;
+    const parts = [];
+    if (typeof e.message === "string" && e.message) parts.push(e.message);
+    if (parts.length === 0) {
+      if (typeof e.detail === "string" && e.detail) parts.push(e.detail);
+      else if (e.detail && typeof e.detail === "object") {
+        const d = e.detail;
+        if (typeof d.message === "string" && d.message) parts.push(d.message);
+      }
+    }
+    if (typeof e.details === "string" && e.details) parts.push(e.details);
+    if (typeof e.hint === "string" && e.hint) parts.push(`Hint: ${e.hint}`);
+    if (typeof e.code === "string" && e.code) parts.push(`Code: ${e.code}`);
+    if (parts.length > 0) return parts.join(" \xB7 ");
+    const nested = extractNestedErrorMessage(e, 0);
+    if (nested !== null) return nested;
+    try {
+      const s = JSON.stringify(err);
+      if (s && s !== "{}") return s;
+    } catch {
+    }
+  }
+  return fallback;
+}
+function extractNestedErrorMessage(e, depth) {
+  if (depth > 4) return null;
+  for (const key of ["error", "exception", "cause"]) {
+    const value = e[key];
+    if (typeof value === "string" && value) return value;
+    if (value && typeof value === "object") {
+      const inner = value;
+      if (typeof inner.message === "string" && inner.message) return inner.message;
+      if (typeof inner.detail === "string" && inner.detail) return inner.detail;
+      const deeper = extractNestedErrorMessage(inner, depth + 1);
+      if (deeper !== null) return deeper;
+    }
+  }
+  return null;
+}
+function isTransportFailure(err) {
+  if (err instanceof NetworkError || err instanceof OfflineError) return true;
+  if (typeof navigator !== "undefined" && navigator.onLine === false) return true;
+  if (err instanceof TypeError) return true;
+  if (err && typeof err === "object") {
+    const e = err;
+    if (e.code || e.status) return false;
+    const text = `${typeof e.name === "string" ? e.name : ""} ${typeof e.message === "string" ? e.message : ""}`.toLowerCase();
+    return text.includes("failed to fetch") || text.includes("networkerror") || text.includes("network request failed") || text.includes("load failed") || // Safari's wording for the same condition
+    text.includes("upstream connect error or disconnect/reset before headers");
+  }
+  return false;
+}
+function toNetError(err) {
+  if (isNetError(err)) return err;
+  if (err instanceof DOMException && err.name === "AbortError") {
+    return new AbortedError(err);
+  }
+  if (err instanceof TypeError) {
+    return new NetworkError(err.message || "Network request failed", err);
+  }
+  return new NetError(
+    "unknown",
+    extractErrorMessage(err),
+    { cause: err }
+  );
+}
+
+// src/net/resilient-fetch.ts
+var DEFAULTS = {
+  connectTimeoutMs: 15e3,
+  totalTimeoutMs: 12e4
+};
+function linkAbort(target, signal) {
+  if (signal.aborted) {
+    target.abort(signal.reason);
+    return () => {
+    };
+  }
+  const onAbort = () => target.abort(signal.reason);
+  signal.addEventListener("abort", onAbort, { once: true });
+  return () => signal.removeEventListener("abort", onAbort);
+}
+async function resilientFetch(url, init = {}, opts = {}) {
+  const connectTimeoutMs = opts.connectTimeoutMs ?? DEFAULTS.connectTimeoutMs;
+  const totalTimeoutMs = opts.totalTimeoutMs === void 0 ? DEFAULTS.totalTimeoutMs : opts.totalTimeoutMs;
+  const throwOnHttpError = opts.throwOnHttpError ?? true;
+  const controller = new AbortController();
+  const unlinkCaller = opts.signal ? linkAbort(controller, opts.signal) : () => {
+  };
+  let connectTimedOut = false;
+  let totalTimedOut = false;
+  const connectTimer = setTimeout(() => {
+    connectTimedOut = true;
+    controller.abort("connect-timeout");
+  }, connectTimeoutMs);
+  const totalTimer = totalTimeoutMs !== null ? setTimeout(() => {
+    totalTimedOut = true;
+    controller.abort("total-timeout");
+  }, totalTimeoutMs) : null;
+  try {
+    const response = await fetch(url, { ...init, signal: controller.signal });
+    clearTimeout(connectTimer);
+    if (totalTimer !== null) clearTimeout(totalTimer);
+    if (throwOnHttpError && !response.ok) {
+      throw new HttpError(
+        response.status,
+        `HTTP ${response.status} ${response.statusText}`
+      );
+    }
+    return { response, controller };
+  } catch (err) {
+    clearTimeout(connectTimer);
+    if (totalTimer !== null) clearTimeout(totalTimer);
+    if (connectTimedOut) throw new ConnectTimeoutError(connectTimeoutMs, err);
+    if (totalTimedOut)
+      throw new TotalTimeoutError(totalTimeoutMs, err);
+    if (err instanceof DOMException && err.name === "AbortError") {
+      throw new AbortedError(err);
+    }
+    if (opts.signal?.aborted) {
+      throw new AbortedError(err);
+    }
+    if (err instanceof TypeError) {
+      if (typeof navigator !== "undefined" && navigator.onLine === false) {
+        throw new OfflineError();
+      }
+      throw new NetworkError(err.message || "Network request failed", err);
+    }
+    if (err instanceof HttpError) throw err;
+    throw new NetworkError(extractErrorMessage(err), err);
+  } finally {
+    unlinkCaller();
+  }
+}
+
+// src/net/retry.ts
+function defaultRetryOn(err) {
+  return isNetError(err) && err.retryable;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      resolve();
+      if (signal) signal.removeEventListener("abort", onAbort);
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason ?? new Error("Aborted"));
+    };
+    if (signal) {
+      if (signal.aborted) {
+        clearTimeout(timer);
+        reject(signal.reason);
+      } else {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+    }
+  });
+}
+async function withRetry(fn, opts = {}) {
+  const attempts = Math.max(1, opts.attempts ?? 3);
+  const initialDelayMs = opts.initialDelayMs ?? 250;
+  const maxDelayMs = opts.maxDelayMs ?? 4e3;
+  const factor = opts.backoffFactor ?? 2;
+  const jitter = Math.max(0, Math.min(1, opts.jitter ?? 0.25));
+  const retryOn = opts.retryOn ?? defaultRetryOn;
+  let lastErr;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    if (opts.signal?.aborted) throw opts.signal.reason;
+    try {
+      return await fn(attempt);
+    } catch (err) {
+      lastErr = err;
+      if (attempt === attempts || !retryOn(err)) throw err;
+      const base = Math.min(
+        maxDelayMs,
+        initialDelayMs * Math.pow(factor, attempt - 1)
+      );
+      const jitterAmount = base * jitter * (Math.random() * 2 - 1);
+      const delayMs = Math.max(0, Math.round(base + jitterAmount));
+      opts.onRetry?.(attempt, err, delayMs);
+      await sleep(delayMs, opts.signal);
+    }
+  }
+  throw lastErr;
+}
+
+export { AbortedError, ConnectTimeoutError, HeartbeatTimeoutError, HttpError, NetError, NetworkError, OfflineError, TotalTimeoutError, extractErrorMessage, isNetError, isTransportFailure, resilientFetch, toNetError, withRetry };