@yoryoboy/bi-mcp 1.16.0 → 1.19.0

package/dist/src/services/mercadolibre/__tests__/mercadolibre-order-billing-info.test.js

@@ -0,0 +1,582 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { getMercadoLibreOrderBillingInfo, getMercadoLibreSaleBillingInfo } from "../mercadolibre-order-billing-info.js";
+import { createMercadoLibreClient, MercadoLibreApiError } from "../mercadolibre-api.js";
+import { getMercadoLibreConnectionRow } from "../../../config/mercadolibre-profile-store.js";
+import { assertActiveProfile } from "../../../config/profile-store.js";
+import { decryptSecret } from "../../../config/vtex-crypto.js";
+vi.mock("../mercadolibre-api.js", () => ({
+  createMercadoLibreClient: vi.fn(),
+  isRetryableMercadoLibreError: (error) => error instanceof MercadoLibreApiError && Boolean(error.status && [408, 429, 500, 502, 503, 504].includes(error.status)),
+  MercadoLibreApiError: class MercadoLibreApiError extends Error {
+    constructor(message, status, code, retryAfterMs) {
+      super(message);
+      this.status = status;
+      this.code = code;
+      this.retryAfterMs = retryAfterMs;
+    }
+  }
+}));
+vi.mock("../../../config/mercadolibre-profile-store.js", () => ({ getMercadoLibreConnectionRow: vi.fn() }));
+vi.mock("../../../config/profile-store.js", () => ({ assertActiveProfile: vi.fn() }));
+vi.mock("../../../config/vtex-crypto.js", () => ({ decryptSecret: vi.fn() }));
+describe("getMercadoLibreOrderBillingInfo", () => {
+  const getMock = vi.fn();
+  const completeBillingInfo = () => ({
+    buyer: {
+      billing_info: {
+        name: "Ada",
+        last_name: "Lovelace",
+        identification: { type: "CUIT", number: "20123456789" },
+        address: {
+          street_name: "Main",
+          street_number: "10",
+          city_name: "Buenos Aires",
+          state: "CABA",
+          zip_code: "1000",
+          country_id: "AR"
+        },
+        taxes: { taxpayer_type: { id: "responsable_inscripto", description: "Responsable Inscripto" } }
+      }
+    }
+  });
+  function createDeferred() {
+    let resolve;
+    const promise = new Promise((resolvePromise) => {
+      resolve = resolvePromise;
+    });
+    return { promise, resolve };
+  }
+  function setFiscalField(billingInfo, path, value) {
+    let current = billingInfo.buyer;
+    for (const key of ["billing_info", ...path.slice(0, -1)]) {
+      current = current[key];
+    }
+    current[path.at(-1)] = value;
+  }
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(assertActiveProfile).mockResolvedValue({ id: "triplim" });
+    vi.mocked(getMercadoLibreConnectionRow).mockResolvedValue({
+      sellerId: "seller-1",
+      encryptedAccessToken: "stored-token",
+      expiresAt: /* @__PURE__ */ new Date("2099-01-01T00:00:00.000Z"),
+      status: "active"
+    });
+    vi.mocked(decryptSecret).mockReturnValue("stored-access-token");
+    vi.mocked(createMercadoLibreClient).mockReturnValue({ get: getMock });
+  });
+  it("reads the order before requesting billing info with its site and billing info IDs", async () => {
+    const order = { seller: { id: "seller-1" }, buyer: { billing_info: { id: "billing/123" } } };
+    const billingInfo = completeBillingInfo();
+    getMock.mockResolvedValueOnce({ data: order }).mockResolvedValueOnce({ data: { site_id: "MLA" } }).mockResolvedValueOnce({ data: billingInfo });
+    await expect(getMercadoLibreOrderBillingInfo("triplim", "order/456")).resolves.toEqual({
+      available: true,
+      order,
+      billingInfo
+    });
+    expect(getMock).toHaveBeenNthCalledWith(1, "/orders/order%2F456");
+    expect(getMock).toHaveBeenNthCalledWith(2, "/users/seller-1");
+    expect(getMock).toHaveBeenNthCalledWith(3, "/orders/billing-info/MLA/billing%2F123");
+  });
+  it("returns an explicit unavailable result when the order has no buyer billing info", async () => {
+    getMock.mockResolvedValueOnce({ data: { seller: { id: "seller-1" }, buyer: {} } });
+    await expect(getMercadoLibreOrderBillingInfo("triplim", "456")).resolves.toEqual({
+      available: false,
+      reason: "order_buyer_billing_info_missing"
+    });
+    expect(getMock).toHaveBeenCalledTimes(1);
+  });
+  it("does not request fiscal data when the order belongs to another seller", async () => {
+    getMock.mockResolvedValueOnce({
+      data: { seller: { id: "other-seller" }, buyer: { billing_info: { id: "billing/123" } } }
+    });
+    await expect(getMercadoLibreOrderBillingInfo("triplim", "456")).resolves.toEqual({
+      available: false,
+      reason: "order_seller_ownership_mismatch"
+    });
+    expect(getMock).toHaveBeenCalledTimes(1);
+    expect(getMock).not.toHaveBeenCalledWith(expect.stringContaining("/orders/billing-info/"));
+  });
+  it("accepts a numeric order seller ID for the selected string seller ID", async () => {
+    vi.mocked(getMercadoLibreConnectionRow).mockResolvedValue({
+      sellerId: "123",
+      encryptedAccessToken: "stored-token",
+      expiresAt: /* @__PURE__ */ new Date("2099-01-01T00:00:00.000Z"),
+      status: "active"
+    });
+    const order = { seller: { id: 123 }, buyer: { billing_info: { id: "billing/123" } } };
+    const billingInfo = completeBillingInfo();
+    getMock.mockResolvedValueOnce({ data: order }).mockResolvedValueOnce({ data: { site_id: "MLA" } }).mockResolvedValueOnce({ data: billingInfo });
+    await expect(getMercadoLibreOrderBillingInfo("triplim", "456")).resolves.toEqual({
+      available: true,
+      order,
+      billingInfo
+    });
+    expect(getMock).toHaveBeenNthCalledWith(2, "/users/123");
+    expect(getMock).toHaveBeenNthCalledWith(3, "/orders/billing-info/MLA/billing%2F123");
+  });
+  it("normalizes surrounding whitespace before checking seller ownership", async () => {
+    vi.mocked(getMercadoLibreConnectionRow).mockResolvedValue({
+      sellerId: " seller-1 ",
+      encryptedAccessToken: "stored-token",
+      expiresAt: /* @__PURE__ */ new Date("2099-01-01T00:00:00.000Z"),
+      status: "active"
+    });
+    const order = { seller: { id: " seller-1 " }, buyer: { billing_info: { id: "billing/123" } } };
+    getMock.mockResolvedValueOnce({ data: order }).mockResolvedValueOnce({ data: { site_id: "MLA" } }).mockResolvedValueOnce({ data: completeBillingInfo() });
+    await expect(getMercadoLibreOrderBillingInfo("triplim", "456")).resolves.toMatchObject({ available: true });
+    expect(getMock).toHaveBeenNthCalledWith(2, "/users/%20seller-1%20");
+    expect(getMock).toHaveBeenNthCalledWith(3, "/orders/billing-info/MLA/billing%2F123");
+  });
+  it("does not request fiscal data when the order seller data is malformed", async () => {
+    getMock.mockResolvedValueOnce({
+      data: { seller: { id: { unexpected: "value" } }, buyer: { billing_info: { id: "billing/123" } } }
+    });
+    await expect(getMercadoLibreOrderBillingInfo("triplim", "456")).resolves.toEqual({
+      available: false,
+      reason: "order_seller_id_missing_or_malformed"
+    });
+    expect(getMock).toHaveBeenCalledTimes(1);
+    expect(getMock).not.toHaveBeenCalledWith(expect.stringContaining("/orders/billing-info/"));
+  });
+  it.each([
+    ["null", null],
+    ["array", []],
+    ["empty string", ""],
+    ["whitespace-only string", "  "]
+  ])("fails closed for a %s seller ID", async (_description, sellerId) => {
+    getMock.mockResolvedValueOnce({
+      data: { seller: { id: sellerId }, buyer: { billing_info: { id: "billing/123" } } }
+    });
+    const result = await getMercadoLibreOrderBillingInfo("triplim", "456");
+    expect(result).toEqual({
+      available: false,
+      reason: "order_seller_id_missing_or_malformed"
+    });
+    expect(result).not.toHaveProperty("billingInfo");
+    expect(result).not.toHaveProperty("fiscal");
+    expect(getMock).toHaveBeenCalledTimes(1);
+    expect(getMock).not.toHaveBeenCalledWith(expect.stringContaining("/orders/billing-info/"));
+  });
+  it("preserves upstream errors from the order or billing-info request", async () => {
+    const upstreamError = new Error("MercadoLibre API request failed (403): forbidden");
+    getMock.mockResolvedValueOnce({ data: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } } }).mockResolvedValueOnce({ data: { site_id: "MLA" } }).mockRejectedValueOnce(upstreamError);
+    await expect(getMercadoLibreOrderBillingInfo("triplim", "456")).rejects.toMatchObject({
+      message: "MercadoLibre billing info request unavailable"
+    });
+  });
+  it("returns credential maintenance required without refreshing or persisting credentials", async () => {
+    vi.mocked(getMercadoLibreConnectionRow).mockResolvedValue({
+      sellerId: "seller-1",
+      encryptedAccessToken: "stored-token",
+      expiresAt: /* @__PURE__ */ new Date("2000-01-01T00:00:00.000Z"),
+      status: "active"
+    });
+    await expect(getMercadoLibreOrderBillingInfo("triplim", "456")).resolves.toEqual({
+      available: false,
+      reason: "credential_maintenance_required"
+    });
+    expect(decryptSecret).not.toHaveBeenCalled();
+    expect(createMercadoLibreClient).not.toHaveBeenCalled();
+    expect(getMock).not.toHaveBeenCalled();
+  });
+  it("retries a transient order request with deterministic backoff", async () => {
+    const transient = new MercadoLibreApiError("temporary", 503);
+    const pause = vi.fn().mockResolvedValue(void 0);
+    getMock.mockRejectedValueOnce(transient).mockResolvedValueOnce({ data: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } } }).mockResolvedValueOnce({ data: { site_id: "MLA" } }).mockResolvedValueOnce({ data: completeBillingInfo() });
+    await expect(
+      getMercadoLibreOrderBillingInfo("triplim", "456", { baseRetryDelayMs: 1, sleep: pause })
+    ).resolves.toMatchObject({ available: true });
+    expect(pause).toHaveBeenCalledWith(1);
+    expect(getMock).toHaveBeenCalledTimes(4);
+  });
+  it("retries transient account and billing-info requests", async () => {
+    const pause = vi.fn().mockResolvedValue(void 0);
+    getMock.mockResolvedValueOnce({ data: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } } }).mockRejectedValueOnce(new MercadoLibreApiError("temporary account", 503)).mockResolvedValueOnce({ data: { site_id: "MLA" } }).mockRejectedValueOnce(new MercadoLibreApiError("temporary billing", 429)).mockResolvedValueOnce({ data: completeBillingInfo() });
+    await expect(
+      getMercadoLibreOrderBillingInfo("triplim", "456", { baseRetryDelayMs: 1, sleep: pause })
+    ).resolves.toMatchObject({ available: true });
+    expect(pause).toHaveBeenCalledTimes(2);
+    expect(getMock).toHaveBeenCalledTimes(5);
+  });
+  it("preserves terminal retryable classification after bounded retry exhaustion without leaking upstream details", async () => {
+    const pause = vi.fn().mockResolvedValue(void 0);
+    getMock.mockRejectedValue(new MercadoLibreApiError("buyer-tax-id-should-not-leak", 503, "internal_error"));
+    await expect(
+      getMercadoLibreOrderBillingInfo("triplim", "456", { maxRetries: 1, sleep: pause })
+    ).rejects.toMatchObject({
+      message: "MercadoLibre billing info request unavailable",
+      status: 503,
+      code: "internal_error",
+      resource: "order",
+      attempts: 2,
+      retryable: true
+    });
+    expect(pause).toHaveBeenCalledTimes(1);
+    expect(getMock).toHaveBeenCalledTimes(2);
+  });
+  it.each([
+    [404, "not_found", "order"],
+    [403, "forbidden", "order"]
+  ])("preserves terminal %i non-retryable classification without retrying", async (status, code, resource) => {
+    const pause = vi.fn().mockResolvedValue(void 0);
+    getMock.mockRejectedValue(new MercadoLibreApiError("buyer-tax-id-should-not-leak", status, code));
+    await expect(
+      getMercadoLibreOrderBillingInfo("triplim", "456", { sleep: pause })
+    ).rejects.toMatchObject({
+      message: "MercadoLibre billing info request unavailable",
+      status,
+      code,
+      resource,
+      attempts: 1,
+      retryable: false
+    });
+    expect(pause).not.toHaveBeenCalled();
+    expect(getMock).toHaveBeenCalledTimes(1);
+  });
+  it("fails closed when intermediary or billing payloads are malformed", async () => {
+    getMock.mockResolvedValueOnce({ data: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } } }).mockResolvedValueOnce({ data: [] });
+    await expect(getMercadoLibreOrderBillingInfo("triplim", "456")).resolves.toEqual({
+      available: false,
+      reason: "account_payload_malformed"
+    });
+    getMock.mockReset();
+    getMock.mockResolvedValueOnce({ data: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } } }).mockResolvedValueOnce({ data: { site_id: "MLA" } }).mockResolvedValueOnce({ data: { buyer: {} } });
+    await expect(getMercadoLibreOrderBillingInfo("triplim", "456")).resolves.toEqual({
+      available: false,
+      reason: "billing_info_payload_malformed"
+    });
+  });
+  it.each([
+    ["buyer name", { name: true }],
+    ["buyer last name", { last_name: true }],
+    ["identification type", { identification: { type: true } }],
+    ["identification number", { identification: { number: true } }],
+    ["address street name", { address: { street_name: true } }],
+    ["address street number", { address: { street_number: true } }],
+    ["address city", { address: { city_name: true } }],
+    ["address state", { address: { state: true } }],
+    ["address zip code", { address: { zip_code: true } }],
+    ["address country", { address: { country_id: true } }],
+    ["taxpayer type ID", { taxes: { taxpayer_type: { id: true } } }],
+    ["taxpayer type description", { taxes: { taxpayer_type: { description: true } } }]
+  ])("fails closed when %s is a boolean", async (_field, fiscalFields) => {
+    getMock.mockResolvedValueOnce({ data: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } } }).mockResolvedValueOnce({ data: { site_id: "MLA" } }).mockResolvedValueOnce({ data: { buyer: { billing_info: fiscalFields } } });
+    const result = await getMercadoLibreOrderBillingInfo("triplim", "456");
+    expect(result).toEqual({
+      available: false,
+      reason: "billing_info_fiscal_fields_malformed"
+    });
+    expect(result).not.toHaveProperty("billingInfo");
+  });
+  it.each([
+    ["buyer name", ["name"]],
+    ["buyer last name", ["last_name"]],
+    ["identification type", ["identification", "type"]],
+    ["identification number", ["identification", "number"]],
+    ["address street name", ["address", "street_name"]],
+    ["address street number", ["address", "street_number"]],
+    ["address city", ["address", "city_name"]],
+    ["address state", ["address", "state"]],
+    ["address zip code", ["address", "zip_code"]],
+    ["address country", ["address", "country_id"]],
+    ["taxpayer type ID", ["taxes", "taxpayer_type", "id"]],
+    ["taxpayer type description", ["taxes", "taxpayer_type", "description"]]
+  ])("fails closed without a fiscal projection when required %s is null or blank", async (_field, path) => {
+    for (const value of [null, "   "]) {
+      const billingInfo = completeBillingInfo();
+      setFiscalField(billingInfo, path, value);
+      getMock.mockResolvedValueOnce({ data: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } } }).mockResolvedValueOnce({ data: { site_id: "MLA" } }).mockResolvedValueOnce({ data: billingInfo });
+      const result = await getMercadoLibreOrderBillingInfo("triplim", "456");
+      expect(result).toEqual({ available: false, reason: "billing_info_fiscal_fields_missing" });
+      expect(result).not.toHaveProperty("billingInfo");
+      expect(result).not.toHaveProperty("fiscal");
+      getMock.mockReset();
+    }
+  });
+  it.each([
+    ["array", []],
+    ["object", { unexpected: "value" }]
+  ])("fails closed when a fiscal field is a malformed %s", async (_type, value) => {
+    getMock.mockResolvedValueOnce({ data: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } } }).mockResolvedValueOnce({ data: { site_id: "MLA" } }).mockResolvedValueOnce({ data: { buyer: { billing_info: { name: value } } } });
+    await expect(getMercadoLibreOrderBillingInfo("triplim", "456")).resolves.toEqual({
+      available: false,
+      reason: "billing_info_fiscal_fields_malformed"
+    });
+  });
+  it("allows a valid numeric street number in a complete fiscal record", async () => {
+    const billingInfo = completeBillingInfo();
+    setFiscalField(billingInfo, ["address", "street_number"], 123);
+    getMock.mockResolvedValueOnce({ data: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } } }).mockResolvedValueOnce({ data: { site_id: "MLA" } }).mockResolvedValueOnce({ data: billingInfo });
+    await expect(getMercadoLibreOrderBillingInfo("triplim", "456")).resolves.toEqual({
+      available: true,
+      order: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } },
+      billingInfo
+    });
+  });
+  it("normalizes a complete Mercado Libre state object to the report display state", async () => {
+    const billingInfo = completeBillingInfo();
+    setFiscalField(billingInfo, ["address", "state"], { code: "AR-C", name: "Ciudad Aut\xF3noma de Buenos Aires" });
+    getMock.mockResolvedValueOnce({ data: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } } }).mockResolvedValueOnce({ data: { site_id: "MLA" } }).mockResolvedValueOnce({ data: billingInfo });
+    await expect(getMercadoLibreOrderBillingInfo("triplim", "456")).resolves.toEqual({
+      available: true,
+      order: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } },
+      billingInfo: expect.objectContaining({
+        buyer: expect.objectContaining({
+          billing_info: expect.objectContaining({
+            address: expect.objectContaining({ state: "Ciudad Aut\xF3noma de Buenos Aires" })
+          })
+        })
+      })
+    });
+  });
+  it.each([
+    ["missing code", { name: "Ciudad Aut\xF3noma de Buenos Aires" }],
+    ["missing name", { code: "AR-C" }],
+    ["blank name", { code: "AR-C", name: " " }]
+  ])("fails closed for a state object with %s", async (_description, state) => {
+    const billingInfo = completeBillingInfo();
+    setFiscalField(billingInfo, ["address", "state"], state);
+    getMock.mockResolvedValueOnce({ data: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } } }).mockResolvedValueOnce({ data: { site_id: "MLA" } }).mockResolvedValueOnce({ data: billingInfo });
+    await expect(getMercadoLibreOrderBillingInfo("triplim", "456")).resolves.toEqual({
+      available: false,
+      reason: "billing_info_fiscal_fields_malformed"
+    });
+  });
+  it("retains scalar state compatibility", async () => {
+    const billingInfo = completeBillingInfo();
+    getMock.mockResolvedValueOnce({ data: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } } }).mockResolvedValueOnce({ data: { site_id: "MLA" } }).mockResolvedValueOnce({ data: billingInfo });
+    await expect(getMercadoLibreOrderBillingInfo("triplim", "456")).resolves.toEqual({
+      available: true,
+      order: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } },
+      billingInfo
+    });
+  });
+  it("resolves a direct sale reference as an order without querying packs", async () => {
+    getMock.mockResolvedValueOnce({ data: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "123" } } } }).mockResolvedValueOnce({ data: { site_id: "MLA" } }).mockResolvedValueOnce({ data: completeBillingInfo() });
+    await expect(getMercadoLibreSaleBillingInfo("triplim", "order-1")).resolves.toMatchObject({
+      resolutionKind: "order",
+      orderId: "order-1",
+      result: { available: true }
+    });
+    expect(getMock).not.toHaveBeenCalledWith("/packs/order-1");
+  });
+  it("falls back to a pack only after an order 404 and independently resolves every member", async () => {
+    const completeFor = (id) => ({ seller: { id: "seller-1" }, buyer: { billing_info: { id } } });
+    getMock.mockImplementation((path) => {
+      if (path === "/orders/pack-1") return Promise.reject(new MercadoLibreApiError("not found", 404));
+      if (path === "/packs/pack-1") return Promise.resolve({ data: { orders: [{ id: "order-1" }, { id: "order-2" }] } });
+      if (path === "/orders/order-1") return Promise.resolve({ data: completeFor("bill-1") });
+      if (path === "/orders/order-2") return Promise.resolve({ data: completeFor("bill-2") });
+      if (path === "/users/seller-1") return Promise.resolve({ data: { site_id: "MLA" } });
+      if (path === "/orders/billing-info/MLA/bill-1" || path === "/orders/billing-info/MLA/bill-2") return Promise.resolve({ data: completeBillingInfo() });
+      throw new Error(`unexpected path ${path}`);
+    });
+    const result = await getMercadoLibreSaleBillingInfo("triplim", "pack-1", { maxConcurrency: 2 });
+    expect(result).toMatchObject({
+      resolutionKind: "pack",
+      packId: "pack-1",
+      metadata: { memberCount: 2, accessibleCount: 2, availableCount: 2, unavailableCount: 0, failedCount: 0, partialCoverage: false },
+      members: [expect.objectContaining({ orderId: "order-1", accessible: true }), expect.objectContaining({ orderId: "order-2", accessible: true })]
+    });
+  });
+  it("keeps pack member failures and ownership mismatches scoped to their members", async () => {
+    getMock.mockImplementation((path) => {
+      if (path === "/orders/pack-1") return Promise.reject(new MercadoLibreApiError("not found", 404));
+      if (path === "/packs/pack-1") return Promise.resolve({ data: { orders: [{ id: "foreign" }, { id: "missing" }] } });
+      if (path === "/orders/foreign") return Promise.resolve({ data: { seller: { id: "other-seller" }, buyer: { billing_info: { id: "do-not-read" } } } });
+      if (path === "/orders/missing") return Promise.reject(new MercadoLibreApiError("missing", 404));
+      throw new Error(`unexpected path ${path}`);
+    });
+    await expect(getMercadoLibreSaleBillingInfo("triplim", "pack-1")).resolves.toMatchObject({
+      resolutionKind: "pack",
+      metadata: { memberCount: 2, accessibleCount: 1, availableCount: 0, unavailableCount: 1, failedCount: 1, partialCoverage: true },
+      members: [
+        { orderId: "foreign", accessible: true, result: { available: false, reason: "order_seller_ownership_mismatch" } },
+        { orderId: "missing", accessible: false, failureReason: "order_not_found" }
+      ]
+    });
+    expect(getMock).not.toHaveBeenCalledWith(expect.stringContaining("billing-info"));
+  });
+  it("keeps valid pack members when other pack entries do not contain an order ID", async () => {
+    getMock.mockImplementation((path) => {
+      if (path === "/orders/pack-1") return Promise.reject(new MercadoLibreApiError("not found", 404));
+      if (path === "/packs/pack-1") return Promise.resolve({ data: { orders: [{ id: "order-1" }, {}, { id: " " }] } });
+      if (path === "/orders/order-1") return Promise.resolve({ data: { seller: { id: "seller-1" }, buyer: { billing_info: { id: "bill-1" } } } });
+      if (path === "/users/seller-1") return Promise.resolve({ data: { site_id: "MLA" } });
+      if (path === "/orders/billing-info/MLA/bill-1") return Promise.resolve({ data: completeBillingInfo() });
+      throw new Error(`unexpected path ${path}`);
+    });
+    await expect(getMercadoLibreSaleBillingInfo("triplim", "pack-1")).resolves.toMatchObject({
+      resolutionKind: "pack",
+      metadata: {
+        memberCount: 3,
+        validMemberCount: 1,
+        invalidMemberCount: 2,
+        accessibleCount: 1,
+        availableCount: 1,
+        unavailableCount: 0,
+        failedCount: 2,
+        partialCoverage: true
+      },
+      members: [
+        { orderId: "order-1", accessible: true, result: { available: true } },
+        { memberIndex: 1, accessible: false, failureReason: "invalid_member" },
+        { memberIndex: 2, accessible: false, failureReason: "invalid_member" }
+      ]
+    });
+  });
+  it("keeps pack member resolution at the configured concurrency ceiling", async () => {
+    let activeMembers = 0;
+    let maxActiveMembers = 0;
+    const firstWaveStarted = createDeferred();
+    const thirdMemberStarted = createDeferred();
+    const fourthMemberStarted = createDeferred();
+    const memberRequests = /* @__PURE__ */ new Map();
+    getMock.mockImplementation((path) => {
+      if (path === "/orders/pack-1") return Promise.reject(new MercadoLibreApiError("not found", 404));
+      if (path === "/packs/pack-1") return Promise.resolve({ data: { orders: [{ id: "one" }, { id: "two" }, { id: "three" }, { id: "four" }] } });
+      if (path.startsWith("/orders/") && !path.startsWith("/orders/billing-info/")) {
+        activeMembers += 1;
+        maxActiveMembers = Math.max(maxActiveMembers, activeMembers);
+        if (activeMembers === 2) firstWaveStarted.resolve();
+        const request = createDeferred();
+        memberRequests.set(path, request);
+        if (memberRequests.size === 3) thirdMemberStarted.resolve();
+        if (memberRequests.size === 4) fourthMemberStarted.resolve();
+        return request.promise.finally(() => {
+          activeMembers -= 1;
+        });
+      }
+      throw new Error(`unexpected path ${path}`);
+    });
+    const result = getMercadoLibreSaleBillingInfo("triplim", "pack-1", { maxConcurrency: 2 });
+    await firstWaveStarted.promise;
+    expect(maxActiveMembers).toBe(2);
+    memberRequests.get("/orders/one").resolve({ data: { seller: { id: "seller-1" }, buyer: {} } });
+    await thirdMemberStarted.promise;
+    expect(maxActiveMembers).toBe(2);
+    for (const path of ["/orders/two", "/orders/three"]) {
+      memberRequests.get(path).resolve({ data: { seller: { id: "seller-1" }, buyer: {} } });
+    }
+    await fourthMemberStarted.promise;
+    memberRequests.get("/orders/four").resolve({ data: { seller: { id: "seller-1" }, buyer: {} } });
+    await result;
+    expect(maxActiveMembers).toBe(2);
+  });
+  it("reports a retry-exhausted member without losing pack aggregate coverage", async () => {
+    const pause = vi.fn().mockResolvedValue(void 0);
+    getMock.mockImplementation((path) => {
+      if (path === "/orders/pack-1") return Promise.reject(new MercadoLibreApiError("not found", 404));
+      if (path === "/packs/pack-1") return Promise.resolve({ data: { orders: [{ id: "unavailable" }] } });
+      if (path === "/orders/unavailable") {
+        return Promise.reject(new MercadoLibreApiError("buyer-tax-id-should-not-leak https://api.example/orders/unavailable", 503));
+      }
+      throw new Error(`unexpected path ${path}`);
+    });
+    const result = await getMercadoLibreSaleBillingInfo("triplim", "pack-1", { maxRetries: 1, sleep: pause });
+    expect(result).toMatchObject({
+      resolutionKind: "pack",
+      metadata: {
+        memberCount: 1,
+        accessibleCount: 0,
+        availableCount: 0,
+        unavailableCount: 0,
+        failedCount: 1,
+        partialCoverage: true
+      },
+      members: [{ orderId: "unavailable", accessible: false, failureReason: "upstream_unavailable", attempts: 2, retryable: true }]
+    });
+    expect(JSON.stringify(result)).not.toContain("buyer-tax-id-should-not-leak");
+    expect(JSON.stringify(result)).not.toContain("api.example");
+    expect(pause).toHaveBeenCalledTimes(1);
+    expect(getMock).toHaveBeenCalledWith("/orders/unavailable", expect.anything());
+    expect(getMock.mock.calls.filter(([path]) => path === "/orders/unavailable")).toHaveLength(2);
+  });
+  it("stops member retries when the feature-scoped pack deadline is exhausted", async () => {
+    const pause = vi.fn().mockResolvedValue(void 0);
+    getMock.mockImplementation((path) => {
+      if (path === "/orders/pack-1") return Promise.reject(new MercadoLibreApiError("not found", 404));
+      if (path === "/packs/pack-1") return Promise.resolve({ data: { orders: [{ id: "slow" }] } });
+      if (path === "/orders/slow") return Promise.reject(new MercadoLibreApiError("temporary", 503));
+      throw new Error(`unexpected path ${path}`);
+    });
+    await expect(
+      getMercadoLibreSaleBillingInfo("triplim", "pack-1", {
+        maxRetries: 2,
+        baseRetryDelayMs: 10,
+        packOperationDeadlineMs: 5,
+        now: () => 0,
+        sleep: pause
+      })
+    ).resolves.toMatchObject({
+      resolutionKind: "pack",
+      metadata: { failedCount: 1, partialCoverage: true, deadlineExceeded: true },
+      members: [{ orderId: "slow", accessible: false, failureReason: "operation_deadline_exceeded" }]
+    });
+    expect(pause).not.toHaveBeenCalled();
+    expect(getMock.mock.calls.filter(([path]) => path === "/orders/slow")).toHaveLength(1);
+  });
+  it("keeps an initial order deadline unavailable and does not fall back after it expires", async () => {
+    const initialOrder = createDeferred();
+    const initialRequestStarted = createDeferred();
+    let now = 0;
+    getMock.mockImplementation((path) => {
+      if (path === "/orders/pack-1") {
+        initialRequestStarted.resolve();
+        return initialOrder.promise;
+      }
+      throw new Error(`unexpected path ${path}`);
+    });
+    const result = getMercadoLibreSaleBillingInfo("triplim", "pack-1", {
+      packOperationDeadlineMs: 5,
+      now: () => now
+    });
+    await initialRequestStarted.promise;
+    now = 5;
+    await expect(result).rejects.toThrow("MercadoLibre pack billing info operation deadline exceeded");
+    expect(getMock).toHaveBeenCalledWith("/orders/pack-1", expect.objectContaining({ signal: expect.any(AbortSignal) }));
+    expect(getMock).not.toHaveBeenCalledWith("/packs/pack-1", expect.anything());
+  });
+  it("does not start fallback pack resolution after the initial order lookup exhausts the shared deadline", async () => {
+    let now = 0;
+    getMock.mockImplementation((path) => {
+      if (path === "/orders/pack-1") {
+        now = 5;
+        return Promise.reject(new MercadoLibreApiError("not found", 404));
+      }
+      throw new Error(`unexpected path ${path}`);
+    });
+    await expect(
+      getMercadoLibreSaleBillingInfo("triplim", "pack-1", {
+        packOperationDeadlineMs: 5,
+        now: () => now
+      })
+    ).resolves.toMatchObject({
+      resolutionKind: "pack",
+      unavailableReason: "pack_operation_deadline_exceeded",
+      metadata: { deadlineExceeded: true, partialCoverage: true },
+      members: []
+    });
+    expect(getMock).toHaveBeenCalledTimes(1);
+    expect(getMock).not.toHaveBeenCalledWith("/packs/pack-1", expect.anything());
+  });
+  it.each([
+    ["empty", { orders: [] }, "pack_orders_empty"],
+    ["malformed envelope", { orders: null }, "pack_payload_malformed"]
+  ])("fails safely for a %s pack payload", async (_description, payload, reason) => {
+    getMock.mockRejectedValueOnce(new MercadoLibreApiError("not found", 404)).mockResolvedValueOnce({ data: payload });
+    await expect(getMercadoLibreSaleBillingInfo("triplim", "pack-1")).resolves.toMatchObject({
+      resolutionKind: "pack",
+      members: [],
+      unavailableReason: reason,
+      metadata: { partialCoverage: true }
+    });
+  });
+  it("does not attempt pack resolution for an order permission failure", async () => {
+    getMock.mockRejectedValueOnce(new MercadoLibreApiError("forbidden", 403));
+    await expect(getMercadoLibreSaleBillingInfo("triplim", "reference-1")).rejects.toMatchObject({ status: 403, resource: "order" });
+    expect(getMock).not.toHaveBeenCalledWith("/packs/reference-1");
+  });
+});
+//# sourceMappingURL=mercadolibre-order-billing-info.test.js.map