@zeroxyz/sdk 0.1.0

package/dist/chunk-XQEHJX2X.js

@@ -0,0 +1,3017 @@
+import { serializeTransaction, parseSignature, formatUnits, isAddress, getAddress, parseUnits, createWalletClient, http, createPublicClient, bytesToHex } from 'viem';
+import { toAccount, privateKeyToAccount, mnemonicToAccount } from 'viem/accounts';
+import { getClient, adaptViemWallet, createClient, convertViemChainToRelayChain, MAINNET_RELAY_API } from '@relayprotocol/relay-sdk';
+import { x402Client } from '@x402/core/client';
+import { x402HTTPClient, decodePaymentResponseHeader, encodePaymentRequiredHeader } from '@x402/core/http';
+import { registerExactEvmScheme } from '@x402/evm/exact/client';
+import { createSIWxClientHook } from '@x402/extensions/sign-in-with-x';
+import { wrapFetchWithPayment } from '@x402/fetch';
+import { Receipt, Challenge } from 'mppx';
+import { Mppx, tempo } from 'mppx/client';
+import { base, baseSepolia } from 'viem/chains';
+import { z } from 'zod';
+import { createHash } from 'crypto';
+
+// src/auth/managed-account.ts
+var createManagedAccount = (client, address) => toAccount({
+  address,
+  async signMessage({ message }) {
+    return await client.auth.signMessage(
+      { message },
+      { expectedAddress: address }
+    );
+  },
+  async signTypedData(typedData) {
+    const td = typedData;
+    return await client.auth.signTypedData(
+      {
+        domain: td.domain,
+        types: td.types,
+        primaryType: td.primaryType,
+        message: td.message
+      },
+      { expectedAddress: address }
+    );
+  },
+  async signTransaction(transaction, options) {
+    const serialize = options?.serializer ?? serializeTransaction;
+    const unsigned = await serialize(transaction);
+    const signature = await client.auth.signTransaction(
+      { unsignedTransaction: unsigned },
+      { expectedAddress: address }
+    );
+    return await serialize(transaction, parseSignature(signature));
+  }
+});
+
+// src/errors.ts
+var ZeroError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options?.cause ? { cause: options.cause } : void 0);
+    this.name = "ZeroError";
+    this.code = code;
+  }
+};
+var ZeroApiError = class extends ZeroError {
+  status;
+  requestId;
+  body;
+  constructor(message, init) {
+    super("api_error", message, { cause: init.cause });
+    this.name = "ZeroApiError";
+    this.status = init.status;
+    this.requestId = init.requestId;
+    this.body = init.body;
+  }
+};
+var ZeroAuthError = class extends ZeroError {
+  constructor(code, message, options) {
+    super(code, message, options);
+    this.name = "ZeroAuthError";
+  }
+};
+var ZeroPaymentError = class extends ZeroError {
+  constructor(message, options) {
+    super("payment_error", message, options);
+    this.name = "ZeroPaymentError";
+  }
+};
+var ZeroSessionCloseFailedError = class extends ZeroError {
+  session;
+  response;
+  capturedAmount;
+  constructor(message, init) {
+    super("payment_session_close_failed", message, { cause: init.cause });
+    this.name = "ZeroSessionCloseFailedError";
+    this.session = init.session;
+    this.response = init.response;
+    this.capturedAmount = init.capturedAmount;
+  }
+};
+var ZeroWalletError = class extends ZeroError {
+  constructor(message, options) {
+    super("wallet_error", message, options);
+    this.name = "ZeroWalletError";
+  }
+};
+var ZeroValidationError = class extends ZeroError {
+  body;
+  constructor(message, options) {
+    super("validation_error", message, options);
+    this.name = "ZeroValidationError";
+    this.body = options?.body;
+  }
+};
+var ZeroTimeoutError = class extends ZeroError {
+  constructor(message, options) {
+    super("timeout_error", message, options);
+    this.name = "ZeroTimeoutError";
+  }
+};
+var ZeroConfigurationError = class extends ZeroError {
+  constructor(message, options) {
+    super("configuration_error", message, options);
+    this.name = "ZeroConfigurationError";
+  }
+};
+
+// src/chains/eip712.ts
+var KNOWN_EIP712_DOMAINS = {
+  // Base mainnet USDC. On-chain `name()` is "USD Coin" (NOT "USDC")
+  // — verified via the contract's name() / version().
+  "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913": {
+    name: "USD Coin",
+    version: "2"
+  },
+  // Base Sepolia USDC. Testnet's on-chain `name()` is "USDC",
+  // differs from mainnet's "USD Coin".
+  "0x036cbd53842c5426634e7929541ec2318f3dcf7e": {
+    name: "USDC",
+    version: "2"
+  }
+};
+var trimmedOrUndefined = (v) => {
+  if (typeof v !== "string") return void 0;
+  const t = v.trim();
+  return t.length > 0 ? t : void 0;
+};
+var trimStringFields = (extra) => {
+  if (!extra) return extra;
+  const out = {};
+  for (const [k, v] of Object.entries(extra)) {
+    out[k] = typeof v === "string" ? v.trim() : v;
+  }
+  return out;
+};
+var withKnownEip712Domain = (asset, extra) => {
+  const trimmedExtra = trimStringFields(extra);
+  const known = KNOWN_EIP712_DOMAINS[(asset ?? "").toLowerCase()];
+  if (!known) return trimmedExtra;
+  return {
+    ...trimmedExtra,
+    name: trimmedOrUndefined(trimmedExtra?.name) ?? known.name,
+    version: trimmedOrUndefined(trimmedExtra?.version) ?? known.version
+  };
+};
+
+// src/transport/configured-fetch.ts
+var ABORT_SIGNAL_ANY_AVAILABLE = typeof AbortSignal !== "undefined" && typeof AbortSignal.any === "function";
+var headersToRecord = (h) => {
+  const result = {};
+  h.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+};
+var isSameOriginAsBase = (urlString, baseUrl) => {
+  try {
+    return new URL(urlString).origin === new URL(baseUrl).origin;
+  } catch {
+    return false;
+  }
+};
+var dedupeHeadersInit = (init) => {
+  const out = new Headers();
+  if (init instanceof Headers) {
+    init.forEach((value, key) => {
+      out.set(key, value);
+    });
+    return out;
+  }
+  const entries = Array.isArray(init) ? init : Object.entries(init);
+  for (const [key, value] of entries) {
+    out.set(key, value);
+  }
+  return out;
+};
+var buildConfiguredFetch = (client, overrides) => {
+  const timeoutMs = overrides?.timeoutMs ?? client.timeout;
+  const impl = async (input, init) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const isRequestInput = typeof Request !== "undefined" && input instanceof Request;
+    const callerSignals = [];
+    if (init?.signal) callerSignals.push(init.signal);
+    if (isRequestInput && input.signal) callerSignals.push(input.signal);
+    const fetchOptionsSignal = client.fetchOptions?.signal;
+    if (fetchOptionsSignal) callerSignals.push(fetchOptionsSignal);
+    if (callerSignals.length > 0 && !ABORT_SIGNAL_ANY_AVAILABLE) {
+      clearTimeout(timer);
+      throw new ZeroConfigurationError(
+        "AbortSignal.any is required for signal handling and is not available in this runtime. The SDK requires Node 20.3+. Check `process.version` (or your bundler's target)."
+      );
+    }
+    const combinedSignal = callerSignals.length > 0 ? AbortSignal.any([controller.signal, ...callerSignals]) : controller.signal;
+    let abortedByCaller = false;
+    const onCallerAbort = () => {
+      abortedByCaller = true;
+    };
+    for (const sig of callerSignals) {
+      if (sig.aborted) {
+        abortedByCaller = true;
+        break;
+      }
+      sig.addEventListener("abort", onCallerAbort, { once: true });
+    }
+    try {
+      let response;
+      if (isRequestInput) {
+        const injectDefaults = isSameOriginAsBase(input.url, client.baseUrl);
+        const merged = new Headers(injectDefaults ? client.defaultHeaders : {});
+        if (init?.headers) {
+          dedupeHeadersInit(init.headers).forEach((value, key) => {
+            merged.set(key, value);
+          });
+        }
+        input.headers.forEach((value, key) => {
+          merged.set(key, value);
+        });
+        const source = input.body !== null ? input.clone() : input;
+        const rebuilt = new Request(source, {
+          headers: headersToRecord(merged)
+        });
+        const { headers: _initHeaders, ...initRest } = init ?? {};
+        response = await client.fetchImpl(rebuilt, {
+          ...client.fetchOptions,
+          ...initRest,
+          signal: combinedSignal
+        });
+      } else {
+        let mergedHeaders;
+        const urlString = typeof input === "string" ? input : String(input);
+        const injectDefaults = isSameOriginAsBase(urlString, client.baseUrl);
+        const defaults = injectDefaults ? client.defaultHeaders : {};
+        const hasDefaults = injectDefaults && Object.keys(defaults).length > 0;
+        if (hasDefaults || init?.headers) {
+          const merged = new Headers(defaults);
+          if (init?.headers) {
+            dedupeHeadersInit(init.headers).forEach((value, key) => {
+              merged.set(key, value);
+            });
+          }
+          mergedHeaders = headersToRecord(merged);
+        }
+        response = await client.fetchImpl(input, {
+          ...client.fetchOptions,
+          ...init,
+          headers: mergedHeaders,
+          signal: combinedSignal
+        });
+      }
+      return response;
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        if (abortedByCaller) {
+          throw new ZeroApiError("Request aborted by caller", {
+            status: 0,
+            cause: err
+          });
+        }
+        throw new ZeroTimeoutError(`Request timed out after ${timeoutMs}ms`, {
+          cause: err
+        });
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+      for (const sig of callerSignals) {
+        sig.removeEventListener("abort", onCallerAbort);
+      }
+    }
+  };
+  return impl;
+};
+var looksLikeX402Body = (body) => {
+  if (!body || typeof body !== "object") return false;
+  const b = body;
+  return typeof b.x402Version === "number" && Array.isArray(b.accepts) && b.accepts.length > 0;
+};
+var isV1ShapedAccept = (accept) => {
+  if (!accept || typeof accept !== "object") return false;
+  const a = accept;
+  const network = typeof a.network === "string" ? a.network : "";
+  const bareNetwork = network !== "" && !network.includes(":");
+  const v1AmountField = a.maxAmountRequired != null && a.amount == null;
+  return bareNetwork || v1AmountField;
+};
+var coerceX402BodyVersion = (challenge) => {
+  const accepts = Array.isArray(challenge.accepts) ? challenge.accepts : [];
+  return { ...challenge, x402Version: accepts.some(isV1ShapedAccept) ? 1 : 2 };
+};
+var withSynthesizedX402Header = (baseFetch) => async (input, init) => {
+  const response = await baseFetch(input, init);
+  if (response.status !== 402) return response;
+  if (response.headers.get("payment-required") ?? response.headers.get("x-payment-required")) {
+    return response;
+  }
+  const text = await response.clone().text();
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return response;
+  }
+  if (!looksLikeX402Body(parsed) || parsed.x402Version === 1) {
+    return response;
+  }
+  const challenge = coerceX402BodyVersion(parsed);
+  const headers = new Headers(response.headers);
+  headers.set(
+    "PAYMENT-REQUIRED",
+    // Validated as an x402 body above; encoder wants the concrete type.
+    encodePaymentRequiredHeader(
+      challenge
+    )
+  );
+  headers.delete("content-length");
+  headers.delete("content-encoding");
+  return new Response(text, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+};
+
+// src/namespaces/payments.ts
+var NETWORK_TO_CHAIN = {
+  base: "base",
+  "base-sepolia": "base-sepolia",
+  "eip155:8453": "base",
+  "eip155:84532": "base-sepolia"
+};
+var networkToChain = (network) => {
+  if (!network) return "unknown";
+  const normalized = network.toLowerCase();
+  return NETWORK_TO_CHAIN[normalized] ?? "unknown";
+};
+var MAX_PAY_RE = /^[0-9]+(\.[0-9]{1,6})?$/;
+var UINT_RE = /^[0-9]+$/;
+var MAX_AMOUNT_DIGITS = 30;
+var USDC_BASE = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+var USDC_TEMPO = "0x20c000000000000000000000b9537d11c60e8b50";
+var PATHUSD_TEMPO = "0x20c0000000000000000000000000000000000000";
+var BASE_CHAIN_ID = 8453;
+var TEMPO_CHAIN_ID = 4217;
+var TEMPO_TESTNET_CHAIN_ID = 42431;
+var DEFAULT_PREFUND = "1";
+var tempoChain = {
+  id: TEMPO_CHAIN_ID,
+  name: "Tempo",
+  nativeCurrency: { name: "USD", symbol: "USD", decimals: 18 },
+  rpcUrls: { default: { http: ["https://rpc.tempo.xyz"] } }
+};
+var tempoTestnetChain = {
+  id: TEMPO_TESTNET_CHAIN_ID,
+  name: "Tempo Testnet",
+  nativeCurrency: { name: "USD", symbol: "USD", decimals: 18 },
+  rpcUrls: { default: { http: ["https://rpc.moderato.tempo.xyz"] } }
+};
+var ERC20_BALANCE_ABI = [
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var calculateBuffer = (baseBalance) => {
+  const twentyFivePercent = baseBalance / 4n;
+  const twoDollars = 2000000n;
+  return twentyFivePercent < twoDollars ? twentyFivePercent : twoDollars;
+};
+var ADAPTIVE_PREFUND_MULTIPLIER = 10;
+var ADAPTIVE_PREFUND_CEILING = "100";
+var resolveDefaultPrefund = (displayCostAmount) => {
+  const floor = Number.parseFloat(DEFAULT_PREFUND);
+  const ceiling = Number.parseFloat(ADAPTIVE_PREFUND_CEILING);
+  if (!displayCostAmount) return DEFAULT_PREFUND;
+  const cost = Number.parseFloat(displayCostAmount);
+  if (!Number.isFinite(cost) || cost <= 0) return DEFAULT_PREFUND;
+  const scaled = cost * ADAPTIVE_PREFUND_MULTIPLIER;
+  const bounded = scaled < floor ? floor : scaled > ceiling ? ceiling : scaled;
+  return bounded.toFixed(6).replace(/\.?0+$/, "");
+};
+var isUintString = (v) => typeof v === "string" && v.length > 0 && v.length <= MAX_AMOUNT_DIGITS && UINT_RE.test(v);
+var coerceTempoChainId = (raw) => {
+  const id = typeof raw === "number" && Number.isFinite(raw) ? raw : typeof raw === "string" && /^-?[0-9]+$/.test(raw) ? Number(raw) : null;
+  if (id === TEMPO_CHAIN_ID) return { id, chain: "tempo" };
+  if (id === TEMPO_TESTNET_CHAIN_ID) return { id, chain: "tempo-testnet" };
+  return null;
+};
+var tempoChainLabelFromId = (chainId) => {
+  const ok = coerceTempoChainId(chainId);
+  return ok ? ok.chain : "unknown";
+};
+var paymentHasAnchor = (payment) => payment !== null && (payment.txHash !== null || payment.session !== void 0);
+var FETCH_WARNINGS = Object.freeze({
+  paidButStill402NotRecorded: "paid_but_still_402_not_recorded",
+  paymentSettlementUnconfirmed: "payment_settlement_unconfirmed",
+  paymentAmountUnknown: "payment_amount_unknown",
+  mppSessionCloseFailed: "mpp_session_close_failed",
+  // MPP session-intent challenge but onChannelUpdate never observed opened=true
+  // before mppx.fetch resolved — a session call may have been recorded as
+  // charge by accident. Surface for investigation.
+  sessionOpenUnobserved: "session_open_unobserved",
+  // Response body exceeded maxResponseBytes — bodyRaw / body / bodyEncoding
+  // reflect the clipped prefix; consumers that wrote the body to disk got
+  // a truncated file. Particularly bad for paid binary fetches.
+  bodyTruncated: "body_truncated"
+});
+var FETCH_SKIP_REASONS = Object.freeze({
+  bodyReadFailed: "body_read_failed",
+  mppSessionCloseFailedNotRecorded: "mpp_session_close_failed_not_recorded",
+  paidButStill402NotRecorded: FETCH_WARNINGS.paidButStill402NotRecorded,
+  paymentSettlementUnconfirmed: FETCH_WARNINGS.paymentSettlementUnconfirmed
+});
+var MAX_RECEIPT_HEADER_BYTES = 8 * 1024;
+var decodeSessionReceiptHeader = (header) => {
+  if (!header) return null;
+  if (header.length > MAX_RECEIPT_HEADER_BYTES) return null;
+  try {
+    const padLen = (4 - header.length % 4) % 4;
+    const padded = header.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat(padLen);
+    const json = Buffer.from(padded, "base64").toString("utf8");
+    const parsed = JSON.parse(json);
+    if (typeof parsed.channelId !== "string" || typeof parsed.challengeId !== "string" || !isUintString(parsed.acceptedCumulative) || !isUintString(parsed.spent)) {
+      return null;
+    }
+    const out = {
+      channelId: parsed.channelId,
+      challengeId: parsed.challengeId,
+      acceptedCumulative: parsed.acceptedCumulative,
+      spent: parsed.spent
+    };
+    if (typeof parsed.txHash === "string") out.txHash = parsed.txHash;
+    if (typeof parsed.metered === "boolean") out.metered = parsed.metered;
+    return out;
+  } catch {
+    return null;
+  }
+};
+var readSessionReceipt = (response) => decodeSessionReceiptHeader(
+  response.headers.get("Payment-Receipt") ?? response.headers.get("payment-receipt")
+);
+var pickSessionCloseAmount = (receipt, openTimeCumulative) => {
+  if (!receipt) return openTimeCumulative;
+  const accepted = BigInt(receipt.acceptedCumulative);
+  const spent = BigInt(receipt.spent);
+  const fromReceipt = accepted > spent ? accepted : spent;
+  if (receipt.metered === true) return fromReceipt;
+  return fromReceipt > openTimeCumulative ? fromReceipt : openTimeCumulative;
+};
+var raceWithSignal = (p, signal, client) => {
+  if (!signal) return p;
+  if (signal.aborted) {
+    p.catch((err) => {
+      client.logger?.({
+        level: "warn",
+        message: "Post-abort rejection from in-flight work (dropped to caller)",
+        meta: { error: err instanceof Error ? err.message : String(err) }
+      });
+    });
+    return Promise.reject(new DOMException("Aborted", "AbortError"));
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const onAbort = () => {
+      settled = true;
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    p.then(
+      (v) => {
+        signal.removeEventListener("abort", onAbort);
+        if (settled) return;
+        settled = true;
+        resolve(v);
+      },
+      (e) => {
+        signal.removeEventListener("abort", onAbort);
+        if (settled) {
+          client.logger?.({
+            level: "warn",
+            message: "Post-abort rejection from in-flight work (dropped to caller)",
+            meta: { error: e instanceof Error ? e.message : String(e) }
+          });
+          return;
+        }
+        settled = true;
+        reject(e);
+      }
+    );
+  });
+};
+var cancelBody = (response) => {
+  try {
+    response.body?.cancel().catch(() => {
+    });
+  } catch {
+  }
+};
+var resolveAccount = async (client, overrideAccount, signal) => {
+  if (overrideAccount) return overrideAccount;
+  const credentials = client.getCredentials();
+  if (credentials.kind === "account") return credentials.account;
+  if (credentials.kind === "session") {
+    return await client.resolveManagedAccount(signal);
+  }
+  throw new ZeroAuthError(
+    "auth_no_credentials",
+    "payments.pay() requires either a client constructed with `account` or a per-call `account` override."
+  );
+};
+var validateMaxPay = (maxPay) => {
+  const normalized = maxPay?.trim();
+  if (normalized === void 0) return null;
+  if (!MAX_PAY_RE.test(normalized)) {
+    throw new ZeroPaymentError(
+      `Invalid maxPay format: ${JSON.stringify(maxPay)}. Expected a decimal USDC string with up to 6 fractional digits, like "0.10". Scientific notation, currency suffixes, and >6-decimal precision are rejected.`
+    );
+  }
+  return parseUnits(normalized, 6);
+};
+var Payments = class {
+  constructor(client) {
+    this.client = client;
+  }
+  relayInitialized = false;
+  /**
+   * Settle an x402 payment for a single request.
+   *
+   * Routes through `@x402/fetch`, which handles the full 402 → sign →
+   * retry round-trip. The settlement transaction hash (when present in
+   * the `payment-response` header AND the facilitator reports success)
+   * is extracted into the returned `payment` metadata.
+   *
+   * Aborts before signing if the server's challenge amount exceeds
+   * `maxPay`. The cap is denominated in USDC (the asset of every Zero
+   * payment today); the API will gain a `maxPayAsset` field if other
+   * assets are added.
+   *
+   * MPP capabilities use `payMpp()` instead — `client.fetch` routes based
+   * on the detected 402 protocol.
+   */
+  pay = async (input) => {
+    const maxPayUnits = validateMaxPay(input.maxPay);
+    if (maxPayUnits === 0n) {
+      throw new ZeroPaymentError("maxPay='0' disallows any payment.");
+    }
+    const account = await resolveAccount(
+      this.client,
+      input.account,
+      input.signal
+    );
+    let capturedAmount = null;
+    let capturedNetwork;
+    const x402 = registerExactEvmScheme(new x402Client(), { signer: account });
+    x402.onBeforePaymentCreation(async (context) => {
+      const selected = context.selectedRequirements;
+      if (selected) {
+        const filled = withKnownEip712Domain(selected.asset, selected.extra);
+        if (filled) selected.extra = filled;
+      }
+      const requirement = selected ?? context.paymentRequired.accepts[0];
+      if (!requirement) {
+        return {
+          abort: true,
+          reason: "x402 challenge had no payment requirements"
+        };
+      }
+      capturedNetwork = requirement.network;
+      const rawAmount = requirement.amount ?? requirement.maxAmountRequired;
+      if (!rawAmount) {
+        return { abort: true, reason: "x402 requirement had no amount field" };
+      }
+      if (rawAmount.length > MAX_AMOUNT_DIGITS || !UINT_RE.test(rawAmount)) {
+        return {
+          abort: true,
+          reason: `x402 requirement amount is not an unsigned integer string: ${JSON.stringify(rawAmount)}`
+        };
+      }
+      const rawAmountUnits = BigInt(rawAmount);
+      capturedAmount = formatUnits(rawAmountUnits, 6);
+      if (maxPayUnits !== null && rawAmountUnits > maxPayUnits) {
+        return {
+          abort: true,
+          reason: `Payment of ${capturedAmount} USDC exceeds maxPay ${input.maxPay}`
+        };
+      }
+    });
+    const configuredFetch = buildConfiguredFetch(this.client, {
+      timeoutMs: input.timeoutMs
+    });
+    const httpClient = new x402HTTPClient(x402).onPaymentRequired(
+      createSIWxClientHook(account)
+    );
+    const wrappedFetch = wrapFetchWithPayment(
+      withSynthesizedX402Header(configuredFetch),
+      httpClient
+    );
+    let response;
+    try {
+      response = await wrappedFetch(input.url, {
+        method: input.method ?? "GET",
+        headers: input.headers,
+        body: input.body,
+        signal: input.signal
+      });
+    } catch (err) {
+      if (err instanceof ZeroError) throw err;
+      throw new ZeroPaymentError(
+        `x402 payment failed: ${err instanceof Error ? err.message : String(err)}`,
+        { cause: err }
+      );
+    }
+    let txHash = null;
+    const settlementHeader = response.headers.get("payment-response") ?? response.headers.get("x-payment-response");
+    if (settlementHeader) {
+      try {
+        const settlement = decodePaymentResponseHeader(settlementHeader);
+        if (settlement.success && typeof settlement.transaction === "string" && settlement.transaction.length > 0) {
+          txHash = settlement.transaction;
+        }
+        if (capturedNetwork === void 0 && typeof settlement.network === "string") {
+          capturedNetwork = settlement.network;
+        }
+      } catch {
+      }
+    }
+    const amount = capturedAmount ?? "unknown";
+    return {
+      response,
+      payment: {
+        protocol: "x402",
+        chain: networkToChain(capturedNetwork),
+        txHash,
+        amount,
+        asset: "USDC"
+      }
+    };
+  };
+  /**
+   * @internal — called by `client.fetch` after MPP protocol detection.
+   *
+   * Runs a single `mppx.fetch` against the Tempo payment-channel protocol.
+   * In-band balance/bridge logic runs from mppx's `onChallenge` callback so
+   * the lifecycle is a single HTTP round-trip from the SDK consumer's view
+   * (no pre-probe — session facilitators that re-run inference per request
+   * can't reconcile the extra state).
+   *
+   * Session-intent capabilities (long-lived channels) close their voucher
+   * after the seller's 200; close failures throw `ZeroSessionCloseFailedError`
+   * carrying the orphaned channel for out-of-band reconciliation.
+   */
+  payMpp = async (input) => {
+    const maxPayUnits = validateMaxPay(input.maxPay);
+    if (maxPayUnits === 0n) {
+      throw new ZeroPaymentError("maxPay='0' disallows any payment.");
+    }
+    const account = await resolveAccount(
+      this.client,
+      input.account,
+      input.signal
+    );
+    const configuredFetch = buildConfiguredFetch(this.client, {
+      timeoutMs: input.timeoutMs
+    });
+    let capturedAmount = "unknown";
+    let capturedChallenge;
+    let channelEntry;
+    let openTimeCumulative;
+    const mppx = Mppx.create({
+      polyfill: false,
+      fetch: configuredFetch,
+      methods: [
+        tempo({
+          account,
+          maxDeposit: input.maxPay ?? resolveDefaultPrefund(input.displayCostAmount),
+          onChannelUpdate: (entry) => {
+            let cumulative;
+            if (typeof entry.cumulativeAmount === "bigint") {
+              cumulative = entry.cumulativeAmount;
+            } else {
+              cumulative = 0n;
+              this.client.logger?.({
+                level: "warn",
+                message: "mppx emitted non-bigint cumulativeAmount; coerced to 0n",
+                meta: { actualType: typeof entry.cumulativeAmount }
+              });
+            }
+            if (openTimeCumulative === void 0 && entry.opened) {
+              openTimeCumulative = cumulative;
+            }
+            const wasOpened = channelEntry?.opened ?? false;
+            channelEntry = {
+              channelId: entry.channelId,
+              escrowContract: entry.escrowContract,
+              cumulativeAmount: cumulative,
+              opened: wasOpened || entry.opened
+            };
+          }
+        })
+      ],
+      onChallenge: async (challenge) => {
+        capturedChallenge = challenge;
+        capturedAmount = await this.prepareTempoFunds(
+          account,
+          challenge,
+          maxPayUnits,
+          input.displayCostAmount
+        );
+        return void 0;
+      }
+    });
+    let response;
+    try {
+      response = await mppx.fetch(input.url, {
+        method: input.method ?? "GET",
+        headers: input.headers,
+        body: input.body,
+        signal: input.signal
+      });
+    } catch (err) {
+      if (channelEntry?.opened) {
+        throw this.buildOrphanError(
+          channelEntry,
+          capturedChallenge,
+          capturedAmount,
+          new Response(null, { status: 502 }),
+          `MPP payment failed after channel open: ${err instanceof Error ? err.message : String(err)}`,
+          err
+        );
+      }
+      if (err instanceof ZeroError) throw err;
+      throw new ZeroPaymentError(
+        `MPP payment failed: ${err instanceof Error ? err.message : String(err)}`,
+        { cause: err }
+      );
+    }
+    if (capturedChallenge?.intent === "session" && channelEntry?.opened) {
+      return this.completeMppSession({
+        url: input.url,
+        method: input.method ?? "GET",
+        challenge: capturedChallenge,
+        channelEntry,
+        openTimeCumulative: openTimeCumulative ?? channelEntry.cumulativeAmount,
+        response,
+        capturedAmount,
+        mppx,
+        signal: input.signal,
+        configuredFetch
+      });
+    }
+    const sdkWarnings = [];
+    if (capturedChallenge?.intent === "session" && !channelEntry?.opened) {
+      this.client.logger?.({
+        level: "warn",
+        message: "MPP session challenge but onChannelUpdate never observed opened=true; recording as charge."
+      });
+      sdkWarnings.push(FETCH_WARNINGS.sessionOpenUnobserved);
+    }
+    let txHash = null;
+    try {
+      const receipt = Receipt.fromResponse(response);
+      txHash = receipt.reference ?? null;
+    } catch (err) {
+      this.client.logger?.({
+        level: "warn",
+        message: "Failed to parse MPP charge receipt; txHash unknown",
+        meta: { error: err instanceof Error ? err.message : String(err) }
+      });
+    }
+    return {
+      response,
+      ...sdkWarnings.length > 0 && { warnings: sdkWarnings },
+      payment: {
+        protocol: "mpp",
+        chain: this.tempoChainLabel(capturedChallenge),
+        txHash,
+        amount: capturedAmount,
+        asset: "USDC"
+      }
+    };
+  };
+  // Construct a ZeroSessionCloseFailedError carrying orphan metadata derived
+  // from the locally-known channelEntry. Used by post-open error paths so the
+  // caller can reconcile the funded channel even when the failure happened
+  // before completeMppSession had a chance to build its full session record.
+  buildOrphanError = (channelEntry, challenge, capturedAmount, response, message, cause) => {
+    const req = challenge?.request ?? {};
+    const methodDetails = req.methodDetails;
+    const rawChainId = req.chainId ?? methodDetails?.chainId;
+    const coercedChain = coerceTempoChainId(rawChainId);
+    const chainId = coercedChain?.id ?? (typeof rawChainId === "number" ? rawChainId : 0);
+    const recipientRaw = req.recipient;
+    const escrowRaw = methodDetails?.escrowContract;
+    const recipient = typeof recipientRaw === "string" && isAddress(recipientRaw) ? getAddress(recipientRaw) : null;
+    const escrowContract = typeof escrowRaw === "string" && isAddress(escrowRaw) ? getAddress(escrowRaw) : channelEntry.escrowContract;
+    return new ZeroSessionCloseFailedError(message, {
+      session: {
+        channelId: channelEntry.channelId,
+        escrowContract,
+        chainId,
+        recipient,
+        cumulativeAmount: channelEntry.cumulativeAmount.toString()
+      },
+      response,
+      capturedAmount,
+      cause
+    });
+  };
+  prepareTempoFunds = async (account, challenge, maxPayUnits, displayCostAmount) => {
+    const challengeRequest = challenge.request;
+    let requiredRaw;
+    if (challenge.intent === "session") {
+      const suggested = isUintString(challengeRequest.suggestedDeposit) ? BigInt(challengeRequest.suggestedDeposit) : 0n;
+      if (suggested > 0n) {
+        requiredRaw = suggested;
+      } else if (maxPayUnits !== null) {
+        requiredRaw = maxPayUnits;
+      } else {
+        requiredRaw = parseUnits(resolveDefaultPrefund(displayCostAmount), 6);
+      }
+    } else {
+      const rawAmount = challengeRequest.amount;
+      if (typeof rawAmount !== "string" || rawAmount.length > MAX_AMOUNT_DIGITS || !UINT_RE.test(rawAmount)) {
+        throw new ZeroPaymentError(
+          `MPP charge challenge amount is not an unsigned integer string: ${JSON.stringify(rawAmount)}`
+        );
+      }
+      requiredRaw = BigInt(rawAmount);
+    }
+    if (maxPayUnits !== null && requiredRaw > maxPayUnits) {
+      throw new ZeroPaymentError(
+        `Payment of ${formatUnits(requiredRaw, 6)} USDC exceeds maxPay ${formatUnits(maxPayUnits, 6)}`
+      );
+    }
+    const capturedAmount = formatUnits(requiredRaw, 6);
+    const methodDetails = challengeRequest.methodDetails;
+    const coerced = coerceTempoChainId(
+      challengeRequest.chainId ?? methodDetails?.chainId
+    );
+    if (!coerced) {
+      throw new ZeroPaymentError(
+        `MPP challenge has missing or unsupported chainId (expected ${TEMPO_CHAIN_ID} or ${TEMPO_TESTNET_CHAIN_ID})`
+      );
+    }
+    const tempoBalance = await this.readUsdcBalance(
+      account.address,
+      coerced.chain
+    );
+    if (tempoBalance < requiredRaw) {
+      if (coerced.chain === "tempo-testnet") {
+        throw new ZeroPaymentError(
+          `Insufficient pathUSD on Tempo testnet: have ${formatUnits(tempoBalance, 6)}, need ${capturedAmount}. Fund via the Tempo testnet faucet: https://docs.tempo.xyz/quickstart/faucet`
+        );
+      }
+      await this.bridgeBaseToTempo(account, requiredRaw - tempoBalance);
+    }
+    return capturedAmount;
+  };
+  bridgeBaseToTempo = async (account, requiredAmount) => {
+    this.ensureRelayClient();
+    const baseBalance = await this.readUsdcBalance(account.address, "base");
+    const buffer = calculateBuffer(baseBalance);
+    const bridgeAmount = requiredAmount + buffer;
+    if (baseBalance < bridgeAmount) {
+      throw new ZeroPaymentError(
+        `Insufficient Base USDC to bridge: have ${formatUnits(baseBalance, 6)}, need ${formatUnits(bridgeAmount, 6)} (${formatUnits(requiredAmount, 6)} + ${formatUnits(buffer, 6)} buffer). This capability uses an MPP payment channel, which is pre-funded up front. Either fund your wallet on Base, or pass \`maxPay\` to size a smaller channel (e.g. \`maxPay: '0.05'\` for a ~5-cent channel sized for a single cheap call).`
+      );
+    }
+    this.client.logger?.({
+      level: "info",
+      message: `Bridging ${formatUnits(bridgeAmount, 6)} USDC from Base to Tempo...`
+    });
+    const walletClient = createWalletClient({
+      account,
+      chain: base,
+      transport: http()
+    });
+    const quote = await getClient().actions.getQuote({
+      chainId: BASE_CHAIN_ID,
+      toChainId: TEMPO_CHAIN_ID,
+      currency: USDC_BASE,
+      toCurrency: USDC_TEMPO,
+      amount: bridgeAmount.toString(),
+      tradeType: "EXACT_INPUT",
+      user: account.address,
+      recipient: account.address,
+      // usePermit signs an EIP-712 Permit2 message — works for both
+      // account mode and session mode (via managed-account adapter).
+      options: { usePermit: true }
+    });
+    let bridgeTxHash = null;
+    await getClient().actions.execute({
+      quote,
+      wallet: adaptViemWallet(walletClient),
+      onProgress: ({ txHashes }) => {
+        if (txHashes?.length && !bridgeTxHash) {
+          bridgeTxHash = txHashes[0]?.txHash ?? null;
+        }
+      }
+    });
+    return bridgeTxHash;
+  };
+  ensureRelayClient = () => {
+    if (this.relayInitialized) return;
+    createClient({
+      baseApiUrl: MAINNET_RELAY_API,
+      source: "zero-sdk",
+      // Both chains registered so post-bridge confirmation polling can
+      // resolve Tempo's RPC; omitting Tempo would hang waiting for a
+      // Tempo tx hash on the Base transport.
+      chains: [
+        convertViemChainToRelayChain(base),
+        convertViemChainToRelayChain(tempoChain)
+      ]
+    });
+    this.relayInitialized = true;
+  };
+  readUsdcBalance = async (address, chain) => {
+    const { viemChain, token } = (() => {
+      switch (chain) {
+        case "base":
+          return { viemChain: base, token: USDC_BASE };
+        case "base-sepolia":
+          return {
+            viemChain: baseSepolia,
+            token: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+          };
+        case "tempo":
+          return { viemChain: tempoChain, token: USDC_TEMPO };
+        case "tempo-testnet":
+          return { viemChain: tempoTestnetChain, token: PATHUSD_TEMPO };
+      }
+    })();
+    const client = createPublicClient({ chain: viemChain, transport: http() });
+    return await client.readContract({
+      address: token,
+      abi: ERC20_BALANCE_ABI,
+      functionName: "balanceOf",
+      args: [address]
+    });
+  };
+  // Single normalizer — string and number chainIds resolve consistently.
+  // Delegates to exported helper so fetch.ts's orphan path agrees.
+  tempoChainLabel = (challenge) => {
+    const req = challenge?.request;
+    const methodDetails = req?.methodDetails;
+    return tempoChainLabelFromId(req?.chainId ?? methodDetails?.chainId);
+  };
+  completeMppSession = async (params) => {
+    const {
+      url,
+      method,
+      challenge,
+      channelEntry,
+      openTimeCumulative,
+      response,
+      capturedAmount,
+      mppx,
+      signal,
+      configuredFetch
+    } = params;
+    const challengeRequest = challenge.request;
+    const recipientRaw = challengeRequest.recipient;
+    const methodDetails = challengeRequest.methodDetails;
+    const escrowRaw = methodDetails?.escrowContract;
+    const recipient = typeof recipientRaw === "string" && isAddress(recipientRaw) ? getAddress(recipientRaw) : null;
+    const challengeEscrow = typeof escrowRaw === "string" && isAddress(escrowRaw) ? getAddress(escrowRaw) : null;
+    const coercedChainId = coerceTempoChainId(
+      challengeRequest.chainId ?? methodDetails?.chainId
+    );
+    const { channelId, escrowContract } = channelEntry;
+    const buildOrphanFromChannelEntry = (message) => this.buildOrphanError(
+      channelEntry,
+      challenge,
+      capturedAmount,
+      response,
+      message,
+      void 0
+    );
+    if (!recipient || !challengeEscrow) {
+      throw buildOrphanFromChannelEntry(
+        `MPP session challenge has missing or malformed recipient/escrowContract; channel ${channelId} is open and requires reconciliation.`
+      );
+    }
+    if (!coercedChainId) {
+      throw buildOrphanFromChannelEntry(
+        `MPP session challenge has unsupported chainId (expected ${TEMPO_CHAIN_ID} or ${TEMPO_TESTNET_CHAIN_ID}); channel ${channelId} is open and requires reconciliation.`
+      );
+    }
+    const receipt = readSessionReceipt(response);
+    let closeAmount = pickSessionCloseAmount(receipt, openTimeCumulative);
+    if (closeAmount === 0n && channelEntry.cumulativeAmount > 0n) {
+      closeAmount = channelEntry.cumulativeAmount;
+    }
+    const reconcileAmount = receipt && isUintString(receipt.acceptedCumulative) ? receipt.acceptedCumulative : closeAmount.toString();
+    const orphanedSession = {
+      channelId,
+      escrowContract,
+      chainId: coercedChainId.id,
+      recipient,
+      cumulativeAmount: reconcileAmount
+    };
+    const closeFailed = (message, cause) => new ZeroSessionCloseFailedError(message, {
+      session: orphanedSession,
+      response,
+      capturedAmount,
+      cause
+    });
+    if (closeAmount === 0n) {
+      throw closeFailed(
+        `Refusing to sign zero close credential for channel ${channelId} \u2014 neither receipt nor channelEntry produced a nonzero cumulativeAmount. Query escrow directly to recover; check logger for an earlier 'non-bigint cumulativeAmount' warning.`
+      );
+    }
+    const closeChallengeResponse = new Response("", {
+      status: 402,
+      headers: { "WWW-Authenticate": Challenge.serialize(challenge) }
+    });
+    let closeCredential;
+    try {
+      closeCredential = await raceWithSignal(
+        mppx.createCredential(closeChallengeResponse, {
+          action: "close",
+          channelId,
+          cumulativeAmountRaw: closeAmount.toString()
+        }),
+        signal,
+        this.client
+      );
+    } catch (err) {
+      throw closeFailed(
+        `Session close credential build failed for channel ${channelId}: ${err instanceof Error ? err.message : String(err)}`,
+        err
+      );
+    }
+    let closeResponse;
+    try {
+      closeResponse = await configuredFetch(url, {
+        method: method.toUpperCase(),
+        headers: { authorization: closeCredential },
+        signal
+      });
+    } catch (err) {
+      throw closeFailed(
+        `Session close request failed for channel ${channelId}: ${err instanceof Error ? err.message : String(err)}`,
+        err
+      );
+    }
+    if (!closeResponse.ok) {
+      const errBody = await Promise.race([
+        closeResponse.text().catch(() => ""),
+        new Promise((resolve) => {
+          const t = setTimeout(() => resolve(""), 1e3);
+          t.unref();
+        })
+      ]);
+      cancelBody(closeResponse);
+      throw closeFailed(
+        `Seller rejected close credential (status ${closeResponse.status}${errBody ? `: ${errBody.slice(0, 200)}` : ""}) for channel ${channelId}`
+      );
+    }
+    const closeReceipt = readSessionReceipt(closeResponse);
+    cancelBody(closeResponse);
+    const rawCloseTx = closeReceipt?.txHash;
+    const closeTxHash = typeof rawCloseTx === "string" && /^0x[0-9a-fA-F]+$/.test(rawCloseTx) ? rawCloseTx : null;
+    return {
+      response,
+      payment: {
+        protocol: "mpp",
+        chain: this.tempoChainLabel(challenge),
+        txHash: closeTxHash,
+        amount: capturedAmount,
+        asset: "USDC",
+        session: {
+          channelId,
+          escrowContract,
+          chainId: coercedChainId.id,
+          recipient,
+          cumulativeAmount: closeReceipt && isUintString(closeReceipt.acceptedCumulative) ? closeReceipt.acceptedCumulative : closeAmount.toString()
+        }
+      }
+    };
+  };
+};
+
+// package.json
+var package_default = {
+  version: "0.1.0"};
+
+// src/version.ts
+var SDK_VERSION = package_default.version;
+var userWalletDtoSchema = z.object({
+  walletAddress: z.string(),
+  source: z.enum(["self_custody", "privy_embedded"]),
+  isPrimary: z.boolean(),
+  linkedAt: z.union([z.string(), z.date()]).nullable().optional(),
+  delegationGranted: z.boolean(),
+  signerQuorumId: z.string().nullable(),
+  // Per-transaction USDC cap in base units (6 dp). null = unlimited, 0 = free-only.
+  maxTransactionUsdcBaseUnits: z.number().int().nullable()
+});
+var welcomeBonusSummarySchema = z.object({
+  status: z.string(),
+  amountUsd: z.number()
+});
+var internalUserDtoSchema = z.object({
+  id: z.string(),
+  email: z.string().nullable(),
+  createdAt: z.union([z.string(), z.date()]).optional(),
+  lastLoginAt: z.union([z.string(), z.date()]).nullable().optional(),
+  onboardingCompleted: z.boolean().optional(),
+  delegationGranted: z.boolean().optional(),
+  wallets: z.array(userWalletDtoSchema).optional(),
+  balance: z.object({ amount: z.string(), asset: z.string() }).nullable().optional(),
+  welcomeBonus: welcomeBonusSummarySchema.nullable().optional()
+});
+var publicUserDtoSchema = z.object({
+  user: z.object({
+    id: z.string(),
+    email: z.string().nullable()
+  }),
+  walletAddress: z.string().nullable(),
+  balance: z.object({ amount: z.string(), asset: z.string() }).nullable(),
+  welcomeBonus: welcomeBonusSummarySchema.nullable()
+});
+var signResponseSchema = z.object({
+  signature: z.string().regex(/^0x[0-9a-fA-F]+$/, "must be 0x-prefixed hex"),
+  walletAddress: z.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be 0x-prefixed 40-char hex address")
+});
+
+// src/schemas/device.ts
+var deviceStartResponseSchema = z.object({
+  deviceCode: z.string(),
+  userCode: z.string(),
+  verificationUri: z.string(),
+  pollInterval: z.number(),
+  expiresAt: z.number()
+});
+var devicePollResponseSchema = z.union([
+  z.object({ error: z.literal("authorization_pending") }),
+  z.object({ error: z.literal("expired_token") }),
+  z.object({
+    accessToken: z.string(),
+    refreshToken: z.string(),
+    expiresIn: z.number(),
+    user: internalUserDtoSchema
+  })
+]);
+var sessionExchangeResponseSchema = z.object({
+  token: z.string(),
+  expiresAt: z.number()
+});
+var refreshResponseSchema = z.object({
+  accessToken: z.string(),
+  refreshToken: z.string()
+});
+var tryRefreshSession = async (client, callerSignal) => {
+  const credentials = client.getCredentials();
+  if (credentials.kind !== "session") return false;
+  if (!credentials.refreshToken) return false;
+  const url = `${client.baseUrl.replace(/\/$/, "")}/v1/auth/refresh`;
+  const timeoutSignal = AbortSignal.timeout(client.timeout);
+  const signal = callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
+  let response;
+  try {
+    response = await client.fetchImpl(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ refreshToken: credentials.refreshToken }),
+      signal
+    });
+  } catch {
+    return false;
+  }
+  if (!response.ok) return false;
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return false;
+  }
+  const parsed = refreshResponseSchema.safeParse(body);
+  if (!parsed.success) return false;
+  await client.applyRefreshedTokens({
+    accessToken: parsed.data.accessToken,
+    refreshToken: parsed.data.refreshToken
+  });
+  return true;
+};
+var buildSessionAuthHeaders = (accessToken) => ({
+  authorization: `Bearer ${accessToken}`
+});
+var buildCanonicalMessage = (method, pathWithQuery, body, timestamp, nonce) => {
+  const bodyHash = createHash("sha256").update(body ?? "").digest("hex");
+  return `${method}:${pathWithQuery}:${bodyHash}:${timestamp}:${nonce}`;
+};
+var buildAccountAuthHeaders = async (account, method, pathWithQuery, body) => {
+  const timestamp = Math.floor(Date.now() / 1e3).toString();
+  const nonce = crypto.randomUUID();
+  const message = buildCanonicalMessage(
+    method,
+    pathWithQuery,
+    body,
+    timestamp,
+    nonce
+  );
+  const signature = await account.signMessage({ message });
+  return {
+    "x-zero-address": account.address,
+    "x-zero-timestamp": timestamp,
+    "x-zero-nonce": nonce,
+    "x-zero-signature": signature
+  };
+};
+
+// src/transport/http.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 502, 503, 504]);
+var sleep = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) {
+    reject(new DOMException("Aborted", "AbortError"));
+    return;
+  }
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(new DOMException("Aborted", "AbortError"));
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+var buildPathWithQuery = (path, query) => {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  if (!query) return normalizedPath;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0) params.set(key, String(value));
+  }
+  const qs = params.toString();
+  return qs ? `${normalizedPath}?${qs}` : normalizedPath;
+};
+var joinUrl = (baseUrl, pathWithQuery) => {
+  const base3 = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  return `${base3}${pathWithQuery}`;
+};
+var buildHeaders = async (client, method, pathWithQuery, hasBody, bodyStr) => {
+  const headers = { ...client.defaultHeaders };
+  if (hasBody) headers["content-type"] = "application/json";
+  headers["x-zero-sdk-version"] = SDK_VERSION;
+  if (client.apiVersion) headers["x-zero-api-version"] = client.apiVersion;
+  const credentials = client.getCredentials();
+  if (credentials.kind === "session") {
+    Object.assign(headers, buildSessionAuthHeaders(credentials.accessToken));
+  } else if (credentials.kind === "account") {
+    const signed = await buildAccountAuthHeaders(
+      credentials.account,
+      method,
+      pathWithQuery,
+      bodyStr
+    );
+    Object.assign(headers, signed);
+  }
+  return headers;
+};
+var parseErrorBody = async (response) => {
+  try {
+    return await response.clone().json();
+  } catch {
+    try {
+      return await response.text();
+    } catch {
+      return void 0;
+    }
+  }
+};
+var errorMessageFromBody = (body, status) => {
+  if (body !== null && typeof body === "object" && "error" in body && typeof body.error === "string") {
+    return body.error;
+  }
+  return `HTTP ${status}`;
+};
+var request = async (client, opts, schema) => {
+  const pathWithQuery = buildPathWithQuery(opts.path, opts.query);
+  const url = joinUrl(client.baseUrl, pathWithQuery);
+  const hasBody = opts.body !== void 0;
+  const bodyStr = hasBody ? JSON.stringify(
+    opts.body,
+    (_k, v) => typeof v === "bigint" ? v.toString() : v
+  ) : void 0;
+  const configuredFetch = buildConfiguredFetch(client);
+  const performOnce = async () => configuredFetch(url, {
+    method: opts.method,
+    headers: await buildHeaders(
+      client,
+      opts.method,
+      pathWithQuery,
+      hasBody,
+      bodyStr
+    ),
+    body: bodyStr,
+    signal: opts.signal
+  });
+  let refreshAttempted = false;
+  const executeWithRefresh = async () => {
+    const response = await performOnce();
+    if (response.status !== 401 || refreshAttempted) return response;
+    const credentials = client.getCredentials();
+    if (credentials.kind !== "session") return response;
+    refreshAttempted = true;
+    const refreshed = await client.refreshSessionOnce(opts.signal);
+    if (!refreshed) return response;
+    return await performOnce();
+  };
+  let lastNetworkError;
+  for (let attempt = 0; attempt <= client.maxRetries; attempt++) {
+    let response;
+    try {
+      response = await executeWithRefresh();
+    } catch (e) {
+      if (e instanceof ZeroError) throw e;
+      lastNetworkError = e;
+      if (attempt < client.maxRetries) {
+        try {
+          await sleep(2 ** attempt * 200, opts.signal);
+        } catch (sleepErr) {
+          throw new ZeroApiError("Request aborted by caller", {
+            status: 0,
+            cause: sleepErr
+          });
+        }
+        continue;
+      }
+      throw new ZeroApiError("Network request failed", {
+        status: 0,
+        cause: e
+      });
+    }
+    if (response.ok) {
+      let text;
+      try {
+        text = await response.text();
+      } catch (e) {
+        throw new ZeroApiError("Response body read failed", {
+          status: response.status,
+          cause: e
+        });
+      }
+      let json;
+      try {
+        json = JSON.parse(text);
+      } catch {
+      }
+      const parsed = schema.safeParse(json);
+      if (!parsed.success) {
+        throw new ZeroValidationError(
+          `Response did not match expected schema for ${opts.method} ${opts.path}`,
+          { cause: parsed.error, body: text }
+        );
+      }
+      return parsed.data;
+    }
+    if (RETRYABLE_STATUS.has(response.status) && attempt < client.maxRetries) {
+      try {
+        await sleep(2 ** attempt * 200, opts.signal);
+      } catch (sleepErr) {
+        throw new ZeroApiError("Request aborted by caller", {
+          status: 0,
+          cause: sleepErr
+        });
+      }
+      continue;
+    }
+    const errorBody = await parseErrorBody(response);
+    const requestId = response.headers.get("x-request-id") ?? void 0;
+    throw new ZeroApiError(errorMessageFromBody(errorBody, response.status), {
+      status: response.status,
+      requestId,
+      body: errorBody
+    });
+  }
+  throw new ZeroApiError("Exhausted retries", {
+    status: 0,
+    cause: lastNetworkError
+  });
+};
+
+// src/namespaces/auth-device.ts
+var AuthDevice = class {
+  constructor(client) {
+    this.client = client;
+  }
+  start = (opts = {}) => request(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/auth/device/start",
+      signal: opts.signal
+    },
+    deviceStartResponseSchema
+  );
+  poll = async (deviceCode, opts = {}) => {
+    const parsed = await request(
+      this.client,
+      {
+        method: "POST",
+        path: "/v1/auth/device/poll",
+        body: { deviceCode },
+        signal: opts.signal
+      },
+      devicePollResponseSchema
+    );
+    if ("error" in parsed) {
+      return parsed.error === "authorization_pending" ? { status: "pending" } : { status: "expired" };
+    }
+    return {
+      status: "ok",
+      accessToken: parsed.accessToken,
+      refreshToken: parsed.refreshToken,
+      expiresIn: parsed.expiresIn,
+      user: parsed.user
+    };
+  };
+};
+var userWalletsSchema = z.array(userWalletDtoSchema);
+var normalizeMessage = (message) => {
+  if (typeof message === "string") return message;
+  if (typeof message.raw === "string") return message.raw;
+  return bytesToHex(message.raw);
+};
+var repackageSignFailure = (err, op) => {
+  if (err instanceof ZeroApiError && err.status === 402) {
+    const body = err.body;
+    const detail = body && typeof body.error === "string" ? `: ${body.error}` : "";
+    throw new ZeroPaymentError(
+      `Sign endpoint refused ${op} (HTTP 402)${detail}`,
+      { cause: err }
+    );
+  }
+  throw err;
+};
+var Auth = class {
+  constructor(client) {
+    this.client = client;
+    this.device = new AuthDevice(client);
+  }
+  device;
+  // The internal (web-app facing) user profile. Richer than profile(): full
+  // wallet list with per-wallet delegation/signer/limit metadata.
+  me = (opts = {}) => request(
+    this.client,
+    { method: "GET", path: "/v1/users/me", signal: opts.signal },
+    internalUserDtoSchema
+  );
+  // The public (agent-facing) profile — identity + primary wallet address +
+  // balance + welcome-bonus, no per-wallet metadata. Same shape the MCP
+  // get_profile tool returns; rendered by `zero auth whoami`.
+  profile = (opts = {}) => request(
+    this.client,
+    { method: "GET", path: "/v1/users/me/profile", signal: opts.signal },
+    publicUserDtoSchema
+  );
+  // The user's wallets only. Lightweight sibling of `me()` for callers that
+  // just need wallet addresses (e.g. managed-account resolution on the pay
+  // path) — avoids the heavier internal-profile computation behind `me()`.
+  wallets = (opts = {}) => request(
+    this.client,
+    { method: "GET", path: "/v1/users/me/wallets", signal: opts.signal },
+    userWalletsSchema
+  );
+  // Exchange an ephemeral session code (e.g. runner / sandbox handoff) for
+  // a session access token. The returned token has no refresh path — pair
+  // with `refreshToken: ""` when constructing the client.
+  exchangeSessionCode = (code, opts = {}) => request(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/session/exchange",
+      body: { code },
+      signal: opts.signal
+    },
+    sessionExchangeResponseSchema
+  );
+  // Server-side revoke of the refresh token. Throws ZeroApiError on any
+  // non-2xx — callers that have already cleared local state (e.g. CLI
+  // logout) typically want to swallow with `.catch(() => {})` so a flaky
+  // server doesn't surface as a user-visible failure for a sign-out that
+  // already succeeded locally. Response body is opaque; schema is
+  // `z.unknown()` and the resolved value is discarded.
+  logout = async (refreshToken, opts = {}) => {
+    await request(
+      this.client,
+      {
+        method: "POST",
+        path: "/v1/auth/logout",
+        body: { refreshToken },
+        signal: opts.signal
+      },
+      z.unknown()
+    );
+  };
+  // Force a session refresh. Routes through refreshSessionOnce() so a
+  // proactive call doesn't race a 401-driven transport refresh —
+  // concurrent POSTs with the same refresh token kill the session
+  // family (RFC 6819 token-theft response).
+  refresh = async () => {
+    const credentials = this.client.getCredentials();
+    if (credentials.kind !== "session") {
+      throw new ZeroAuthError(
+        "auth_no_credentials",
+        "refresh() requires the client to be constructed with a session \u2014 got credentials.kind=" + credentials.kind
+      );
+    }
+    const ok = await this.client.refreshSessionOnce();
+    if (!ok) {
+      throw new ZeroAuthError(
+        "auth_session_expired",
+        "Session refresh failed. The refresh token may be revoked or expired."
+      );
+    }
+  };
+  signMessage = async (input, opts = {}) => {
+    const credentials = this.client.getCredentials();
+    if (credentials.kind === "account") {
+      return await credentials.account.signMessage({ message: input.message });
+    }
+    if (credentials.kind === "session") {
+      try {
+        const parsed = await request(
+          this.client,
+          {
+            method: "POST",
+            path: "/v1/users/me/sign-message",
+            body: { message: normalizeMessage(input.message) }
+          },
+          signResponseSchema
+        );
+        this.assertSignerMatches(parsed.walletAddress, opts.expectedAddress);
+        return parsed.signature;
+      } catch (err) {
+        repackageSignFailure(err, "signMessage");
+      }
+    }
+    throw new ZeroAuthError(
+      "auth_no_credentials",
+      "signMessage() requires the client to be constructed with `account` or `session`."
+    );
+  };
+  // Managed-only: BYO accounts sign locally via viem's account.signTransaction.
+  signTransaction = async (input, opts = {}) => {
+    const credentials = this.client.getCredentials();
+    if (credentials.kind === "session") {
+      try {
+        const parsed = await request(
+          this.client,
+          {
+            method: "POST",
+            path: "/v1/users/me/sign-transaction",
+            body: { unsignedTransaction: input.unsignedTransaction }
+          },
+          signResponseSchema
+        );
+        this.assertSignerMatches(parsed.walletAddress, opts.expectedAddress);
+        return parsed.signature;
+      } catch (err) {
+        repackageSignFailure(err, "signTransaction");
+      }
+    }
+    if (credentials.kind === "account") {
+      throw new ZeroAuthError(
+        "auth_error",
+        "signTransaction() is a managed-signing operation and is not supported in account mode. Sign locally with viem's account.signTransaction instead."
+      );
+    }
+    throw new ZeroAuthError(
+      "auth_no_credentials",
+      "signTransaction() requires session credentials (managed signing)."
+    );
+  };
+  signTypedData = async (input, opts = {}) => {
+    const credentials = this.client.getCredentials();
+    if (credentials.kind === "account") {
+      if (!credentials.account.signTypedData) {
+        throw new ZeroAuthError(
+          "auth_error",
+          "The configured viem account does not implement signTypedData."
+        );
+      }
+      return await credentials.account.signTypedData(input);
+    }
+    if (credentials.kind === "session") {
+      try {
+        const parsed = await request(
+          this.client,
+          {
+            method: "POST",
+            path: "/v1/users/me/sign-typed-data",
+            body: { typedData: input }
+          },
+          signResponseSchema
+        );
+        this.assertSignerMatches(parsed.walletAddress, opts.expectedAddress);
+        return parsed.signature;
+      } catch (err) {
+        repackageSignFailure(err, "signTypedData");
+      }
+    }
+    throw new ZeroAuthError(
+      "auth_no_credentials",
+      "signTypedData() requires the client to be constructed with `account` or `session`."
+    );
+  };
+  // Compare against the caller's pinned address (not shared cache) so
+  // concurrent pay()s can't race past each other. Mismatch → clear + throw;
+  // the caller's retry rebuilds against the new wallet.
+  assertSignerMatches = (serverAddr, expectedAddr) => {
+    if (!expectedAddr) return;
+    const canonicalServer = getAddress(serverAddr);
+    const canonicalExpected = getAddress(expectedAddr);
+    if (canonicalExpected === canonicalServer) return;
+    this.client.clearManagedAccount();
+    throw new ZeroAuthError(
+      "auth_error",
+      `Managed signing wallet changed (caller expected ${canonicalExpected}, server signed as ${canonicalServer}). Cache cleared \u2014 retry to rebuild against the current wallet.`
+    );
+  };
+};
+var BUG_REPORT_CATEGORIES = [
+  "search_relevance",
+  "ranking_issue",
+  "missing_capability",
+  "wrong_schema",
+  "misleading_description",
+  "broken_execution",
+  "payment_failure",
+  "billing_anomaly",
+  "cli_bug",
+  "security",
+  "other"
+];
+var createBugReportResponseSchema = z.object({
+  bugReportId: z.string(),
+  status: z.string(),
+  deduped: z.boolean(),
+  category: z.enum(BUG_REPORT_CATEGORIES).nullable(),
+  title: z.string().nullable(),
+  attached: z.object({
+    capabilityId: z.number().nullable(),
+    runId: z.number().nullable(),
+    searchId: z.number().nullable()
+  })
+});
+
+// src/namespaces/bug-reports.ts
+var BugReports = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // POST /v1/bug-reports. Wallet-attributed server-side; the SDK client's
+  // active credential drives attribution (account-mode → EIP-191 from the
+  // wallet, session-mode → Bearer + server resolves the user's wallet).
+  create = (input, opts = {}) => request(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/bug-reports",
+      body: input,
+      signal: opts.signal
+    },
+    createBugReportResponseSchema
+  );
+};
+var ratingSchema = z.object({
+  score: z.string(),
+  successRate: z.string(),
+  reviews: z.number(),
+  stars: z.string().nullable().optional(),
+  state: z.enum(["unrated", "rated"]).optional()
+});
+
+// src/schemas/capabilities.ts
+var capabilityResponseSchema = z.object({
+  uid: z.string(),
+  slug: z.string(),
+  name: z.string(),
+  description: z.string(),
+  url: z.string(),
+  urlTemplate: z.string().nullable().optional(),
+  method: z.string(),
+  headers: z.record(z.string(), z.string()).nullable(),
+  bodySchema: z.record(z.string(), z.unknown()).nullable(),
+  responseSchema: z.record(z.string(), z.unknown()).nullable(),
+  example: z.object({ request: z.unknown(), response: z.unknown() }).nullable(),
+  tags: z.array(z.string()).nullable(),
+  exampleAgentPrompt: z.string().nullable().optional(),
+  displayCostAmount: z.string(),
+  displayCostAsset: z.string(),
+  reviewCount: z.number(),
+  rating: ratingSchema,
+  priceObserved: z.object({
+    minCents: z.string().nullable(),
+    medianCents: z.string().nullable(),
+    maxCents: z.string().nullable(),
+    // Deprecated alias for maxCents; kept for back-compat with older
+    // API versions that still emit it.
+    p95Cents: z.string().nullable(),
+    sampleCount: z.number(),
+    varies: z.boolean(),
+    failureChargeRate: z.number().nullable()
+  }).nullable().optional(),
+  paymentMethods: z.array(
+    z.object({
+      uid: z.string(),
+      protocol: z.string(),
+      methodType: z.string(),
+      chain: z.string().nullable(),
+      mode: z.string(),
+      costAmount: z.string(),
+      costPer: z.string(),
+      priority: z.number()
+    })
+  ).nullable(),
+  availabilityStatus: z.enum(["healthy", "unknown", "down"]).nullable().optional(),
+  /**
+   * @deprecated The API no longer emits `displayStatus`; it has been replaced
+   * by the consolidated 3-value {@link capabilityResponseSchema.shape.availabilityStatus}.
+   * Kept as an optional field for one release for back-compat (ZERO-89 soft
+   * migration) and will be removed in the next major version.
+   */
+  displayStatus: z.enum(["healthy", "stable", "degraded", "unhealthy", "unknown"]).optional(),
+  activationCount: z.number().optional(),
+  lastUsedAt: z.string().nullable().optional(),
+  lastSuccessfullyRanAt: z.string().nullable().optional()
+});
+
+// src/namespaces/capabilities.ts
+var Capabilities = class {
+  constructor(client) {
+    this.client = client;
+  }
+  get = (id, opts = {}) => request(
+    this.client,
+    {
+      method: "GET",
+      path: `/v1/capabilities/${encodeURIComponent(id)}`,
+      query: opts.searchId ? { searchId: opts.searchId } : void 0,
+      signal: opts.signal
+    },
+    capabilityResponseSchema
+  );
+};
+var createRunResponseSchema = z.object({
+  runId: z.string()
+});
+var runListItemSchema = z.object({
+  uid: z.string(),
+  capabilityUid: z.string(),
+  capabilitySlug: z.string(),
+  capabilityName: z.string(),
+  status: z.number().nullable(),
+  latencyMs: z.number().nullable(),
+  cost: z.object({ amount: z.string(), asset: z.string().nullable() }).nullable(),
+  payment: z.object({
+    protocol: z.string(),
+    chain: z.string().nullable(),
+    txHash: z.string().nullable(),
+    mode: z.string().nullable()
+  }).nullable(),
+  createdAt: z.coerce.date(),
+  reviewed: z.boolean()
+});
+var listRunsResponseSchema = z.object({
+  runs: z.array(runListItemSchema),
+  nextCursor: z.string().nullable()
+});
+var createReviewResponseSchema = z.object({
+  reviewId: z.string(),
+  recorded: z.boolean(),
+  updated: z.boolean().optional()
+});
+var batchReviewResponseSchema = z.object({
+  results: z.array(
+    z.union([
+      z.object({
+        runId: z.string(),
+        ok: z.literal(true),
+        reviewId: z.string(),
+        updated: z.boolean()
+      }),
+      z.object({
+        runId: z.string(),
+        ok: z.literal(false),
+        status: z.number(),
+        error: z.string()
+      })
+    ])
+  ),
+  summary: z.object({
+    total: z.number(),
+    ok: z.number(),
+    failed: z.number()
+  })
+});
+
+// src/namespaces/runs.ts
+var Runs = class {
+  constructor(client) {
+    this.client = client;
+  }
+  create = (input, opts = {}) => request(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/runs",
+      body: input,
+      signal: opts.signal
+    },
+    createRunResponseSchema
+  );
+  list = (params = {}, opts = {}) => {
+    if (params.limit === 0) {
+      if (opts.signal?.aborted) {
+        return Promise.reject(
+          new ZeroApiError("Request aborted by caller", { status: 0 })
+        );
+      }
+      if (params.cursor === void 0) {
+        return Promise.reject(
+          new ZeroApiError(
+            "runs.list({ limit: 0 }) requires a cursor \u2014 without one the empty page is indistinguishable from end-of-stream",
+            { status: 0 }
+          )
+        );
+      }
+      return Promise.resolve({
+        runs: [],
+        nextCursor: params.cursor
+      });
+    }
+    const query = {};
+    if (params.capabilityId !== void 0)
+      query.capabilityId = params.capabilityId;
+    if (params.unreviewed !== void 0) query.unreviewed = params.unreviewed;
+    if (params.limit !== void 0) query.limit = params.limit;
+    if (params.cursor !== void 0) query.cursor = params.cursor;
+    return request(
+      this.client,
+      {
+        method: "GET",
+        path: "/v1/runs",
+        query,
+        signal: opts.signal
+      },
+      listRunsResponseSchema
+    );
+  };
+  review = (input, opts = {}) => request(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/reviews",
+      body: input,
+      signal: opts.signal
+    },
+    createReviewResponseSchema
+  );
+  // Bulk review submission. The CLI's bulk JSONL parser stays CLI-side —
+  // SDK consumers pass already-parsed structured input.
+  createReviewsBatch = (reviews, opts = {}) => request(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/reviews/batch",
+      body: { reviews },
+      signal: opts.signal
+    },
+    batchReviewResponseSchema
+  );
+};
+var USDC_BASE2 = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+var USDC_TEMPO2 = "0x20c000000000000000000000b9537d11c60e8b50";
+var TEMPO_CHAIN_ID2 = 4217;
+var baseChain = base;
+var tempoChain2 = {
+  id: TEMPO_CHAIN_ID2,
+  name: "Tempo",
+  nativeCurrency: { name: "USD", symbol: "USD", decimals: 18 },
+  rpcUrls: {
+    default: { http: ["https://rpc.tempo.xyz"] }
+  }
+};
+var ERC20_BALANCE_ABI2 = [
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var USDC_DECIMALS = 6;
+
+// src/namespaces/wallet.ts
+var fundingUrlResponseSchema = z.object({ url: z.string() });
+var userWalletListSchema = z.array(userWalletDtoSchema);
+var migrateAuthorizationResponseSchema = z.object({
+  transactionHash: z.string()
+});
+var errorMessage = (reason) => reason instanceof Error ? reason.message : String(reason);
+var Wallet = class {
+  constructor(client) {
+    this.client = client;
+  }
+  clients = {};
+  // The configured wallet address, or null if the client wasn't constructed
+  // with an account. Stable read — does not hit the network.
+  get address() {
+    const credentials = this.client.getCredentials();
+    if (credentials.kind !== "account") return null;
+    return credentials.account.address;
+  }
+  balance = async (opts = {}) => {
+    const target = opts.address ?? this.address;
+    if (!target) {
+      throw new ZeroWalletError(
+        "balance() requires either an `address` option or a client constructed with an account"
+      );
+    }
+    const chain = opts.chain ?? "total";
+    if (chain !== "total") {
+      const raw = await this.readChainBalance(chain, target);
+      return { amount: formatUnits(raw, USDC_DECIMALS), asset: "USDC" };
+    }
+    const chains = ["base", "tempo"];
+    const settled = await Promise.allSettled(
+      chains.map((c) => this.readChainBalance(c, target))
+    );
+    let sum = 0n;
+    const errors = [];
+    for (let i = 0; i < settled.length; i++) {
+      const result = settled[i];
+      const chainName = chains[i];
+      if (!result || !chainName) continue;
+      if (result.status === "fulfilled") {
+        sum += result.value;
+      } else {
+        errors.push({ chain: chainName, message: errorMessage(result.reason) });
+      }
+    }
+    if (errors.length === settled.length) {
+      throw new ZeroWalletError(
+        `balance() failed for every chain: ${errors.map((e) => `${e.chain} (${e.message})`).join(", ")}`
+      );
+    }
+    const balance = {
+      amount: formatUnits(sum, USDC_DECIMALS),
+      asset: "USDC"
+    };
+    if (errors.length > 0) balance.errors = errors;
+    return balance;
+  };
+  // All wallets linked to the authenticated session user. Session-only.
+  list = (opts = {}) => request(
+    this.client,
+    {
+      method: "GET",
+      path: "/v1/users/me/wallets",
+      signal: opts.signal
+    },
+    userWalletListSchema
+  );
+  // Provision a managed (Privy-embedded) wallet for the session user.
+  // Idempotent server-side — repeat calls return the existing wallet.
+  provision = (opts = {}) => request(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/users/me/wallets/provision",
+      signal: opts.signal
+    },
+    userWalletDtoSchema
+  );
+  // Relays a BYO-wallet-signed EIP-3009 ReceiveWithAuthorization, sweeping
+  // USDC from the BYO wallet to the user's Zero wallet on Base via the
+  // gas-paying relayer. The SDK does not author the authorization (chain
+  // nonce + EIP-712 domain coupling stays caller-side); it only forwards
+  // the signed payload. Session-only.
+  migrateAuthorization = (authorization, opts = {}) => request(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/users/me/wallets/migrate",
+      body: { authorization },
+      signal: opts.signal
+    },
+    migrateAuthorizationResponseSchema
+  );
+  // Routes by identity: account mode signs EIP-191 against /v1/wallet/fund-url,
+  // session mode hits /v1/users/me/fund-url (Bearer-authed, wallet resolved
+  // server-side). Both honor `provider` (coinbase | stripe).
+  fundingUrl = async (opts = {}) => {
+    const credentials = this.client.getCredentials();
+    const path = credentials.kind === "account" ? "/v1/wallet/fund-url" : credentials.kind === "session" ? "/v1/users/me/fund-url" : null;
+    if (!path) {
+      throw new ZeroWalletError(
+        "fundingUrl() requires a client constructed with an account or session credentials"
+      );
+    }
+    const query = {
+      provider: opts.provider ?? "coinbase"
+    };
+    if (opts.amount) query.amount = opts.amount;
+    const { url } = await request(
+      this.client,
+      { method: "GET", path, query, signal: opts.signal },
+      fundingUrlResponseSchema
+    );
+    return url;
+  };
+  getPublicClient = (chain) => {
+    if (chain === "base") {
+      if (!this.clients.base) {
+        this.clients.base = createPublicClient({
+          chain: baseChain,
+          transport: http()
+        });
+      }
+      return this.clients.base;
+    }
+    if (!this.clients.tempo) {
+      this.clients.tempo = createPublicClient({
+        // biome-ignore lint/suspicious/noExplicitAny: tempo is a custom chain object that viem's stricter Chain type rejects shape-wise but accepts at runtime
+        chain: tempoChain2,
+        transport: http()
+      });
+    }
+    return this.clients.tempo;
+  };
+  /**
+   * @internal
+   *
+   * Per-chain USDC balance read. Exposed (rather than private) so unit
+   * tests can stub it without standing up a real viem public client —
+   * viem's `http()` transport doesn't go through `client.fetchImpl`, so
+   * the standard mock-fetch trick doesn't cover this path.
+   */
+  readChainBalance = async (chain, address) => {
+    const publicClient = this.getPublicClient(chain);
+    const tokenAddress = chain === "base" ? USDC_BASE2 : USDC_TEMPO2;
+    const balance = await publicClient.readContract({
+      address: tokenAddress,
+      abi: ERC20_BALANCE_ABI2,
+      functionName: "balanceOf",
+      args: [address]
+    });
+    return balance;
+  };
+};
+
+// src/options.ts
+var DEFAULT_BASE_URL = "https://api.zero.xyz";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var DEFAULT_MAX_RETRIES = 2;
+
+// src/auth/credentials.ts
+var noopRefresh = async () => {
+};
+var MAX_402_PROBE_BYTES = 1024 * 1024;
+var MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
+var TEXT_CONTENT_TYPES = [
+  "application/json",
+  "application/xml",
+  "application/javascript",
+  "application/ecmascript",
+  "application/x-www-form-urlencoded",
+  "text/",
+  "+json",
+  "+xml"
+];
+var MPP_SCHEME_TOKENS = /* @__PURE__ */ new Set(["payment", "mpp"]);
+var splitWwwAuthenticateChallenges = (header) => {
+  const chunks = [];
+  let buf = "";
+  let inQuotes = false;
+  for (let i = 0; i < header.length; i++) {
+    const ch = header[i];
+    if (inQuotes) {
+      if (ch === "\\" && i + 1 < header.length) {
+        buf += ch + header[i + 1];
+        i++;
+        continue;
+      }
+      if (ch === '"') inQuotes = false;
+      buf += ch;
+      continue;
+    }
+    if (ch === '"') {
+      inQuotes = true;
+      buf += ch;
+      continue;
+    }
+    if (ch === ",") {
+      chunks.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  if (buf.length > 0) chunks.push(buf);
+  return chunks;
+};
+var isTextContentType = (contentType) => {
+  if (!contentType) return true;
+  const lower = contentType.toLowerCase();
+  return TEXT_CONTENT_TYPES.some((marker) => lower.includes(marker));
+};
+var redactUrl = (url) => {
+  try {
+    const u = new URL(url);
+    return `${u.origin}${u.pathname}`;
+  } catch {
+    return "<invalid url>";
+  }
+};
+var ECHO_DETECT_MIN_LEN = 16;
+var ECHO_DETECT_MAX_SCAN = 64 * 1024;
+var requestBodyEchoed = (candidate, requestBody) => {
+  if (requestBody === void 0) return false;
+  const asString = typeof requestBody === "string" ? requestBody : new TextDecoder("utf-8", { fatal: false }).decode(
+    requestBody.byteLength > ECHO_DETECT_MAX_SCAN ? requestBody.subarray(0, ECHO_DETECT_MAX_SCAN) : requestBody
+  );
+  if (asString.length < ECHO_DETECT_MIN_LEN) return false;
+  const scanLen = Math.min(asString.length, ECHO_DETECT_MAX_SCAN);
+  for (let i = 0; i + ECHO_DETECT_MIN_LEN <= scanLen; i++) {
+    if (candidate.includes(asString.slice(i, i + ECHO_DETECT_MIN_LEN))) {
+      return true;
+    }
+  }
+  return false;
+};
+var cancelBody2 = (response) => {
+  try {
+    response.body?.cancel().catch(() => {
+    });
+  } catch {
+  }
+};
+var detectPaymentRequirement = async (response) => {
+  if (response.status !== 402) return null;
+  const x402Header = response.headers.get("payment-required") ?? response.headers.get("x-payment-required");
+  if (x402Header) {
+    cancelBody2(response);
+    try {
+      const decoded = JSON.parse(
+        Buffer.from(x402Header, "base64").toString("utf8")
+      );
+      return { protocol: "x402", raw: decoded };
+    } catch {
+      return { protocol: "x402", raw: { encoded: x402Header } };
+    }
+  }
+  const declaredLen = Number.parseInt(
+    response.headers.get("content-length") ?? "",
+    10
+  );
+  const bodyFits = !Number.isFinite(declaredLen) || declaredLen <= MAX_402_PROBE_BYTES;
+  if (bodyFits) {
+    try {
+      const text = await readClippedText(response, MAX_402_PROBE_BYTES);
+      if (text) {
+        const parsed = JSON.parse(text);
+        if (looksLikeX402Body(parsed)) {
+          return { protocol: "x402", raw: parsed };
+        }
+      }
+    } catch {
+    }
+  }
+  const wwwAuth = response.headers.get("www-authenticate");
+  if (wwwAuth) {
+    const schemes = splitWwwAuthenticateChallenges(wwwAuth).map(
+      (challenge) => challenge.trim().split(/\s+/)[0]?.toLowerCase() ?? ""
+    );
+    if (schemes.some((scheme) => MPP_SCHEME_TOKENS.has(scheme))) {
+      cancelBody2(response);
+      return { protocol: "mpp", raw: { "www-authenticate": wwwAuth } };
+    }
+  }
+  cancelBody2(response);
+  return { protocol: "unknown", raw: {} };
+};
+var readClippedBytes = async (response, max) => {
+  if (response.body === null) return new Uint8Array(0);
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (total < max) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {
+    }
+  }
+  const merged = new Uint8Array(Math.min(total, max));
+  let offset = 0;
+  for (const c of chunks) {
+    const take = Math.min(c.byteLength, max - offset);
+    merged.set(c.subarray(0, take), offset);
+    offset += take;
+    if (offset >= max) break;
+  }
+  return merged;
+};
+var readClippedText = async (response, max) => {
+  const bytes = await readClippedBytes(response, max);
+  return new TextDecoder().decode(bytes);
+};
+var parseResponseBody = async (response, max) => {
+  const contentType = response.headers.get("content-type");
+  const bytes = await readClippedBytes(response, max + 1);
+  const truncated = bytes.byteLength > max;
+  const view = truncated ? bytes.subarray(0, max) : bytes;
+  const buf = Buffer.from(view.buffer, view.byteOffset, view.byteLength);
+  if (!isTextContentType(contentType)) {
+    const base64 = buf.toString("base64");
+    return {
+      body: base64,
+      bodyRaw: base64,
+      bodyEncoding: "base64",
+      truncated
+    };
+  }
+  const text = buf.toString("utf8");
+  if (contentType?.toLowerCase().includes("json")) {
+    try {
+      return { body: JSON.parse(text), bodyRaw: text, truncated };
+    } catch {
+    }
+  }
+  return { body: text, bodyRaw: text, truncated };
+};
+var UPSTREAM_ERROR_FIELDS = [
+  "error",
+  "message",
+  "detail",
+  "reason",
+  "error_description"
+];
+var UPSTREAM_ERROR_MAX_LEN = 200;
+var ERROR_SNIPPET_BYTES = 500;
+var clampUpstreamMessage = (value) => {
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  return trimmed.length > UPSTREAM_ERROR_MAX_LEN ? `${trimmed.slice(0, UPSTREAM_ERROR_MAX_LEN)}\u2026` : trimmed;
+};
+var tryParseJson = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+};
+var extractUpstreamErrorMessage = (body) => {
+  const parsed = tryParseJson(body);
+  if (parsed === null || typeof parsed !== "object") {
+    return clampUpstreamMessage(body);
+  }
+  const record = parsed;
+  for (const field of UPSTREAM_ERROR_FIELDS) {
+    const value = record[field];
+    if (typeof value === "string" && value.length > 0) {
+      return clampUpstreamMessage(value);
+    }
+    if (value && typeof value === "object") {
+      const nested = value.message;
+      if (typeof nested === "string" && nested.length > 0) {
+        return clampUpstreamMessage(nested);
+      }
+    }
+  }
+  return void 0;
+};
+var buildUpstreamError = (status, bodyRaw, bodyEncoding) => {
+  if (status >= 200 && status < 300) return void 0;
+  if (bodyRaw === null || bodyRaw.length === 0) return void 0;
+  if (bodyEncoding === "base64") return void 0;
+  const snippet = bodyRaw.slice(0, ERROR_SNIPPET_BYTES);
+  return {
+    status,
+    message: extractUpstreamErrorMessage(bodyRaw),
+    snippetHash: createHash("sha256").update(snippet).digest("hex"),
+    snippetLength: snippet.length
+  };
+};
+var computeOutcome = (status, payment, warnings) => {
+  if (warnings.includes(FETCH_WARNINGS.mppSessionCloseFailed))
+    return "payment_close_failed";
+  if (status === 402 && payment !== null) return "payment_rejected";
+  if (status === 402) return "payment_failed";
+  if (status >= 400) return "server_error";
+  return "success";
+};
+var errorFetchResult = (startedAt, error, skipReason, capabilityIdRequested, outcome, status = null) => {
+  const result = {
+    runId: null,
+    ok: false,
+    status,
+    latencyMs: Date.now() - startedAt,
+    payment: null,
+    outcome,
+    body: null,
+    bodyRaw: null,
+    error
+  };
+  if (capabilityIdRequested) result.runTrackingSkipped = [skipReason];
+  return result;
+};
+var resolveRecordingClient = (client, opts) => {
+  const credentials = client.getCredentials();
+  const recordingClient = opts.account ? client.withAccount(opts.account) : client;
+  const canRecord = opts.account !== void 0 || credentials.kind === "account" || credentials.kind === "session";
+  return { recordingClient, canRecord };
+};
+var recordErrorFetchRun = async (client, opts, result) => {
+  if (opts.capabilityId === void 0) return;
+  const { recordingClient, canRecord } = resolveRecordingClient(client, opts);
+  if (!canRecord) return;
+  try {
+    const created = await recordingClient.runs.create({
+      capabilityId: opts.capabilityId,
+      ...opts.searchId && { searchId: opts.searchId },
+      ...result.status !== null && { status: result.status },
+      latencyMs: result.latencyMs,
+      ...opts.requestSchema && { requestSchema: opts.requestSchema }
+    });
+    result.runId = created.runId;
+    delete result.runTrackingSkipped;
+  } catch {
+  }
+};
+var clientFetch = async (client, url, opts = {}) => {
+  const startedAt = Date.now();
+  const capabilityIdRequested = opts.capabilityId !== void 0;
+  const method = opts.method ?? (opts.body !== void 0 ? "POST" : "GET");
+  const probeHeaders = opts.headers ? { ...opts.headers } : void 0;
+  const requestInit = {
+    method,
+    headers: probeHeaders,
+    body: opts.body,
+    signal: opts.signal
+  };
+  const configuredFetch = buildConfiguredFetch(client, {
+    timeoutMs: opts.timeoutMs
+  });
+  let response;
+  let payment = null;
+  const skipReasons = [];
+  const warnings = [];
+  try {
+    response = await configuredFetch(url, requestInit);
+  } catch (err) {
+    if (err instanceof ZeroError) throw err;
+    const errMessage = err instanceof Error ? err.message : String(err);
+    const result2 = errorFetchResult(
+      startedAt,
+      errMessage,
+      "fetch_failed_before_response",
+      capabilityIdRequested,
+      "network_error"
+    );
+    await recordErrorFetchRun(client, opts, result2);
+    return result2;
+  }
+  if (response.status === 402) {
+    const requirement = await detectPaymentRequirement(response);
+    if (requirement?.protocol === "x402" || requirement?.protocol === "mpp") {
+      const payCall = requirement.protocol === "x402" ? client.payments.pay : client.payments.payMpp;
+      try {
+        const paid = await payCall({
+          url,
+          method,
+          // Fresh clone for the paid retry — same rationale as
+          // the probe-side clone above.
+          headers: opts.headers ? { ...opts.headers } : void 0,
+          body: opts.body,
+          maxPay: opts.maxPay,
+          account: opts.account,
+          signal: opts.signal,
+          timeoutMs: opts.timeoutMs,
+          ...opts.displayCostAmount && {
+            displayCostAmount: opts.displayCostAmount
+          }
+        });
+        response = paid.response;
+        payment = paid.payment;
+        if (paid.warnings) warnings.push(...paid.warnings);
+      } catch (err) {
+        if (err instanceof ZeroSessionCloseFailedError) {
+          response = err.response;
+          payment = {
+            protocol: "mpp",
+            chain: tempoChainLabelFromId(err.session.chainId),
+            txHash: null,
+            amount: err.capturedAmount,
+            asset: "USDC",
+            session: err.session
+          };
+          warnings.push(FETCH_WARNINGS.mppSessionCloseFailed);
+        } else if (err instanceof ZeroPaymentError || err instanceof ZeroAuthError) {
+          const result2 = errorFetchResult(
+            startedAt,
+            err.message,
+            "payment_failed",
+            capabilityIdRequested,
+            "payment_failed",
+            402
+          );
+          await recordErrorFetchRun(client, opts, result2);
+          return result2;
+        } else {
+          throw err;
+        }
+      }
+    } else if (requirement?.protocol === "unknown") {
+      const result2 = errorFetchResult(
+        startedAt,
+        "Capability returned 402 with an unrecognized payment protocol. Neither x402 nor MPP markers were detected in the response headers or body.",
+        "unrecognized_402_protocol",
+        capabilityIdRequested,
+        "payment_failed",
+        402
+      );
+      await recordErrorFetchRun(client, opts, result2);
+      return result2;
+    }
+  }
+  const latencyMs = Date.now() - startedAt;
+  const maxResponseBytes = opts.maxResponseBytes ?? MAX_RESPONSE_BYTES;
+  let body;
+  let bodyRaw;
+  let bodyEncoding;
+  try {
+    const parsed = await parseResponseBody(response, maxResponseBytes);
+    body = parsed.body;
+    bodyRaw = parsed.bodyRaw;
+    bodyEncoding = parsed.bodyEncoding;
+    if (parsed.truncated) warnings.push(FETCH_WARNINGS.bodyTruncated);
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new ZeroApiError("Request aborted by caller", {
+        status: 0,
+        cause: err
+      });
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    const skips = [];
+    const settledLocally = paymentHasAnchor(payment);
+    if (settledLocally && response.status === 402) {
+      warnings.push(FETCH_WARNINGS.paidButStill402NotRecorded);
+      skips.push(FETCH_WARNINGS.paidButStill402NotRecorded);
+    }
+    if (payment !== null && !settledLocally) {
+      warnings.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
+      skips.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
+    }
+    if (payment !== null && payment.amount === "unknown") {
+      warnings.push(FETCH_WARNINGS.paymentAmountUnknown);
+    }
+    skips.push(FETCH_SKIP_REASONS.bodyReadFailed);
+    const result2 = {
+      runId: null,
+      ok: false,
+      status: response.status,
+      latencyMs: Date.now() - startedAt,
+      payment,
+      outcome: computeOutcome(response.status, payment, warnings),
+      body: null,
+      bodyRaw: null,
+      error: message
+    };
+    if (capabilityIdRequested) result2.runTrackingSkipped = skips;
+    if (warnings.length > 0) result2.warnings = warnings;
+    return result2;
+  }
+  const settled = paymentHasAnchor(payment);
+  const paidButStill402 = settled && response.status === 402;
+  const settlementUnconfirmed = payment !== null && !settled;
+  if (paidButStill402) warnings.push(FETCH_WARNINGS.paidButStill402NotRecorded);
+  if (settlementUnconfirmed)
+    warnings.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
+  if (payment !== null && payment.amount === "unknown") {
+    warnings.push(FETCH_WARNINGS.paymentAmountUnknown);
+  }
+  let runId = null;
+  const closeFailed = warnings.includes(FETCH_WARNINGS.mppSessionCloseFailed);
+  const upstreamErrorForRecord = buildUpstreamError(
+    response.status,
+    bodyRaw,
+    bodyEncoding
+  );
+  if (capabilityIdRequested) {
+    if (paidButStill402)
+      skipReasons.push(FETCH_WARNINGS.paidButStill402NotRecorded);
+    else if (closeFailed)
+      skipReasons.push(FETCH_SKIP_REASONS.mppSessionCloseFailedNotRecorded);
+  }
+  if (opts.capabilityId !== void 0 && !paidButStill402 && !closeFailed) {
+    const { recordingClient, canRecord } = resolveRecordingClient(client, opts);
+    if (!canRecord) {
+      skipReasons.push("no_credentials");
+    } else {
+      const knownAmount = payment !== null && payment.amount !== "unknown";
+      try {
+        let derived;
+        if (opts.deriveRunMetadata) {
+          try {
+            derived = opts.deriveRunMetadata({
+              status: response.status,
+              ok: response.ok,
+              bodyRaw,
+              ...bodyEncoding && { bodyEncoding }
+            });
+          } catch {
+          }
+        }
+        const result2 = await recordingClient.runs.create({
+          capabilityId: opts.capabilityId,
+          searchId: opts.searchId,
+          status: response.status,
+          latencyMs,
+          ...opts.requestSchema && { requestSchema: opts.requestSchema },
+          ...derived?.responseSchema && {
+            responseSchema: derived.responseSchema
+          },
+          ...upstreamErrorForRecord && {
+            errorSnippetHash: upstreamErrorForRecord.snippetHash,
+            errorSnippetLength: upstreamErrorForRecord.snippetLength
+          },
+          ...payment && {
+            ...knownAmount && {
+              costAmount: payment.amount,
+              costAsset: payment.asset
+            },
+            paymentProtocol: payment.protocol,
+            paymentChain: payment.chain,
+            paymentTxHash: payment.txHash ?? void 0,
+            paymentMode: payment.session ? "session" : "charge"
+          }
+        });
+        runId = result2.runId;
+      } catch (err) {
+        const errorMessage2 = err instanceof Error ? err.message : String(err);
+        const code = err instanceof ZeroError ? err.code : void 0;
+        const skipMsg = code ? `run_create_failed:${code}: ${errorMessage2}` : `run_create_failed: ${errorMessage2}`;
+        skipReasons.push(skipMsg);
+        client.logger?.({
+          level: "warn",
+          message: "Failed to record run for fetch",
+          meta: {
+            url: redactUrl(url),
+            capabilityId: opts.capabilityId,
+            error: errorMessage2,
+            errorCode: code
+          }
+        });
+      }
+    }
+  }
+  const result = {
+    runId,
+    ok: response.ok,
+    status: response.status,
+    latencyMs,
+    payment,
+    outcome: computeOutcome(response.status, payment, warnings),
+    body,
+    bodyRaw
+  };
+  if (bodyEncoding) result.bodyEncoding = bodyEncoding;
+  if (!response.ok) {
+    const candidate = bodyRaw !== null && bodyRaw.length > 0 && bodyEncoding !== "base64" ? bodyRaw.slice(0, 240) : null;
+    result.error = candidate !== null && !requestBodyEchoed(candidate, opts.body) ? candidate : `HTTP ${response.status}`;
+    if (upstreamErrorForRecord) result.upstreamError = upstreamErrorForRecord;
+  }
+  if (capabilityIdRequested && skipReasons.length > 0) {
+    result.runTrackingSkipped = skipReasons;
+  }
+  if (warnings.length > 0) result.warnings = warnings;
+  return result;
+};
+var searchResultSchema = z.object({
+  id: z.string(),
+  position: z.number(),
+  slug: z.string(),
+  name: z.string(),
+  canonicalName: z.string().nullable().optional(),
+  description: z.string(),
+  whatItDoes: z.string().nullable().optional(),
+  url: z.string(),
+  urlTemplate: z.string().nullable().optional(),
+  cost: z.object({ amount: z.string(), asset: z.string() }),
+  reviewCount: z.number().optional(),
+  rating: ratingSchema,
+  availabilityStatus: z.enum(["healthy", "unknown", "down"]).nullable().optional(),
+  /**
+   * @deprecated The API no longer emits `displayStatus`; it has been replaced
+   * by the consolidated 3-value {@link searchResultSchema.shape.availabilityStatus}.
+   * Kept as an optional field for one release for back-compat (ZERO-89 soft
+   * migration) and will be removed in the next major version.
+   */
+  displayStatus: z.enum(["healthy", "stable", "degraded", "unhealthy", "unknown"]).optional()
+});
+var searchResponseSchema = z.object({
+  searchId: z.string(),
+  total: z.number().optional().default(0),
+  offset: z.number().optional().default(0),
+  hasMore: z.boolean().optional().default(false),
+  capabilities: z.array(searchResultSchema)
+});
+
+// src/client.ts
+var normalizeCredentials = (session, account) => {
+  if (session && account) {
+    throw new ZeroConfigurationError(
+      "ClientOptions accepts at most one of `session` or `account`, not both. The two auth modes are non-composable."
+    );
+  }
+  if (session) {
+    return {
+      kind: "session",
+      accessToken: session.accessToken,
+      refreshToken: session.refreshToken,
+      onRefreshed: session.onRefreshed ?? noopRefresh
+    };
+  }
+  if (account) {
+    return { kind: "account", account };
+  }
+  return { kind: "none" };
+};
+var ZeroClient = class _ZeroClient {
+  baseUrl;
+  timeout;
+  maxRetries;
+  apiVersion;
+  defaultHeaders;
+  fetchImpl;
+  fetchOptions;
+  logger;
+  // Private — read via getCredentials(), mutate only via applyRefreshedTokens().
+  // Keeping a single mutator funnel is what lets the transport replay
+  // requests with a fresh access token after a 401 → refresh.
+  credentials;
+  // Shared in-flight refresh promise. When N concurrent requests all 401 on
+  // an expired access token, only the first triggers the network refresh;
+  // the rest await the same promise. Without this dedup, the first refresh
+  // rotates the refresh token, the rest present the now-revoked token, and
+  // the server (RFC 6819) treats that as token theft and kills the entire
+  // session family. Cleared in finally() so the NEXT expiry can refresh
+  // again.
+  refreshInFlight = null;
+  // First paid call hits /v1/users/me/wallets to find the wallet; cached after.
+  // Gen counter handles the logout race; AC owns /me's signal so it's
+  // decoupled from any single caller and clearManagedAccount can abort it.
+  managedAccount = null;
+  managedAccountInFlight = null;
+  managedAccountAC = null;
+  managedAccountGen = 0;
+  // Multi-tenant servers calling `client.fetch(url, { account: tenantAccount })`
+  // on every request would otherwise construct a new ZeroClient (with
+  // five namespace instances) per call. Keyed by lowercased account
+  // address so equivalent accounts hit the same sub-client.
+  //
+  // Shared across base + sub-clients so `base.clearAccountCache()`
+  // reaches sub-fragments (e.g. `base.withAccount(a).withAccount(b)`).
+  // Without sharing, those fragments leak past base.clearAccountCache().
+  //
+  // Lifetime = base client's lifetime. Sub-clients hold a reference back
+  // to their account via `credentials.account`, so even a WeakMap variant
+  // could not GC entries until the base client is dropped. Long-running
+  // multi-tenant servers should call `clearAccountCache(account?)` on
+  // tenant churn to release per-tenant memory.
+  withAccountCache;
+  // Namespace surfaces. Eagerly instantiated in the constructor because they
+  // hold only a reference to `this` — no heavy work happens until a method
+  // is called. Lazy getters would tree-shake better but break the discoverable
+  // `client.<tab>` ergonomics that make resource-namespaced SDKs pleasant.
+  auth;
+  bugReports;
+  capabilities;
+  payments;
+  runs;
+  wallet;
+  refreshOverride;
+  constructor(options = {}) {
+    this.credentials = normalizeCredentials(options.session, options.account);
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.apiVersion = options.apiVersion;
+    this.defaultHeaders = options.defaultHeaders ?? {};
+    this.fetchImpl = options.fetch ?? ((...args) => globalThis.fetch(...args));
+    this.fetchOptions = options.fetchOptions;
+    this.logger = options.logger;
+    this.refreshOverride = options.refresh;
+    this.withAccountCache = options._sharedAccountCache ?? /* @__PURE__ */ new Map();
+    this.auth = new Auth(this);
+    this.bugReports = new BugReports(this);
+    this.capabilities = new Capabilities(this);
+    this.payments = new Payments(this);
+    this.runs = new Runs(this);
+    this.wallet = new Wallet(this);
+  }
+  // Convenience factory: derives a viem account from a raw 0x-prefixed
+  // private key and constructs a client in account mode. Equivalent to
+  // `new ZeroClient({ account: privateKeyToAccount(pk), ...opts })`.
+  static fromPrivateKey = (privateKey, opts = {}) => new _ZeroClient({ ...opts, account: privateKeyToAccount(privateKey) });
+  // Convenience factory: derives a viem account from a BIP-39 mnemonic and
+  // constructs a client in account mode. The default derivation path is
+  // viem's default (m/44'/60'/0'/0/0).
+  static fromMnemonic = (mnemonic, opts = {}) => new _ZeroClient({ ...opts, account: mnemonicToAccount(mnemonic) });
+  /**
+   * @internal
+   *
+   * Live credential accessor for transport + auth modules. Returns the
+   * discriminated union (not a snapshot) so auth-dispatch always sees the
+   * freshest access token after rotation. Exposed publicly only to bridge
+   * the SDK's module boundary — consumers should not call this directly,
+   * and the shape is not part of the stable surface.
+   */
+  getCredentials = () => this.credentials;
+  /**
+   * @internal
+   *
+   * Single in-flight refresh helper. Concurrent callers share one
+   * invocation. Used by the transport's 401 path; consumers should call
+   * `client.auth.refresh()` for explicit rotation.
+   *
+   * Only the FIRST caller's signal participates in the in-flight
+   * refresh — combining signals retroactively isn't possible.
+   */
+  refreshSessionOnce = (signal) => {
+    if (!this.refreshInFlight) {
+      const refresh = this.refreshOverride ? this.runRefreshOverride(this.refreshOverride, signal) : tryRefreshSession(this, signal);
+      this.refreshInFlight = refresh.finally(() => {
+        this.refreshInFlight = null;
+      });
+    }
+    return this.refreshInFlight;
+  };
+  runRefreshOverride = async (fn, signal) => {
+    const credentials = this.credentials;
+    if (credentials.kind !== "session") return false;
+    let result;
+    try {
+      result = await fn(signal);
+    } catch {
+      return false;
+    }
+    if (!result) return false;
+    await this.applyRefreshedTokens(result);
+    return true;
+  };
+  // The single mutation funnel for credential rotation. Updates the
+  // in-memory tokens first, then awaits the consumer's persistence callback.
+  // Callback errors are caught and routed to client.logger if present, but
+  // do NOT propagate — a persistence failure is not a network error and
+  // must not trigger the transport's retry loop. The in-memory tokens are
+  // still considered the source of truth for the current process.
+  applyRefreshedTokens = async (next) => {
+    if (this.credentials.kind !== "session") return;
+    this.credentials = {
+      ...this.credentials,
+      accessToken: next.accessToken,
+      refreshToken: next.refreshToken
+    };
+    try {
+      await this.credentials.onRefreshed(next);
+    } catch (error) {
+      this.logger?.({
+        level: "error",
+        message: "onRefreshed callback threw \u2014 tokens rotated in-memory but consumer persistence failed. The current process will use the new tokens; a process restart may replay a stale refresh token.",
+        meta: {
+          error: error instanceof Error ? error.message : String(error)
+        }
+      });
+    }
+  };
+  // Silent setter for sibling-client sync: updates in-memory tokens without
+  // firing onRefreshed (which would recurse if both clients share a
+  // callback). No-op outside session mode.
+  setSessionTokens = (tokens) => {
+    if (this.credentials.kind !== "session") return;
+    this.credentials = {
+      ...this.credentials,
+      accessToken: tokens.accessToken,
+      refreshToken: tokens.refreshToken
+    };
+  };
+  // Returns a new client bound to a different session, inheriting
+  // transport config but with its own credential slot. Refreshes on the
+  // sub-client never mutate the base — critical for multi-tenant servers
+  // where one tenant's expired token must not cascade to others.
+  //
+  // withSession is a trust boundary: it does NOT share the base's
+  // withAccount cache. Sharing would let the first sibling's transport
+  // snapshot (headers/fetchOptions/logger) leak to every later sibling
+  // calling withAccount(a) for the same address. withSession is also
+  // not itself cached — sessions are typically one-per-request, and
+  // caching by token would keep secrets in memory longer than needed.
+  withSession = (session) => new _ZeroClient({
+    session,
+    baseUrl: this.baseUrl,
+    timeout: this.timeout,
+    maxRetries: this.maxRetries,
+    apiVersion: this.apiVersion,
+    defaultHeaders: { ...this.defaultHeaders },
+    fetch: this.fetchImpl,
+    fetchOptions: this.fetchOptions ? { ...this.fetchOptions } : void 0,
+    logger: this.logger
+  });
+  // Returns a new client bound to a different viem account. Mirrors
+  // withSession for the self-custody auth path — multi-tenant servers
+  // holding many private keys get isolated signing state without
+  // sharing namespace caches (e.g., the Wallet namespace's per-instance
+  // public RPC clients).
+  //
+  // Sub-clients are cached per account address (see `withAccountCache`
+  // above for the lifetime). Call `clearAccountCache()` on tenant churn.
+  //
+  // `defaultHeaders` and `fetchOptions` are SHALLOW SNAPSHOTS taken at
+  // sub-client construction:
+  //   - Mutating them on a SUB-client persists across cached calls for
+  //     the same account (use `opts.headers` per call instead).
+  //   - Mutating them on the BASE post-construction does NOT reach
+  //     already-cached sub-clients. A caller that swaps an
+  //     `x-zero-api-version` header on the base for a rollout would
+  //     silently miss every cached tenant. Rebuild the base + sub-cache
+  //     to apply such changes uniformly, or pass `opts.headers` per call.
+  // This snapshot concern is orthogonal to 401 refresh: account-mode
+  // sub-clients have no session tokens to refresh, and session refresh
+  // mutates `credentials` (not `defaultHeaders` / `fetchOptions`) via the
+  // `applyRefreshedTokens` funnel.
+  //
+  // Cache invalidates on signer rotation (same address, new
+  // LocalAccount object) so a rotated signer doesn't silently keep
+  // signing as the old one. Multi-tenant servers using a KMS/vault
+  // pattern that constructs a fresh LocalAccount per request should
+  // hoist the LocalAccount to a per-tenant cache to preserve cache
+  // hit rate — re-deriving the account each call defeats the cache
+  // by design (we cannot tell from outside whether the signing
+  // function is equivalent).
+  withAccount = (account) => {
+    const key = account.address.toLowerCase();
+    const cached = this.withAccountCache.get(key);
+    if (cached) {
+      const cachedCreds = cached.getCredentials();
+      if (cachedCreds.kind === "account" && cachedCreds.account === account) {
+        return cached;
+      }
+    }
+    const sub = new _ZeroClient({
+      account,
+      baseUrl: this.baseUrl,
+      timeout: this.timeout,
+      maxRetries: this.maxRetries,
+      apiVersion: this.apiVersion,
+      defaultHeaders: { ...this.defaultHeaders },
+      fetch: this.fetchImpl,
+      fetchOptions: this.fetchOptions ? { ...this.fetchOptions } : void 0,
+      logger: this.logger,
+      _sharedAccountCache: this.withAccountCache
+    });
+    this.withAccountCache.set(key, sub);
+    return sub;
+  };
+  /**
+   * Evict cached `withAccount` sub-clients. Pass an account to drop a
+   * single tenant's entry; omit the argument to clear the entire cache.
+   * Call on tenant churn (session expiry, deprovisioning) — without
+   * eviction the cache grows for the base client's lifetime.
+   */
+  clearAccountCache = (account) => {
+    if (account) {
+      this.withAccountCache.delete(account.address.toLowerCase());
+      return;
+    }
+    this.withAccountCache.clear();
+  };
+  /** @internal — used by payments.pay() in session mode. Cached, dedupes concurrent lookups. */
+  resolveManagedAccount = (signal) => {
+    if (this.managedAccount) return Promise.resolve(this.managedAccount);
+    if (this.managedAccountInFlight) {
+      return this.raceWithSignal(this.managedAccountInFlight, signal);
+    }
+    if (this.credentials.kind !== "session") {
+      return Promise.reject(
+        new ZeroAuthError(
+          "auth_no_credentials",
+          "resolveManagedAccount() requires session credentials."
+        )
+      );
+    }
+    const startedAtGen = this.managedAccountGen;
+    const ac = new AbortController();
+    this.managedAccountAC = ac;
+    this.managedAccountInFlight = (async () => {
+      const wallets = await this.auth.wallets({ signal: ac.signal });
+      const primary = wallets.find((w) => w.isPrimary && w.source === "privy_embedded") ?? wallets.find((w) => w.source === "privy_embedded");
+      if (!primary) {
+        throw new ZeroAuthError(
+          "auth_error",
+          "Session user has no Privy-embedded wallet provisioned. Managed signing requires one. Construct the client with `account` to sign locally instead."
+        );
+      }
+      if (this.managedAccountGen !== startedAtGen) {
+        throw new ZeroAuthError(
+          "auth_session_expired",
+          "Session cleared during managed-account resolution. Retry to rebuild against the current session."
+        );
+      }
+      const acc = createManagedAccount(this, getAddress(primary.walletAddress));
+      this.managedAccount = acc;
+      return acc;
+    })().finally(() => {
+      if (this.managedAccountGen === startedAtGen) {
+        this.managedAccountInFlight = null;
+        this.managedAccountAC = null;
+      }
+    });
+    return this.raceWithSignal(this.managedAccountInFlight, signal);
+  };
+  // Per-caller signal gate: each caller can reject on their own abort
+  // without cancelling the shared underlying promise.
+  raceWithSignal = (p, signal) => {
+    if (!signal) return p;
+    const abortErr = (cause) => new ZeroApiError("Request aborted by caller", { status: 0, cause });
+    if (signal.aborted)
+      return Promise.reject(
+        abortErr(new DOMException("Aborted", "AbortError"))
+      );
+    return new Promise((resolve, reject) => {
+      const onAbort = () => reject(abortErr(new DOMException("Aborted", "AbortError")));
+      signal.addEventListener("abort", onAbort, { once: true });
+      p.then(
+        (v) => {
+          signal.removeEventListener("abort", onAbort);
+          resolve(v);
+        },
+        (e) => {
+          signal.removeEventListener("abort", onAbort);
+          reject(e);
+        }
+      );
+    });
+  };
+  /** Drop the cached managed-signing account and abort any in-flight /me lookup. */
+  clearManagedAccount = () => {
+    this.managedAccount = null;
+    this.managedAccountAC?.abort();
+    this.managedAccountInFlight = null;
+    this.managedAccountAC = null;
+    this.managedAccountGen++;
+  };
+  /** @internal — Read cached managed account without triggering resolution. */
+  peekManagedAccount = () => this.managedAccount;
+  // `search` is a flat method, not a namespace — it's the hot path most
+  // consumers hit first, and Stripe/Anthropic/OpenAI all keep their primary
+  // entry point flat for the same reason.
+  search = (query, opts = {}) => {
+    const { signal, ...rest } = opts;
+    return request(
+      this,
+      {
+        method: "POST",
+        path: "/v1/search",
+        body: { query, ...rest },
+        signal
+      },
+      searchResponseSchema
+    );
+  };
+  // Paid fetch — search → get → fetch is Zero's canonical loop. The hot
+  // path is flat on the client, same rationale as `search` above.
+  // Orchestration lives in fetch.ts so this class stays readable.
+  fetch = (url, opts = {}) => clientFetch(this, url, opts);
+  // No-op today. Reserved for an explicit drain/cancel handle once
+  // long-running consumers need one — do NOT rely on this to abort
+  // in-flight requests or flush recording. Consumers needing
+  // shutdown semantics should manage their own AbortController.
+  close = async () => {
+  };
+};
+
+export { Auth, AuthDevice, BUG_REPORT_CATEGORIES, BugReports, Capabilities, DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT_MS, FETCH_SKIP_REASONS, FETCH_WARNINGS, Payments, Runs, SDK_VERSION, TEMPO_CHAIN_ID, TEMPO_TESTNET_CHAIN_ID, Wallet, ZeroApiError, ZeroAuthError, ZeroClient, ZeroConfigurationError, ZeroError, ZeroPaymentError, ZeroSessionCloseFailedError, ZeroTimeoutError, ZeroValidationError, ZeroWalletError, coerceTempoChainId, createManagedAccount, paymentHasAnchor, tempoChainLabelFromId };
+//# sourceMappingURL=chunk-XQEHJX2X.js.map
+//# sourceMappingURL=chunk-XQEHJX2X.js.map