{"version":3,"sources":["../src/errors.ts","../src/rate-limiter.ts","../src/retry.ts","../src/oauth.ts","../src/telemetry.ts","../src/client.ts","../src/testing.ts"],"names":["ArAgentsError","sleep"],"mappings":"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","file":"testing.cjs","sourcesContent":["// Typed errors for `@ar-agents/mercadolibre`. All client failures funnel\n// through one of these so consumers can `if (err instanceof MeliApiError)`\n// without parsing strings.\n//\n// `MeliError` extends `ArAgentsError` from `@ar-agents/core` so the\n// family contract (code / retryable / context) is uniform across every\n// `@ar-agents/*` integration.\n\nimport { ArAgentsError } from \"@ar-agents/core\";\n\n/** Common base. */\nexport abstract class MeliError extends ArAgentsError {\n  abstract override readonly code: string;\n  constructor(message: string, init: { retryable?: boolean; context?: Record<string, unknown>; cause?: unknown } = {}) {\n    super(message, {\n      code: \"meli_error\",\n      retryable: init.retryable ?? false,\n      context: init.context ?? {},\n      cause: init.cause,\n    });\n    this.name = this.constructor.name;\n  }\n}\n\n/** Shape of MELI's typical error envelope. The fields are not guaranteed —\n *  legacy endpoints sometimes use `{ status, message }` only, and some\n *  post-purchase routes return `{ error_code, description }`. We extract\n *  both shapes opportunistically. */\nexport interface MeliErrorBody {\n  /** MELI's machine-readable error slug (e.g., \"rate_limited\",\n   *  \"forbidden\", \"validation_error\"). */\n  error?: string;\n  /** Human-readable message MELI returns alongside `error`. */\n  message?: string;\n  /** Echoed status code (some MELI endpoints duplicate it in the body). */\n  status?: number;\n  /** Multi-issue causes — typically array of `{ code, message }` for\n   *  validation failures on `createItem` / `updateItem`. */\n  cause?: Array<{ code?: string | number; message?: string; [k: string]: unknown }>;\n}\n\n/** A MELI API call returned a non-2xx after retries are exhausted. */\nexport class MeliApiError extends MeliError {\n  readonly code = \"meli_api_error\";\n  /** MELI's error slug if present (`error` field on the body). Stable +\n   *  documented; safe to switch on in your code. */\n  readonly meliCode: string | null;\n  /** MELI's human-readable error message if present. */\n  readonly meliMessage: string | null;\n  /** Multi-issue causes (validation failures usually). */\n  readonly meliCauses: ReadonlyArray<{\n    code?: string | number;\n    message?: string;\n    [k: string]: unknown;\n  }>;\n\n  constructor(\n    message: string,\n    public readonly status: number,\n    public readonly url: string,\n    public readonly body: unknown,\n    public readonly requestId?: string,\n  ) {\n    super(message);\n    const parsed = parseMeliErrorBody(body);\n    this.meliCode = parsed.error ?? null;\n    this.meliMessage = parsed.message ?? null;\n    this.meliCauses = parsed.cause ?? [];\n  }\n\n  /** Back-compat — same as `meliCode`. New code should read `meliCode` directly. */\n  meliErrorCode(): string | null {\n    return this.meliCode;\n  }\n\n  /**\n   * True if MELI explicitly told us this was a rate-limit hit\n   * (vs. a 429 with no body, or a 5xx). Use this to drive a longer backoff\n   * in your retry loop.\n   */\n  isRateLimited(): boolean {\n    return this.status === 429 || this.meliCode === \"rate_limited\";\n  }\n\n  /**\n   * True if the request hit the seller's permission boundary — typically\n   * because the bearer token doesn't own the resource being addressed.\n   * Don't retry; surface to the user.\n   */\n  isForbidden(): boolean {\n    return this.status === 403 || this.meliCode === \"forbidden\";\n  }\n\n  /**\n   * True if MELI says this access_token is invalid / expired.\n   * The OAuth flow's `ensureAccessToken` should be re-driven before retrying.\n   */\n  isUnauthorized(): boolean {\n    return this.status === 401 || this.meliCode === \"unauthorized\" || this.meliCode === \"invalid_token\";\n  }\n\n  /** True if MELI's body identifies this as validation-failure on inputs. */\n  isValidationError(): boolean {\n    return this.meliCode === \"validation_error\" || this.status === 400;\n  }\n}\n\n/** Best-effort parse of MELI's error envelope. Tolerates missing fields\n *  and the post-purchase `{ error_code, description }` variant. */\nfunction parseMeliErrorBody(body: unknown): MeliErrorBody {\n  if (!body || typeof body !== \"object\") return {};\n  const b = body as Record<string, unknown>;\n  const out: MeliErrorBody = {};\n  if (typeof b[\"error\"] === \"string\") out.error = b[\"error\"];\n  else if (typeof b[\"error_code\"] === \"string\") out.error = b[\"error_code\"];\n  if (typeof b[\"message\"] === \"string\") out.message = b[\"message\"];\n  else if (typeof b[\"description\"] === \"string\") out.message = b[\"description\"];\n  if (typeof b[\"status\"] === \"number\") out.status = b[\"status\"];\n  if (Array.isArray(b[\"cause\"])) {\n    out.cause = b[\"cause\"].filter(\n      (c): c is { code?: string | number; message?: string } =>\n        typeof c === \"object\" && c !== null,\n    );\n  }\n  return out;\n}\n\n/** OAuth-related failure (token refresh, callback, etc.). */\nexport class MeliAuthError extends MeliError {\n  readonly code = \"meli_auth_error\";\n  constructor(\n    message: string,\n    public override readonly cause?: unknown,\n  ) {\n    super(message);\n  }\n}\n\n/** Rate limit hit and retries are exhausted. */\nexport class MeliRateLimitError extends MeliError {\n  readonly code = \"meli_rate_limit\";\n  constructor(\n    public readonly retryAfterSeconds: number,\n    public readonly url: string,\n  ) {\n    super(\n      `MELI rate limit exhausted on ${url}; retry in ${retryAfterSeconds}s`,\n    );\n  }\n}\n\n/** The host's network failed (DNS, TLS, fetch threw). */\nexport class MeliNetworkError extends MeliError {\n  readonly code = \"meli_network_error\";\n  constructor(\n    message: string,\n    public override readonly cause?: unknown,\n  ) {\n    super(message);\n  }\n}\n\n/** A response body failed Zod validation. */\nexport class MeliValidationError extends MeliError {\n  readonly code = \"meli_validation_error\";\n  constructor(\n    message: string,\n    public readonly issues: unknown,\n  ) {\n    super(message);\n  }\n}\n\n/** Webhook signature verification failed (where ML supports it). */\nexport class MeliWebhookError extends MeliError {\n  readonly code = \"meli_webhook_error\";\n  constructor(\n    public readonly detail:\n      | \"missing_topic\"\n      | \"missing_resource\"\n      | \"unknown_topic\"\n      | \"malformed_body\"\n      | \"missed_feeds_unauthorized\",\n    message: string,\n  ) {\n    super(message);\n  }\n}\n\n/** Convenience type guard. */\nexport function isMeliError(e: unknown): e is MeliError {\n  return e instanceof MeliError;\n}\n","// Per-seller token-bucket rate limiter.\n//\n// MELI documents 1500 req/min/seller (≈25 req/s). We default to 24/s with\n// a burst of 60 to leave headroom for retries + concurrent requests.\n// Each acquire() returns a promise that resolves when a token is available.\n//\n// In-memory only. Cross-process deployments should swap with a Redis-\n// backed token bucket (the interface is intentionally tiny so a Redis\n// adapter is ~30 LOC).\n\nexport interface RateLimiter {\n  /**\n   * Acquire 1 token. Resolves when granted (immediately if burst capacity\n   * is available, otherwise after a delay).\n   *\n   * @param scope Independently-throttled bucket key (typically `seller:${id}`).\n   */\n  acquire(scope: string): Promise<void>;\n}\n\nexport interface TokenBucketOptions {\n  /** Tokens per second refill. Default 24 (≈1440 req/min). */\n  refillPerSecond?: number;\n  /** Max burst (bucket capacity). Default 60. */\n  burst?: number;\n  /** Override \"now\" for tests. Returns ms. */\n  now?: () => number;\n  /** Evict buckets idle for more than this many ms. Default 600_000 (10 min).\n   *  Set to 0 to disable GC (useful in tests). */\n  idleEvictMs?: number;\n}\n\ninterface Bucket {\n  tokens: number;\n  lastRefillMs: number;\n}\n\nexport class TokenBucketRateLimiter implements RateLimiter {\n  private readonly buckets = new Map<string, Bucket>();\n  private readonly refillPerSecond: number;\n  private readonly burst: number;\n  private readonly now: () => number;\n  private readonly idleEvictMs: number;\n  /** Counter — every N acquires we sweep idle buckets. */\n  private acquireSinceLastSweep = 0;\n  private static readonly SWEEP_EVERY_N_ACQUIRES = 256;\n\n  constructor(options: TokenBucketOptions = {}) {\n    this.refillPerSecond = options.refillPerSecond ?? 24;\n    this.burst = options.burst ?? 60;\n    this.now = options.now ?? (() => Date.now());\n    this.idleEvictMs = options.idleEvictMs ?? 600_000;\n  }\n\n  async acquire(scope: string): Promise<void> {\n    this.maybeSweep();\n    while (true) {\n      const ms = this.now();\n      const bucket = this.refill(scope, ms);\n      if (bucket.tokens >= 1) {\n        bucket.tokens -= 1;\n        return;\n      }\n      const deficitTokens = 1 - bucket.tokens;\n      const waitMs = Math.ceil((deficitTokens / this.refillPerSecond) * 1000);\n      await sleep(waitMs);\n    }\n  }\n\n  /** Inspect tokens (for tests/diagnostics). */\n  inspect(scope: string): { tokens: number } {\n    const bucket = this.refill(scope, this.now());\n    return { tokens: bucket.tokens };\n  }\n\n  /** Number of currently-tracked buckets. Diagnostics only. */\n  bucketCount(): number {\n    return this.buckets.size;\n  }\n\n  /** Force-evict buckets that have been idle longer than `idleEvictMs`.\n   *  We don't bother checking token count — recreating an idle bucket\n   *  later is essentially free (one Map.set + one allocation), and any\n   *  bucket that's been idle for >10 min has long since refilled to burst\n   *  anyway. */\n  sweepIdleBuckets(now = this.now()): number {\n    if (this.idleEvictMs === 0) return 0;\n    let evicted = 0;\n    for (const [scope, bucket] of this.buckets) {\n      if (now - bucket.lastRefillMs > this.idleEvictMs) {\n        this.buckets.delete(scope);\n        evicted++;\n      }\n    }\n    return evicted;\n  }\n\n  private maybeSweep(): void {\n    if (this.idleEvictMs === 0) return;\n    this.acquireSinceLastSweep++;\n    if (this.acquireSinceLastSweep < TokenBucketRateLimiter.SWEEP_EVERY_N_ACQUIRES) return;\n    this.acquireSinceLastSweep = 0;\n    this.sweepIdleBuckets();\n  }\n\n  private refill(scope: string, ms: number): Bucket {\n    let bucket = this.buckets.get(scope);\n    if (!bucket) {\n      bucket = { tokens: this.burst, lastRefillMs: ms };\n      this.buckets.set(scope, bucket);\n      return bucket;\n    }\n    const elapsedSeconds = (ms - bucket.lastRefillMs) / 1000;\n    bucket.tokens = Math.min(\n      this.burst,\n      bucket.tokens + elapsedSeconds * this.refillPerSecond,\n    );\n    bucket.lastRefillMs = ms;\n    return bucket;\n  }\n}\n\nfunction sleep(ms: number): Promise<void> {\n  if (ms <= 0) return Promise.resolve();\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/** No-op limiter for tests / when you want to bypass throttling entirely. */\nexport class NoopRateLimiter implements RateLimiter {\n  async acquire(): Promise<void> {}\n}\n","// Exponential-backoff retry helper.\n//\n// Retries on 5xx + 429 + network errors. Honors `Retry-After` when present\n// (seconds or HTTP-date). Configurable max attempts + base delay. Adds\n// jitter so concurrent failures don't synchronize.\n\nexport interface RetryOptions {\n  /** Max attempts (including the first). Default 4. */\n  maxAttempts?: number;\n  /** Base delay in ms before the first retry. Default 200. */\n  baseDelayMs?: number;\n  /** Max delay between retries in ms. Default 8000. */\n  maxDelayMs?: number;\n  /** Jitter factor 0..1. Default 0.3 (±30%). */\n  jitter?: number;\n  /** Custom callback fired before each retry. */\n  onRetry?: (attempt: number, lastError: unknown) => void;\n}\n\nconst DEFAULTS = {\n  maxAttempts: 4,\n  baseDelayMs: 200,\n  maxDelayMs: 8000,\n  jitter: 0.3,\n} as const;\n\nexport interface RetryDecision {\n  shouldRetry: boolean;\n  /** Override delay (e.g. from Retry-After header). */\n  delayMsOverride?: number;\n}\n\nexport interface RetryContext {\n  /** HTTP method of the request being attempted, uppercase. Default \"GET\". */\n  method?: string;\n  /** Attempt number (1-based). */\n  attempt?: number;\n}\n\n/** A function that decides whether a thrown error / response is retryable. */\nexport type RetryClassifier = (\n  error: unknown,\n  response: Response | null,\n  ctx?: RetryContext,\n) => RetryDecision;\n\n/** HTTP methods that are safe to retry by default (RFC 9110 idempotent set). */\nconst IDEMPOTENT_METHODS = new Set([\"GET\", \"HEAD\", \"OPTIONS\", \"PUT\", \"DELETE\"]);\n\n/** Parse a `Retry-After` header value: integer seconds OR HTTP-date. */\nfunction parseRetryAfter(value: string): number | null {\n  const seconds = Number.parseInt(value, 10);\n  if (Number.isFinite(seconds)) return seconds * 1000;\n  const dateMs = Date.parse(value);\n  if (Number.isFinite(dateMs)) return Math.max(0, dateMs - Date.now());\n  return null;\n}\n\n/**\n * Default classifier — retry on 5xx, 429, network errors. By default,\n * **only retries idempotent methods** (GET/HEAD/OPTIONS/PUT/DELETE). POST\n * and PATCH are NOT retried because MELI's gateway can persist a request\n * after a 5xx (split-brain), which would create duplicate listings,\n * double-answers, or duplicate promo opt-ins on retry.\n *\n * Callers who know their POST endpoint is idempotent (or who supply an\n * `X-Idempotency-Key` header) can override via `retryClassifier`.\n */\nexport const defaultRetryClassifier: RetryClassifier = (error, response, ctx) => {\n  const method = ctx?.method?.toUpperCase() ?? \"GET\";\n  const methodIsIdempotent = IDEMPOTENT_METHODS.has(method);\n\n  if (response) {\n    if (response.status === 429) {\n      const retryAfter = response.headers.get(\"Retry-After\");\n      if (retryAfter) {\n        const delayMs = parseRetryAfter(retryAfter);\n        if (delayMs !== null) {\n          return { shouldRetry: true, delayMsOverride: delayMs };\n        }\n      }\n      // 429 is safe to retry on any method (request hadn't been processed).\n      return { shouldRetry: true };\n    }\n    if (response.status >= 500 && response.status < 600) {\n      // 5xx is split-brain risky: only retry idempotent verbs.\n      return { shouldRetry: methodIsIdempotent };\n    }\n    return { shouldRetry: false };\n  }\n  // Network-level failure (fetch threw, AbortError, etc.)\n  if (error instanceof Error) {\n    if (error.name === \"AbortError\") return { shouldRetry: false };\n    // Network errors are safe to retry on idempotent methods. For non-\n    // idempotent ones we have no way to know if the server got the request,\n    // so we err on the side of \"fail loud.\"\n    return { shouldRetry: methodIsIdempotent };\n  }\n  return { shouldRetry: false };\n};\n\n/**\n * Run an async operation with exponential backoff. The operation receives\n * the current attempt number (1-based) and is expected to either resolve\n * with a value or throw. The classifier decides whether to retry.\n *\n * For HTTP, prefer the `fetchWithRetry` helper instead — it composes this\n * with response inspection.\n */\nexport async function withRetry<T>(\n  op: (attempt: number) => Promise<T>,\n  classifier: RetryClassifier = defaultRetryClassifier,\n  options: RetryOptions = {},\n  ctx: RetryContext = {},\n): Promise<T> {\n  const opts = { ...DEFAULTS, ...options };\n  let lastError: unknown = null;\n  for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {\n    try {\n      return await op(attempt);\n    } catch (err) {\n      lastError = err;\n      const response = (err as { response?: Response }).response ?? null;\n      const decision = classifier(err, response, { ...ctx, attempt });\n      if (!decision.shouldRetry || attempt === opts.maxAttempts) {\n        throw err;\n      }\n      const delay =\n        decision.delayMsOverride ??\n        computeBackoffMs(attempt, opts.baseDelayMs, opts.maxDelayMs, opts.jitter);\n      opts.onRetry?.(attempt, err);\n      await sleep(delay);\n    }\n  }\n  throw lastError;\n}\n\n/**\n * Variant of `withRetry` specialized for `fetch`. The op MUST return the\n * `Response`, NOT throw on 4xx/5xx — this helper inspects the response\n * status itself. Network errors (fetch throwing) are retried per the\n * classifier.\n */\nexport async function fetchWithRetry(\n  url: string,\n  init: RequestInit,\n  options: RetryOptions = {},\n  classifier: RetryClassifier = defaultRetryClassifier,\n  fetchImpl: typeof fetch = fetch,\n): Promise<Response> {\n  const method = (init.method ?? \"GET\").toUpperCase();\n  const ctx: RetryContext = { method };\n  return withRetry(\n    async () => {\n      const response = await fetchImpl(url, init);\n      const decision = classifier(null, response, ctx);\n      if (decision.shouldRetry) {\n        const synthetic = new Error(`HTTP ${response.status} ${response.statusText}`);\n        (synthetic as { response?: Response }).response = response;\n        throw synthetic;\n      }\n      return response;\n    },\n    classifier,\n    options,\n    ctx,\n  );\n}\n\nfunction computeBackoffMs(\n  attempt: number,\n  base: number,\n  max: number,\n  jitter: number,\n): number {\n  const exp = Math.min(max, base * 2 ** (attempt - 1));\n  const j = exp * jitter * (Math.random() * 2 - 1);\n  return Math.max(0, Math.floor(exp + j));\n}\n\nexport function sleep(ms: number): Promise<void> {\n  if (ms <= 0) return Promise.resolve();\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n","// MELI OAuth 2.0 — auth code + refresh token flows.\n//\n// Critical landmines this module defends against (verified during research):\n//\n//   1. **Refresh tokens are SINGLE-USE.** Each refresh rotates the\n//      `refresh_token`. If two workers race a refresh with the same old\n//      token, MELI revokes the application's connection (`refresh_token_reused`).\n//      We mutex per-seller so concurrent token reads coalesce.\n//\n//   2. **Refresh tokens expire after 4 months of inactivity.** We expose\n//      this as a typed error so the caller can re-prompt the seller for\n//      OAuth consent gracefully.\n//\n//   3. **Multi-site OAuth callbacks must use a single redirect host.**\n//      The MLA / MLB / MLM / MLC apps share callback URLs.\n//\n//   4. **`offline_access` scope is required** to receive a refresh token\n//      at all. Without it, access_token-only flows expire in 6 hours and\n//      can't be renewed.\n\nimport { MeliAuthError } from \"./errors\";\n\nconst TOKEN_URL = \"https://api.mercadolibre.com/oauth/token\";\nconst AUTHORIZATION_URL_BY_SITE: Record<string, string> = {\n  MLA: \"https://auth.mercadolibre.com.ar/authorization\",\n  MLB: \"https://auth.mercadolivre.com.br/authorization\",\n  MLM: \"https://auth.mercadolibre.com.mx/authorization\",\n  MLC: \"https://auth.mercadolibre.cl/authorization\",\n  MCO: \"https://auth.mercadolibre.com.co/authorization\",\n  MLU: \"https://auth.mercadolibre.com.uy/authorization\",\n  MPE: \"https://auth.mercadolibre.com.pe/authorization\",\n};\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport interface OAuthAppCredentials {\n  clientId: string;\n  clientSecret: string;\n  /** Must be registered on the MELI app dashboard. */\n  redirectUri: string;\n}\n\nexport interface MeliOAuthTokens {\n  access_token: string;\n  refresh_token: string;\n  /** Seconds-from-now until access_token expires. Typically 21600 (6h). */\n  expires_in: number;\n  /** Unix-seconds wall-clock at which access_token will expire. */\n  access_token_expires_at: number;\n  /** MELI-side user id of the authorized seller. */\n  user_id: number;\n  scope: string;\n  token_type: \"bearer\";\n}\n\n/**\n * Pluggable token store. Production deployments back this with Redis /\n * Postgres / Vercel KV. The `InMemoryOAuthStore` below is suitable for\n * tests + single-process demos.\n */\nexport interface OAuthTokenStore {\n  /** Read tokens for a specific seller (by MELI user id). */\n  read(userId: number): Promise<MeliOAuthTokens | null>;\n  /** Atomically replace tokens. Implementations MUST handle concurrent writes. */\n  write(userId: number, tokens: MeliOAuthTokens): Promise<void>;\n  /** Remove tokens (e.g. when seller revokes). */\n  remove?(userId: number): Promise<void>;\n}\n\n// ---------------------------------------------------------------------------\n// Authorization URL builder\n// ---------------------------------------------------------------------------\n\nexport interface BuildAuthUrlInput {\n  app: OAuthAppCredentials;\n  /** MELI site identifier — controls which auth host is used. */\n  site: keyof typeof AUTHORIZATION_URL_BY_SITE;\n  /** State for CSRF protection (random nonce, validated on callback). */\n  state: string;\n  /** Override scopes. Default: `offline_access read write`. */\n  scopes?: string[];\n}\n\nexport function buildAuthorizationUrl(input: BuildAuthUrlInput): string {\n  const base = AUTHORIZATION_URL_BY_SITE[input.site];\n  if (!base) {\n    throw new MeliAuthError(`Unknown MELI site: '${input.site}'`);\n  }\n  const url = new URL(base);\n  url.searchParams.set(\"response_type\", \"code\");\n  url.searchParams.set(\"client_id\", input.app.clientId);\n  url.searchParams.set(\"redirect_uri\", input.app.redirectUri);\n  url.searchParams.set(\"state\", input.state);\n  if (input.scopes) {\n    url.searchParams.set(\"scope\", input.scopes.join(\" \"));\n  }\n  return url.toString();\n}\n\n// ---------------------------------------------------------------------------\n// Exchange auth code for tokens\n// ---------------------------------------------------------------------------\n\nexport async function exchangeAuthorizationCode(\n  app: OAuthAppCredentials,\n  code: string,\n  fetchImpl: typeof fetch = fetch,\n): Promise<MeliOAuthTokens> {\n  const body = new URLSearchParams({\n    grant_type: \"authorization_code\",\n    client_id: app.clientId,\n    client_secret: app.clientSecret,\n    code,\n    redirect_uri: app.redirectUri,\n  });\n  const tokens = await postTokenRequest(body, fetchImpl);\n  return enrichTokens(tokens);\n}\n\n// ---------------------------------------------------------------------------\n// Refresh\n// ---------------------------------------------------------------------------\n\nexport async function refreshTokens(\n  app: OAuthAppCredentials,\n  refreshToken: string,\n  fetchImpl: typeof fetch = fetch,\n): Promise<MeliOAuthTokens> {\n  const body = new URLSearchParams({\n    grant_type: \"refresh_token\",\n    client_id: app.clientId,\n    client_secret: app.clientSecret,\n    refresh_token: refreshToken,\n  });\n  const tokens = await postTokenRequest(body, fetchImpl);\n  return enrichTokens(tokens);\n}\n\n// ---------------------------------------------------------------------------\n// Mutex-protected ensure-fresh access token\n// ---------------------------------------------------------------------------\n\n/**\n * Returns a valid access_token for the given seller, refreshing if needed.\n * Coalesces concurrent calls so only one HTTP refresh fires per seller per\n * window. Atomically updates the store with the rotated refresh_token.\n *\n * Throws `MeliAuthError` if no tokens are stored OR if the refresh fails\n * permanently (e.g. revoked, expired beyond 4 months).\n */\nexport async function ensureAccessToken(args: {\n  userId: number;\n  app: OAuthAppCredentials;\n  store: OAuthTokenStore;\n  /** Refresh ahead of expiry by this many seconds. Default 60. */\n  preflightWindowSeconds?: number;\n  /** Override \"now\" for tests. Returns Unix seconds. */\n  now?: () => number;\n  /** Override fetch (mocked in tests / Edge runtime). Default global fetch. */\n  fetchImpl?: typeof fetch;\n}): Promise<MeliOAuthTokens> {\n  const now = args.now ?? (() => Math.floor(Date.now() / 1000));\n  const preflight = args.preflightWindowSeconds ?? 60;\n\n  const lock = getLock(args.userId);\n  return lock.run(async () => {\n    const stored = await args.store.read(args.userId);\n    if (!stored) {\n      throw new MeliAuthError(\n        `No OAuth tokens stored for MELI user ${args.userId}; the seller must complete the OAuth flow first.`,\n      );\n    }\n    if (stored.access_token_expires_at - now() > preflight) {\n      // Still fresh.\n      return stored;\n    }\n    // Refresh.\n    let refreshed: MeliOAuthTokens;\n    try {\n      refreshed = await refreshTokens(args.app, stored.refresh_token, args.fetchImpl);\n    } catch (err) {\n      throw new MeliAuthError(\n        `Token refresh failed for MELI user ${args.userId}: ${\n          err instanceof Error ? err.message : String(err)\n        }`,\n        err,\n      );\n    }\n    // Note: we MUST atomically write the new tokens before returning so\n    // concurrent callers see the rotated refresh_token. The mutex guarantees\n    // single-flight; the store's write atomicity guarantees no partial state.\n    await args.store.write(args.userId, refreshed);\n    return refreshed;\n  });\n}\n\n// ---------------------------------------------------------------------------\n// In-memory store + lock\n// ---------------------------------------------------------------------------\n\nexport class InMemoryOAuthStore implements OAuthTokenStore {\n  private state = new Map<number, MeliOAuthTokens>();\n\n  async read(userId: number): Promise<MeliOAuthTokens | null> {\n    return this.state.get(userId) ?? null;\n  }\n\n  async write(userId: number, tokens: MeliOAuthTokens): Promise<void> {\n    this.state.set(userId, tokens);\n  }\n\n  async remove(userId: number): Promise<void> {\n    this.state.delete(userId);\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\ninterface RawTokenResponse {\n  access_token: string;\n  refresh_token: string;\n  expires_in: number;\n  user_id: number;\n  scope: string;\n  token_type: \"bearer\";\n}\n\nasync function postTokenRequest(\n  body: URLSearchParams,\n  fetchImpl: typeof fetch = fetch,\n): Promise<RawTokenResponse> {\n  const response = await fetchImpl(TOKEN_URL, {\n    method: \"POST\",\n    headers: {\n      \"Content-Type\": \"application/x-www-form-urlencoded\",\n      Accept: \"application/json\",\n    },\n    body: body.toString(),\n  });\n  let raw: unknown;\n  try {\n    raw = await response.json();\n  } catch {\n    throw new MeliAuthError(\n      `MELI /oauth/token returned non-JSON response (status ${response.status})`,\n    );\n  }\n  if (!response.ok) {\n    const errorBody = raw as { error?: string; message?: string };\n    throw new MeliAuthError(\n      `MELI /oauth/token failed (${response.status}): ${\n        errorBody.error ?? errorBody.message ?? \"unknown error\"\n      }`,\n      errorBody,\n    );\n  }\n  if (\n    typeof (raw as RawTokenResponse).access_token !== \"string\" ||\n    typeof (raw as RawTokenResponse).refresh_token !== \"string\" ||\n    typeof (raw as RawTokenResponse).expires_in !== \"number\" ||\n    typeof (raw as RawTokenResponse).user_id !== \"number\"\n  ) {\n    throw new MeliAuthError(\n      `MELI /oauth/token returned unexpected shape: ${JSON.stringify(raw)}`,\n    );\n  }\n  return raw as RawTokenResponse;\n}\n\nfunction enrichTokens(raw: RawTokenResponse): MeliOAuthTokens {\n  return {\n    access_token: raw.access_token,\n    refresh_token: raw.refresh_token,\n    expires_in: raw.expires_in,\n    access_token_expires_at: Math.floor(Date.now() / 1000) + raw.expires_in,\n    user_id: raw.user_id,\n    scope: raw.scope,\n    token_type: raw.token_type,\n  };\n}\n\n// Per-userId mutex map. Coalesces concurrent refresh requests to a single\n// in-flight HTTP call.\nconst locks = new Map<number, AsyncLock>();\nfunction getLock(userId: number): AsyncLock {\n  let lock = locks.get(userId);\n  if (!lock) {\n    lock = new AsyncLock();\n    locks.set(userId, lock);\n  }\n  return lock;\n}\n\nclass AsyncLock {\n  private chain: Promise<unknown> = Promise.resolve();\n  run<T>(fn: () => Promise<T>): Promise<T> {\n    const next = this.chain.then(() => fn(), () => fn());\n    this.chain = next.catch(() => {\n      /* swallow so a failure doesn't break the chain */\n    });\n    return next as Promise<T>;\n  }\n}\n","// Pluggable telemetry hooks. Wires the client to OpenTelemetry, Sentry,\n// Datadog, custom logging — without modifying the lib.\n//\n// Hosts pass `telemetry: { onRequest, onResponse, onRetry, onRateLimitWait }`\n// in `MeliClientOptions`. All hooks are optional; the client treats missing\n// hooks as no-ops with zero overhead.\n//\n// Design choices:\n//   - Hooks are SYNCHRONOUS by default — they shouldn't add latency to the\n//     request path. Async work (e.g., shipping spans to a remote collector)\n//     should be enqueued by the host.\n//   - The hook payload uses opaque `requestId` strings the host generates so\n//     onRequest/onResponse can be correlated.\n//   - We never pass headers containing `Authorization` to hooks.\n\nexport interface TelemetryRequestEvent {\n  /** Stable id for correlating onRequest ↔ onResponse / onRetry. */\n  requestId: string;\n  /** Wall-clock start in ms (Date.now). */\n  startedAt: number;\n  method: string;\n  /** Full URL including query string. */\n  url: string;\n  /** Path without query string for low-cardinality span names. */\n  path: string;\n  /** Attempt number (1-based). */\n  attempt: number;\n}\n\nexport interface TelemetryResponseEvent {\n  requestId: string;\n  /** Wall-clock end in ms. */\n  endedAt: number;\n  /** Total duration in ms (endedAt - startedAt). */\n  durationMs: number;\n  status: number;\n  /** Number of attempts that ran before this response (1 = no retries). */\n  attempts: number;\n  /** MELI's request id from the response header, if present. */\n  meliRequestId?: string;\n}\n\nexport interface TelemetryRetryEvent {\n  requestId: string;\n  attempt: number;\n  /** Reason: 5xx status, 429, network error, etc. */\n  reason: \"status\" | \"network\" | \"timeout\";\n  status?: number;\n  /** Backoff delay before next attempt, in ms. */\n  delayMs: number;\n}\n\nexport interface TelemetryRateLimitEvent {\n  /** Bucket scope (`seller:<userId>`, `bearer:<suffix>`, or \"anon\"). */\n  scope: string;\n  /** How long we waited for a token, in ms. */\n  waitMs: number;\n}\n\nexport interface TelemetryHooks {\n  /** Fired before the HTTP call leaves the client. */\n  onRequest?: (event: TelemetryRequestEvent) => void;\n  /** Fired after the response is received (success or non-retryable error). */\n  onResponse?: (event: TelemetryResponseEvent) => void;\n  /** Fired before each retry attempt. */\n  onRetry?: (event: TelemetryRetryEvent) => void;\n  /** Fired when a rate-limit token wait completes. Only emitted when wait > 0. */\n  onRateLimitWait?: (event: TelemetryRateLimitEvent) => void;\n}\n\n/**\n * No-op telemetry. Used as the default when the host doesn't configure hooks.\n * Defined here (instead of `?? {}` inline) so the JIT can devirtualize the\n * empty path.\n */\nexport const noopTelemetry: Required<TelemetryHooks> = {\n  onRequest: () => {},\n  onResponse: () => {},\n  onRetry: () => {},\n  onRateLimitWait: () => {},\n};\n\n/**\n * Generate a request id without depending on `crypto.randomUUID()`. Edge\n * runtimes have it, but Node 18- on Lambda doesn't.\n */\nexport function generateRequestId(): string {\n  const cryptoLike = (globalThis as { crypto?: { randomUUID?: () => string } })\n    .crypto;\n  if (cryptoLike?.randomUUID) return cryptoLike.randomUUID();\n  // Fallback — 16 bytes of Math.random hex.\n  let id = \"\";\n  for (let i = 0; i < 16; i++) {\n    id += Math.floor(Math.random() * 256)\n      .toString(16)\n      .padStart(2, \"0\");\n  }\n  return id;\n}\n","// `MeliClient` — typed HTTP client for the MercadoLibre API.\n//\n// Behaviour:\n//   - Bearer auth via OAuth access_token. The client coalesces concurrent\n//     calls per seller and refreshes tokens via the configured store.\n//   - Per-seller rate limit (token bucket; default 24/s, burst 60).\n//   - Exponential-backoff retry on 5xx + 429 + network errors.\n//   - Response body validation via Zod (with a flag to disable for hot paths).\n//   - Single base URL: `https://api.mercadolibre.com`.\n//\n// Domain-specific helpers (`items`, `categories`, etc.) compose this client\n// — they call `client.fetch(path, opts)` with the appropriate type.\n\nimport {\n  MeliApiError,\n  MeliAuthError,\n  MeliNetworkError,\n  MeliValidationError,\n} from \"./errors\";\nimport {\n  TokenBucketRateLimiter,\n  type RateLimiter,\n} from \"./rate-limiter\";\nimport {\n  fetchWithRetry,\n  type RetryClassifier,\n  type RetryOptions,\n  defaultRetryClassifier,\n} from \"./retry\";\nimport {\n  ensureAccessToken,\n  type OAuthAppCredentials,\n  type OAuthTokenStore,\n} from \"./oauth\";\nimport {\n  generateRequestId,\n  noopTelemetry,\n  type TelemetryHooks,\n} from \"./telemetry\";\nimport type { ZodType } from \"zod\";\n\nconst DEFAULT_BASE_URL = \"https://api.mercadolibre.com\";\n\n// ---------------------------------------------------------------------------\n// Options\n// ---------------------------------------------------------------------------\n\nexport type AuthMode =\n  | { kind: \"bearer\"; accessToken: string }\n  | { kind: \"oauth\"; userId: number; app: OAuthAppCredentials; store: OAuthTokenStore }\n  | { kind: \"none\" };\n\nexport interface MeliClientOptions {\n  /** Auth strategy. Use `bearer` for direct tokens, `oauth` for managed\n   *  refresh, or `none` for public endpoints (search, sites, currencies). */\n  auth: AuthMode;\n  /** Override base URL — useful for testing against a mock server. */\n  baseUrl?: string;\n  /** Override fetch (e.g. msw). Defaults to globalThis.fetch. */\n  fetch?: typeof fetch;\n  /** Rate limiter implementation. Default: TokenBucketRateLimiter. */\n  rateLimiter?: RateLimiter;\n  /** Retry options forwarded to `fetchWithRetry`. */\n  retry?: RetryOptions;\n  /** Custom retry classifier. */\n  retryClassifier?: RetryClassifier;\n  /** User-Agent string. Default: `@ar-agents/mercadolibre/<version>`. */\n  userAgent?: string;\n  /** When true, skip Zod validation on responses (hot paths). Default false. */\n  skipResponseValidation?: boolean;\n  /** Pluggable telemetry hooks (OpenTelemetry, Sentry, Datadog, custom). */\n  telemetry?: TelemetryHooks;\n  /** Per-request timeout in milliseconds. Default 30000.\n   *  Wedged TCP connections that never return data otherwise burn a Vercel\n   *  Edge function's entire 25-60s budget on attempt #1 and never retry. */\n  requestTimeoutMs?: number;\n}\n\nexport interface FetchOptions<T = unknown> {\n  method?: \"GET\" | \"POST\" | \"PUT\" | \"DELETE\" | \"PATCH\";\n  /** Path relative to base URL (must start with `/`). */\n  path: string;\n  /** Query string parameters. */\n  query?: Record<string, string | number | boolean | undefined | null>;\n  /** Pre-serialized body. If set, body is sent as-is. */\n  body?: unknown;\n  /** When set, response is parsed against this Zod schema. */\n  responseSchema?: ZodType<T>;\n  /** Override per-call User-Agent. */\n  userAgent?: string;\n  /** Per-call retry override. */\n  retry?: RetryOptions;\n  /** AbortSignal. */\n  signal?: AbortSignal;\n  /** Override the rate-limit scope. Default: derived from auth (`seller:<userId>`). */\n  rateLimitScope?: string;\n}\n\n// ---------------------------------------------------------------------------\n// Client\n// ---------------------------------------------------------------------------\n\nexport class MeliClient {\n  readonly baseUrl: string;\n  private readonly auth: AuthMode;\n  private readonly fetchImpl: typeof fetch;\n  private readonly rateLimiter: RateLimiter;\n  private readonly retry: RetryOptions;\n  private readonly retryClassifier: RetryClassifier;\n  private readonly userAgent: string;\n  private readonly skipResponseValidation: boolean;\n  private readonly telemetry: Required<TelemetryHooks>;\n  private readonly requestTimeoutMs: number;\n\n  constructor(options: MeliClientOptions) {\n    this.auth = options.auth;\n    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\\/+$/, \"\");\n    this.fetchImpl =\n      options.fetch ??\n      ((globalThis as { fetch?: typeof fetch }).fetch as typeof fetch);\n    if (typeof this.fetchImpl !== \"function\") {\n      throw new Error(\n        \"MeliClient requires `fetch` (Node 20+, browsers, Vercel Edge, etc.).\",\n      );\n    }\n    this.rateLimiter = options.rateLimiter ?? new TokenBucketRateLimiter();\n    this.retry = options.retry ?? {};\n    this.retryClassifier = options.retryClassifier ?? defaultRetryClassifier;\n    this.userAgent = options.userAgent ?? `@ar-agents/mercadolibre/0.1`;\n    this.skipResponseValidation = options.skipResponseValidation ?? false;\n    this.requestTimeoutMs = options.requestTimeoutMs ?? 30_000;\n    this.telemetry = {\n      onRequest: options.telemetry?.onRequest ?? noopTelemetry.onRequest,\n      onResponse: options.telemetry?.onResponse ?? noopTelemetry.onResponse,\n      onRetry: options.telemetry?.onRetry ?? noopTelemetry.onRetry,\n      onRateLimitWait:\n        options.telemetry?.onRateLimitWait ?? noopTelemetry.onRateLimitWait,\n    };\n  }\n\n  /**\n   * Like `fetch`, but returns the raw `Response`. Used for binary endpoints\n   * (e.g., `/shipment_labels` returning PDF/ZPL). Goes through the same\n   * auth + rate-limit + retry + telemetry plumbing.\n   *\n   * Throws on non-2xx the same way `fetch<T>` does.\n   */\n  async fetchRaw(\n    options: FetchOptions<unknown> & { acceptHeader?: string },\n  ): Promise<Response> {\n    return (await this.executeRequest({ ...options, parseAsJson: false })) as Response;\n  }\n\n  /**\n   * Make a request. Returns the parsed-and-validated response.\n   *\n   * Throws:\n   *   - `MeliAuthError` if OAuth refresh fails\n   *   - `MeliApiError` if status >= 400 after retries\n   *   - `MeliNetworkError` if fetch threw\n   *   - `MeliValidationError` if response failed Zod validation\n   */\n  async fetch<T = unknown>(options: FetchOptions<T>): Promise<T> {\n    return this.executeRequest({ ...options, parseAsJson: true }) as Promise<T>;\n  }\n\n  /** Internal — runs the full request pipeline. JSON-parses unless told otherwise. */\n  private async executeRequest(\n    options: FetchOptions<unknown> & {\n      parseAsJson: boolean;\n      acceptHeader?: string;\n    },\n  ): Promise<unknown> {\n    const url = this.buildUrl(options.path, options.query);\n    const requestId = generateRequestId();\n    const startedAt = Date.now();\n    let attempts = 1;\n\n    // 1. Resolve auth header.\n    const authHeader = await this.resolveAuthHeader();\n\n    // 2. Acquire rate-limit token.\n    const scope = options.rateLimitScope ?? this.deriveRateLimitScope();\n    const rateLimitStartedAt = Date.now();\n    await this.rateLimiter.acquire(scope);\n    const rateLimitWaitMs = Date.now() - rateLimitStartedAt;\n    if (rateLimitWaitMs > 0) {\n      this.telemetry.onRateLimitWait({ scope, waitMs: rateLimitWaitMs });\n    }\n\n    this.telemetry.onRequest({\n      requestId,\n      startedAt,\n      method: options.method ?? \"GET\",\n      url,\n      path: options.path,\n      attempt: 1,\n    });\n\n    // 3. Build request init. Compose a per-request timeout signal with the\n    // caller's signal (if any) so wedged connections can't burn the agent's\n    // budget on a single attempt.\n    const timeoutSignal = AbortSignal.timeout(this.requestTimeoutMs);\n    const composedSignal = options.signal\n      ? anySignal(options.signal, timeoutSignal)\n      : timeoutSignal;\n    const init: RequestInit = {\n      method: options.method ?? \"GET\",\n      headers: {\n        Accept: options.acceptHeader ?? \"application/json\",\n        \"User-Agent\": options.userAgent ?? this.userAgent,\n        ...(authHeader ? { Authorization: authHeader } : {}),\n        ...(options.body !== undefined && options.body !== null\n          ? { \"Content-Type\": \"application/json\" }\n          : {}),\n      },\n      ...(options.body !== undefined && options.body !== null\n        ? { body: typeof options.body === \"string\" ? options.body : JSON.stringify(options.body) }\n        : {}),\n      signal: composedSignal,\n    };\n\n    // 4. Do the request with retry.\n    const wrappedRetry: RetryOptions = {\n      ...this.retry,\n      ...(options.retry ?? {}),\n      onRetry: (attempt: number, lastError: unknown) => {\n        attempts = attempt + 1;\n        const retryResponse = (lastError as { response?: Response }).response;\n        const reason: \"status\" | \"network\" | \"timeout\" = retryResponse\n          ? \"status\"\n          : (lastError as { name?: string })?.name === \"AbortError\"\n            ? \"timeout\"\n            : \"network\";\n        const event: import(\"./telemetry\").TelemetryRetryEvent = {\n          requestId,\n          attempt,\n          reason,\n          delayMs: 0,\n        };\n        if (retryResponse) event.status = retryResponse.status;\n        this.telemetry.onRetry(event);\n        (this.retry.onRetry ?? options.retry?.onRetry)?.(attempt, lastError);\n      },\n    };\n    let response: Response;\n    try {\n      response = await fetchWithRetry(\n        url,\n        init,\n        wrappedRetry,\n        this.retryClassifier,\n        this.fetchImpl,\n      );\n    } catch (err) {\n      // Rethrow as our typed error so consumers can branch.\n      if (err instanceof Error && (err as { response?: Response }).response) {\n        const r = (err as { response?: Response }).response!;\n        const errorBody = await safeReadJson(r);\n        throw new MeliApiError(\n          `MELI API ${r.status} on ${options.method ?? \"GET\"} ${options.path}`,\n          r.status,\n          url,\n          errorBody,\n          r.headers.get(\"x-request-id\") ?? undefined,\n        );\n      }\n      throw new MeliNetworkError(\n        `MELI fetch failed for ${options.method ?? \"GET\"} ${options.path}: ${\n          err instanceof Error ? err.message : String(err)\n        }`,\n        err,\n      );\n    }\n\n    // 5. Parse + validate.\n    const meliReqId = response.headers.get(\"x-request-id\");\n    const responseEvent: import(\"./telemetry\").TelemetryResponseEvent = {\n      requestId,\n      endedAt: Date.now(),\n      durationMs: Date.now() - startedAt,\n      status: response.status,\n      attempts,\n    };\n    if (meliReqId) responseEvent.meliRequestId = meliReqId;\n    this.telemetry.onResponse(responseEvent);\n\n    // Raw mode: return the Response untouched (caller handles binary body).\n    if (!options.parseAsJson) {\n      if (response.status >= 400) {\n        // Try to read a JSON error body for context, but tolerate non-JSON.\n        const errorBody = await safeReadJson(response.clone());\n        throw new MeliApiError(\n          `MELI API ${response.status} on ${options.method ?? \"GET\"} ${options.path}`,\n          response.status,\n          url,\n          errorBody,\n          response.headers.get(\"x-request-id\") ?? undefined,\n        );\n      }\n      return response;\n    }\n\n    if (response.status === 204 || response.status === 205) {\n      return undefined;\n    }\n    let body: unknown;\n    try {\n      body = await response.json();\n    } catch (err) {\n      throw new MeliApiError(\n        `MELI returned non-JSON body on ${options.path}`,\n        response.status,\n        url,\n        null,\n        response.headers.get(\"x-request-id\") ?? undefined,\n      );\n    }\n\n    if (response.status >= 400) {\n      throw new MeliApiError(\n        `MELI API ${response.status} on ${options.method ?? \"GET\"} ${options.path}`,\n        response.status,\n        url,\n        body,\n        response.headers.get(\"x-request-id\") ?? undefined,\n      );\n    }\n\n    if (options.responseSchema && !this.skipResponseValidation) {\n      const parsed = options.responseSchema.safeParse(body);\n      if (!parsed.success) {\n        throw new MeliValidationError(\n          `Response from ${options.path} failed validation: ${\n            parsed.error.issues[0]?.message ?? \"unknown\"\n          }`,\n          parsed.error.issues,\n        );\n      }\n      return parsed.data;\n    }\n    return body;\n  }\n\n  // -------------------------------------------------------------------------\n  // Internal helpers\n  // -------------------------------------------------------------------------\n\n  private async resolveAuthHeader(): Promise<string | null> {\n    switch (this.auth.kind) {\n      case \"none\":\n        return null;\n      case \"bearer\":\n        return `Bearer ${this.auth.accessToken}`;\n      case \"oauth\": {\n        const tokens = await ensureAccessToken({\n          userId: this.auth.userId,\n          app: this.auth.app,\n          store: this.auth.store,\n          fetchImpl: this.fetchImpl,\n        }).catch((err) => {\n          throw err instanceof Error ? new MeliAuthError(err.message, err) : err;\n        });\n        return `Bearer ${tokens.access_token}`;\n      }\n    }\n  }\n\n  private deriveRateLimitScope(): string {\n    if (this.auth.kind === \"oauth\") return `seller:${this.auth.userId}`;\n    if (this.auth.kind === \"bearer\") {\n      // Hash instead of slicing the token. Slicing leaks the last 8 chars\n      // into telemetry; hashing produces an opaque, collision-resistant id.\n      // Use a non-cryptographic FNV-1a 32-bit (deterministic, no async).\n      return `bearer:${fnv1a32(this.auth.accessToken)}`;\n    }\n    return \"anon\";\n  }\n\n  private buildUrl(\n    path: string,\n    query?: Record<string, string | number | boolean | undefined | null>,\n  ): string {\n    // Defence in depth against SSRF: reject any path that includes a scheme\n    // (`http://...`) or a protocol-relative authority (`//evil.com/x`).\n    // Without this, a path containing an absolute URL would silently rebase\n    // the request onto an attacker's host. Domain helpers always pass paths\n    // beginning with `/`, so this only catches mistakes (or attacks) before\n    // they reach the network.\n    if (\n      typeof path !== \"string\" ||\n      /^[a-z][a-z0-9+.-]*:\\/\\//i.test(path) ||\n      path.startsWith(\"//\") ||\n      path.includes(\"\u0000\")\n    ) {\n      throw new Error(\n        `MeliClient: refusing to fetch path that looks like an absolute URL or contains NUL: ${JSON.stringify(path)}`,\n      );\n    }\n    const url = new URL(path.startsWith(\"/\") ? path : `/${path}`, this.baseUrl);\n    if (query) {\n      for (const [k, v] of Object.entries(query)) {\n        if (v === undefined || v === null) continue;\n        url.searchParams.set(k, String(v));\n      }\n    }\n    return url.toString();\n  }\n}\n\nasync function safeReadJson(r: Response): Promise<unknown> {\n  try {\n    return await r.json();\n  } catch {\n    return null;\n  }\n}\n\n/** Compose multiple AbortSignals into one. The result aborts when any input\n *  aborts. Pure ES2022, works on Node 20+ / browsers / Edge. */\nfunction anySignal(...signals: AbortSignal[]): AbortSignal {\n  if (typeof (AbortSignal as unknown as { any?: (s: AbortSignal[]) => AbortSignal }).any === \"function\") {\n    return (AbortSignal as unknown as { any: (s: AbortSignal[]) => AbortSignal }).any(signals);\n  }\n  // Polyfill for runtimes without AbortSignal.any (older Node 20.x).\n  const ctrl = new AbortController();\n  const onAbort = () => ctrl.abort();\n  for (const s of signals) {\n    if (s.aborted) {\n      ctrl.abort();\n      break;\n    }\n    s.addEventListener(\"abort\", onAbort, { once: true });\n  }\n  return ctrl.signal;\n}\n\n/** FNV-1a 32-bit hash. Used to scope rate-limit buckets without leaking tokens. */\nfunction fnv1a32(s: string): string {\n  let h = 0x811c9dc5;\n  for (let i = 0; i < s.length; i++) {\n    h ^= s.charCodeAt(i);\n    h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;\n  }\n  return h.toString(16).padStart(8, \"0\");\n}\n","// Test helpers — `MockFetch` builder + a pre-wired client factory.\n//\n// Hosts that want to unit-test agent flows that consume the MELI client\n// can fixture responses without a real MELI account:\n//\n//   import { mockFetch, makeMeliClient } from \"@ar-agents/mercadolibre/testing\";\n//\n//   const fetchMock = mockFetch()\n//     .on(\"GET\", \"/items/MLA1\", () => ({ status: 200, body: { ... } }))\n//     .on(\"POST\", \"/answers\", (req) => ({ status: 200, body: { id: 1, text: req.body.text } }))\n//     .build();\n//\n//   const client = makeMeliClient({ fetch: fetchMock, accessToken: \"test\" });\n\nimport { MeliClient, type MeliClientOptions } from \"./client\";\nimport { NoopRateLimiter } from \"./rate-limiter\";\n\nexport interface MockRequestSnapshot {\n  method: string;\n  url: string;\n  headers: Record<string, string>;\n  body: unknown;\n}\n\nexport interface MockResponse {\n  status: number;\n  body?: unknown;\n  headers?: Record<string, string>;\n}\n\nexport type MockHandler = (\n  req: MockRequestSnapshot,\n) => MockResponse | Promise<MockResponse>;\n\nexport interface MockFetchBuilder {\n  /** Match exact method+pathname. */\n  on(\n    method: \"GET\" | \"POST\" | \"PUT\" | \"DELETE\" | \"PATCH\",\n    pathname: string,\n    handler: MockHandler,\n  ): MockFetchBuilder;\n  /** Match a regex against pathname. */\n  onRegex(\n    method: \"GET\" | \"POST\" | \"PUT\" | \"DELETE\" | \"PATCH\",\n    pattern: RegExp,\n    handler: MockHandler,\n  ): MockFetchBuilder;\n  /** Catch-all fallback (defaults to 404). */\n  fallback(handler: MockHandler): MockFetchBuilder;\n  /** Return the mock fetch fn + a recorder of all requests received. */\n  build(): MockFetch;\n}\n\nexport interface MockFetch {\n  fetch: typeof fetch;\n  /** All requests received, in order. */\n  requests: MockRequestSnapshot[];\n}\n\ninterface Rule {\n  method: string;\n  match: (pathname: string) => boolean;\n  handler: MockHandler;\n}\n\nexport function mockFetch(): MockFetchBuilder {\n  const rules: Rule[] = [];\n  let fallback: MockHandler = () => ({ status: 404, body: { error: \"not_found\" } });\n\n  const builder: MockFetchBuilder = {\n    on(method, pathname, handler) {\n      rules.push({\n        method,\n        match: (p) => p === pathname,\n        handler,\n      });\n      return builder;\n    },\n    onRegex(method, pattern, handler) {\n      rules.push({\n        method,\n        match: (p) => pattern.test(p),\n        handler,\n      });\n      return builder;\n    },\n    fallback(handler) {\n      fallback = handler;\n      return builder;\n    },\n    build() {\n      const requests: MockRequestSnapshot[] = [];\n      const f: typeof fetch = async (input, init) => {\n        const urlStr = typeof input === \"string\" ? input : (input as Request).url;\n        const u = new URL(urlStr);\n        const method = (init?.method ?? \"GET\").toUpperCase();\n        const headers: Record<string, string> = {};\n        const headersInit = (init?.headers ?? {}) as\n          | Record<string, string>\n          | Headers\n          | string[][];\n        if (headersInit instanceof Headers) {\n          headersInit.forEach((v, k) => {\n            headers[k] = v;\n          });\n        } else if (Array.isArray(headersInit)) {\n          for (const [k, v] of headersInit) {\n            if (k && v) headers[k] = v;\n          }\n        } else {\n          for (const [k, v] of Object.entries(headersInit)) {\n            headers[k] = v;\n          }\n        }\n        let parsedBody: unknown = null;\n        if (init?.body !== undefined && init.body !== null) {\n          if (typeof init.body === \"string\") {\n            try {\n              parsedBody = JSON.parse(init.body);\n            } catch {\n              parsedBody = init.body;\n            }\n          } else {\n            parsedBody = init.body;\n          }\n        }\n        const snapshot: MockRequestSnapshot = {\n          method,\n          url: urlStr,\n          headers,\n          body: parsedBody,\n        };\n        requests.push(snapshot);\n        const matched = rules.find(\n          (r) => r.method === method && r.match(u.pathname),\n        );\n        const handler = matched?.handler ?? fallback;\n        const result = await handler(snapshot);\n        const responseHeaders: Record<string, string> = {\n          \"Content-Type\": \"application/json\",\n          ...(result.headers ?? {}),\n        };\n        return new Response(\n          result.body !== undefined ? JSON.stringify(result.body) : null,\n          {\n            status: result.status,\n            headers: responseHeaders,\n          },\n        );\n      };\n      return { fetch: f, requests };\n    },\n  };\n  return builder;\n}\n\n// ---------------------------------------------------------------------------\n// Convenience: pre-wired client for tests\n// ---------------------------------------------------------------------------\n\nexport interface MakeMeliClientOptions {\n  /** Mock fetch implementation. */\n  fetch: typeof fetch;\n  /** Access token to embed (sent as `Bearer <token>`). Defaults to \"test_token\". */\n  accessToken?: string;\n  /** Override base URL (the mock fetch can ignore the host but we set one for url-building). */\n  baseUrl?: string;\n  /** Skip Zod response validation (useful when fixtures are minimal). */\n  skipResponseValidation?: boolean;\n}\n\nexport function makeMeliClient(opts: MakeMeliClientOptions): MeliClient {\n  const init: MeliClientOptions = {\n    auth: { kind: \"bearer\", accessToken: opts.accessToken ?? \"test_token\" },\n    fetch: opts.fetch,\n    rateLimiter: new NoopRateLimiter(),\n    skipResponseValidation: opts.skipResponseValidation ?? false,\n  };\n  if (opts.baseUrl !== undefined) init.baseUrl = opts.baseUrl;\n  return new MeliClient(init);\n}\n"]}