@cimplify/sdk 0.16.1 → 0.16.2

package/dist/advanced.mjs

@@ -118,7 +118,7 @@ function enrichError(error, options = {}) {
   return error;
 }
 
-// src/catalogue.ts
+// src/internal/safe.ts
 function toCimplifyError(error) {
   if (error instanceof CimplifyError) return enrichError(error);
   if (error instanceof Error) {
@@ -133,6 +133,8 @@ async function safe(promise) {
     return err(toCimplifyError(error));
   }
 }
+
+// src/catalogue.ts
 function withQuery(path, params) {
   const query2 = new URLSearchParams();
   for (const [key, value] of Object.entries(params)) {
@@ -502,20 +504,6 @@ var CatalogueQueries = class {
 };
 
 // src/cart.ts
-function toCimplifyError2(error) {
-  if (error instanceof CimplifyError) return enrichError(error);
-  if (error instanceof Error) {
-    return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, error.message, false));
-  }
-  return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, String(error), false));
-}
-async function safe2(promise) {
-  try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError2(error));
-  }
-}
 function isUICartResponse(value) {
   return "cart" in value;
 }
@@ -527,21 +515,21 @@ var CartOperations = class {
     this.client = client;
   }
   async get() {
-    const result = await safe2(this.client.get("/api/v1/cart"));
+    const result = await safe(this.client.get("/api/v1/cart"));
     if (!result.ok) return result;
     return ok(unwrapEnrichedCart(result.value));
   }
   async getRaw() {
-    return safe2(this.client.get("/api/v1/cart"));
+    return safe(this.client.get("/api/v1/cart"));
   }
   async getItems() {
-    return safe2(this.client.get("/api/v1/cart/items"));
+    return safe(this.client.get("/api/v1/cart/items"));
   }
   async getCount() {
-    return safe2(this.client.get("/api/v1/cart/count"));
+    return safe(this.client.get("/api/v1/cart/count"));
   }
   async getTotal() {
-    return safe2(this.client.get("/api/v1/cart/total"));
+    return safe(this.client.get("/api/v1/cart/total"));
   }
   async getSummary() {
     const cartResult = await this.get();
@@ -558,18 +546,18 @@ var CartOperations = class {
     });
   }
   async addItem(input) {
-    return safe2(this.client.post("/api/v1/cart/items", input));
+    return safe(this.client.post("/api/v1/cart/items", input));
   }
   async updateItem(cartItemId, updates) {
     if (typeof updates.quantity === "number") {
       return this.updateQuantity(cartItemId, updates.quantity);
     }
     const encodedId = encodeURIComponent(cartItemId);
-    return safe2(this.client.patch(`/api/v1/cart/items/${encodedId}`, updates));
+    return safe(this.client.patch(`/api/v1/cart/items/${encodedId}`, updates));
   }
   async updateQuantity(cartItemId, quantity) {
     const encodedId = encodeURIComponent(cartItemId);
-    return safe2(
+    return safe(
       this.client.patch(`/api/v1/cart/items/${encodedId}`, {
         quantity
       })
@@ -577,20 +565,20 @@ var CartOperations = class {
   }
   async removeItem(cartItemId) {
     const encodedId = encodeURIComponent(cartItemId);
-    return safe2(this.client.delete(`/api/v1/cart/items/${encodedId}`));
+    return safe(this.client.delete(`/api/v1/cart/items/${encodedId}`));
   }
   async clear() {
-    return safe2(this.client.delete("/api/v1/cart"));
+    return safe(this.client.delete("/api/v1/cart"));
   }
   async applyCoupon(code) {
-    return safe2(
+    return safe(
       this.client.post("/api/v1/cart/coupons", {
         coupon_code: code
       })
     );
   }
   async removeCoupon() {
-    return safe2(this.client.delete("/api/v1/cart/coupons/current"));
+    return safe(this.client.delete("/api/v1/cart/coupons/current"));
   }
   async isEmpty() {
     const countResult = await this.getCount();
@@ -1449,20 +1437,6 @@ var CheckoutResolver = class {
 };
 
 // src/checkout.ts
-function toCimplifyError3(error) {
-  if (error instanceof CimplifyError) return enrichError(error);
-  if (error instanceof Error) {
-    return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, error.message, false));
-  }
-  return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, String(error), false));
-}
-async function safe3(promise) {
-  try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError3(error));
-  }
-}
 function toTerminalFailure(code, message, recoverable) {
   return {
     success: false,
@@ -1494,7 +1468,7 @@ var CheckoutService = class {
       ...data,
       idempotency_key: data.idempotency_key || generateIdempotencyKey()
     };
-    const result = await safe3(
+    const result = await safe(
       this.client.post("/api/v1/checkout", {
         checkout_data: checkoutData
       })
@@ -1514,22 +1488,22 @@ var CheckoutService = class {
     );
   }
   async submitAuthorization(input) {
-    return safe3(this.client.post("/api/v1/payments/authorization", input));
+    return safe(this.client.post("/api/v1/payments/authorization", input));
   }
   async pollPaymentStatus(orderId) {
     const encodedId = encodeURIComponent(orderId);
     const tokenParam = this.orderTokenParam(orderId);
-    return safe3(this.client.get(`/api/v1/orders/${encodedId}/payment-status${tokenParam}`));
+    return safe(this.client.get(`/api/v1/orders/${encodedId}/payment-status${tokenParam}`));
   }
   async updateOrderCustomer(orderId, customer) {
     const encodedId = encodeURIComponent(orderId);
     const tokenParam = this.orderTokenParam(orderId);
-    return safe3(this.client.post(`/api/v1/orders/${encodedId}/customer${tokenParam}`, customer));
+    return safe(this.client.post(`/api/v1/orders/${encodedId}/customer${tokenParam}`, customer));
   }
   async verifyPayment(orderId) {
     const encodedId = encodeURIComponent(orderId);
     const tokenParam = this.orderTokenParam(orderId);
-    return safe3(this.client.post(`/api/v1/orders/${encodedId}/verify-payment${tokenParam}`));
+    return safe(this.client.post(`/api/v1/orders/${encodedId}/verify-payment${tokenParam}`));
   }
   async processAndResolve(data) {
     data.on_status_change?.("preparing", {});
@@ -1634,20 +1608,6 @@ var CheckoutService = class {
 };
 
 // src/orders.ts
-function toCimplifyError4(error) {
-  if (error instanceof CimplifyError) return enrichError(error);
-  if (error instanceof Error) {
-    return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, error.message, false));
-  }
-  return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, String(error), false));
-}
-async function safe4(promise) {
-  try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError4(error));
-  }
-}
 var OrderQueries = class {
   constructor(client) {
     this.client = client;
@@ -1662,12 +1622,12 @@ var OrderQueries = class {
     if (options?.limit) params.set("limit", String(options.limit));
     if (options?.offset) params.set("offset", String(options.offset));
     const path = params.toString() ? `/api/v1/orders?${params.toString()}` : "/api/v1/orders";
-    return safe4(this.client.get(path));
+    return safe(this.client.get(path));
   }
   async get(orderId) {
     const encodedId = encodeURIComponent(orderId);
     const tokenParam = this.orderTokenParam(orderId);
-    return safe4(this.client.get(`/api/v1/orders/${encodedId}${tokenParam}`));
+    return safe(this.client.get(`/api/v1/orders/${encodedId}${tokenParam}`));
   }
   async getRecent(limit = 5) {
     return this.list({ limit });
@@ -1678,7 +1638,7 @@ var OrderQueries = class {
   async cancel(orderId, reason) {
     const encodedId = encodeURIComponent(orderId);
     const tokenParam = this.orderTokenParam(orderId);
-    return safe4(
+    return safe(
       this.client.post(`/api/v1/orders/${encodedId}/cancel${tokenParam}`, {
         reason
       })
@@ -1687,20 +1647,6 @@ var OrderQueries = class {
 };
 
 // src/link.ts
-function toCimplifyError5(error) {
-  if (error instanceof CimplifyError) return error;
-  if (error instanceof Error) {
-    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
-  }
-  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
-}
-async function safe5(promise) {
-  try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError5(error));
-  }
-}
 function encodePathSegment(value) {
   return encodeURIComponent(value);
 }
@@ -1738,13 +1684,13 @@ var LinkService = class {
     this.client = client;
   }
   async getProfile() {
-    return safe5(this.client.linkGet("/v1/link/profile"));
+    return safe(this.client.linkGet("/v1/link/profile"));
   }
   async requestOtp(input) {
-    return safe5(this.client.linkPost("/v1/link/auth/request-otp", input));
+    return safe(this.client.linkPost("/v1/link/auth/request-otp", input));
   }
   async verifyOtp(input) {
-    const result = await safe5(
+    const result = await safe(
       this.client.linkPost("/v1/link/auth/verify-otp", input)
     );
     if (result.ok && result.value.session_token) {
@@ -1753,45 +1699,45 @@ var LinkService = class {
     return result;
   }
   async logout() {
-    const result = await safe5(this.client.linkPost("/v1/link/auth/logout"));
+    const result = await safe(this.client.linkPost("/v1/link/auth/logout"));
     if (result.ok) {
       this.client.clearSession();
     }
     return result;
   }
   async checkStatus(contact) {
-    return safe5(this.client.linkPost("/v1/link/check-status", { contact }));
+    return safe(this.client.linkPost("/v1/link/check-status", { contact }));
   }
   async getLinkData() {
-    return safe5(this.client.linkGet("/v1/link/data"));
+    return safe(this.client.linkGet("/v1/link/data"));
   }
   async getAddresses() {
-    return safe5(this.client.linkGet("/v1/link/addresses"));
+    return safe(this.client.linkGet("/v1/link/addresses"));
   }
   async getMobileMoney() {
-    return safe5(this.client.linkGet("/v1/link/mobile-money"));
+    return safe(this.client.linkGet("/v1/link/mobile-money"));
   }
   async getPreferences() {
-    return safe5(this.client.linkGet("/v1/link/preferences"));
+    return safe(this.client.linkGet("/v1/link/preferences"));
   }
   async enroll(data) {
-    return safe5(this.client.linkPost("/v1/link/enroll", data));
+    return safe(this.client.linkPost("/v1/link/enroll", data));
   }
   async enrollAndLinkOrder(data) {
-    return safe5(
+    return safe(
       this.client.linkPost("/v1/link/enroll-and-link-order", data)
     );
   }
   async updatePreferences(preferences) {
-    return safe5(this.client.linkPost("/v1/link/preferences", preferences));
+    return safe(this.client.linkPost("/v1/link/preferences", preferences));
   }
   async createAddress(input) {
-    return safe5(
+    return safe(
       this.client.linkPost("/v1/link/addresses", toCreateAddressPayload(input))
     );
   }
   async updateAddress(input) {
-    return safe5(
+    return safe(
       this.client.linkPost(
         `/v1/link/addresses/${encodePathSegment(input.address_id)}`,
         toUpdateAddressPayload(input)
@@ -1799,26 +1745,26 @@ var LinkService = class {
     );
   }
   async deleteAddress(addressId) {
-    return safe5(
+    return safe(
       this.client.linkDelete(`/v1/link/addresses/${encodePathSegment(addressId)}`)
     );
   }
   async setDefaultAddress(addressId) {
-    return safe5(
+    return safe(
       this.client.linkPost(
         `/v1/link/addresses/${encodePathSegment(addressId)}/default`
       )
     );
   }
   async trackAddressUsage(addressId) {
-    return safe5(
+    return safe(
       this.client.linkPost(
         `/v1/link/addresses/${encodePathSegment(addressId)}/track-usage`
       )
     );
   }
   async createMobileMoney(input) {
-    return safe5(
+    return safe(
       this.client.linkPost(
         "/v1/link/mobile-money",
         toCreateMobileMoneyPayload(input)
@@ -1826,65 +1772,51 @@ var LinkService = class {
     );
   }
   async deleteMobileMoney(mobileMoneyId) {
-    return safe5(
+    return safe(
       this.client.linkDelete(
         `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}`
       )
     );
   }
   async setDefaultMobileMoney(mobileMoneyId) {
-    return safe5(
+    return safe(
       this.client.linkPost(
         `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/default`
       )
     );
   }
   async trackMobileMoneyUsage(mobileMoneyId) {
-    return safe5(
+    return safe(
       this.client.linkPost(
         `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/track-usage`
       )
     );
   }
   async verifyMobileMoney(mobileMoneyId) {
-    return safe5(
+    return safe(
       this.client.linkPost(
         `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/verify`
       )
     );
   }
   async getSessions() {
-    return safe5(this.client.linkGet("/v1/link/sessions"));
+    return safe(this.client.linkGet("/v1/link/sessions"));
   }
   async revokeSession(sessionId) {
-    return safe5(this.client.linkDelete(`/v1/link/sessions/${sessionId}`));
+    return safe(this.client.linkDelete(`/v1/link/sessions/${sessionId}`));
   }
   async revokeAllSessions() {
-    return safe5(this.client.linkDelete("/v1/link/sessions"));
+    return safe(this.client.linkDelete("/v1/link/sessions"));
   }
 };
 
 // src/auth.ts
-function toCimplifyError6(error) {
-  if (error instanceof CimplifyError) return error;
-  if (error instanceof Error) {
-    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
-  }
-  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
-}
-async function safe6(promise) {
-  try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError6(error));
-  }
-}
 var AuthService = class {
   constructor(client) {
     this.client = client;
   }
   async getStatus() {
-    return safe6(this.client.get("/api/v1/auth/status"));
+    return safe(this.client.get("/api/v1/auth/status"));
   }
   async getCurrentUser() {
     const result = await this.getStatus();
@@ -1897,7 +1829,7 @@ var AuthService = class {
     return ok(result.value.is_authenticated);
   }
   async requestOtp(contact, contactType) {
-    return safe6(
+    return safe(
       this.client.post("/api/v1/auth/request-otp", {
         contact,
         contact_type: contactType
@@ -1905,7 +1837,7 @@ var AuthService = class {
     );
   }
   async verifyOtp(code, contact) {
-    return safe6(
+    return safe(
       this.client.post("/api/v1/auth/verify-otp", {
         otp_code: code,
         contact
@@ -1913,48 +1845,34 @@ var AuthService = class {
     );
   }
   async logout() {
-    return safe6(this.client.post("/api/v1/auth/logout"));
+    return safe(this.client.post("/api/v1/auth/logout"));
   }
   async updateProfile(input) {
-    return safe6(this.client.post("/api/v1/auth/profile", input));
+    return safe(this.client.post("/api/v1/auth/profile", input));
   }
 };
 
 // src/business.ts
-function toCimplifyError7(error) {
-  if (error instanceof CimplifyError) return enrichError(error);
-  if (error instanceof Error) {
-    return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, error.message, false));
-  }
-  return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, String(error), false));
-}
-async function safe7(promise) {
-  try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError7(error));
-  }
-}
 var BusinessService = class {
   constructor(client) {
     this.client = client;
   }
   async getInfo() {
-    return safe7(this.client.get("/api/v1/business"));
+    return safe(this.client.get("/api/v1/business"));
   }
   async getByHandle(handle) {
     const encodedHandle = encodeURIComponent(handle);
-    return safe7(this.client.get(`/api/v1/business/by-handle/${encodedHandle}`));
+    return safe(this.client.get(`/api/v1/business/by-handle/${encodedHandle}`));
   }
   async getByDomain(domain) {
     const encodedDomain = encodeURIComponent(domain);
-    return safe7(this.client.get(`/api/v1/business/by-domain?domain=${encodedDomain}`));
+    return safe(this.client.get(`/api/v1/business/by-domain?domain=${encodedDomain}`));
   }
   async getSettings() {
-    return safe7(this.client.get("/api/v1/business/settings"));
+    return safe(this.client.get("/api/v1/business/settings"));
   }
   async getLocations() {
-    return safe7(this.client.get("/api/v1/business/locations"));
+    return safe(this.client.get("/api/v1/business/locations"));
   }
   async getLocation(locationId) {
     const result = await this.getLocations();
@@ -1966,7 +1884,7 @@ var BusinessService = class {
     return ok(location);
   }
   async getHours() {
-    return safe7(this.client.get("/api/v1/business/hours"));
+    return safe(this.client.get("/api/v1/business/hours"));
   }
   async getLocationHours(locationId) {
     const result = await this.getHours();
@@ -1974,25 +1892,11 @@ var BusinessService = class {
     return ok(result.value.filter((hour) => hour.location_id === locationId));
   }
   async getBootstrap() {
-    return safe7(this.client.get("/api/v1/bootstrap"));
+    return safe(this.client.get("/api/v1/bootstrap"));
   }
 };
 
 // src/inventory.ts
-function toCimplifyError8(error) {
-  if (error instanceof CimplifyError) return error;
-  if (error instanceof Error) {
-    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
-  }
-  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
-}
-async function safe8(promise) {
-  try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError8(error));
-  }
-}
 var InventoryService = class {
   constructor(client) {
     this.client = client;
@@ -2011,14 +1915,14 @@ var InventoryService = class {
     const path = this.withQuery(`/api/v1/inventory/products/${encodedId}/stock`, {
       location_id: locationId
     });
-    return safe8(this.client.get(path));
+    return safe(this.client.get(path));
   }
   async getVariantStock(variantId, locationId) {
     const encodedId = encodeURIComponent(variantId);
     const path = this.withQuery(`/api/v1/inventory/variants/${encodedId}/stock`, {
       location_id: locationId
     });
-    return safe8(this.client.get(path));
+    return safe(this.client.get(path));
   }
   async checkProductAvailability(productId, quantity, locationId) {
     const encodedId = encodeURIComponent(productId);
@@ -2026,7 +1930,7 @@ var InventoryService = class {
       quantity,
       location_id: locationId
     });
-    return safe8(this.client.get(path));
+    return safe(this.client.get(path));
   }
   async checkVariantAvailability(variantId, quantity, locationId) {
     const encodedId = encodeURIComponent(variantId);
@@ -2034,7 +1938,7 @@ var InventoryService = class {
       quantity,
       location_id: locationId
     });
-    return safe8(this.client.get(path));
+    return safe(this.client.get(path));
   }
   async checkMultipleAvailability(items, locationId) {
     const results = await Promise.all(
@@ -2060,20 +1964,6 @@ var InventoryService = class {
 };
 
 // src/scheduling.ts
-function toCimplifyError9(error) {
-  if (error instanceof CimplifyError) return error;
-  if (error instanceof Error) {
-    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
-  }
-  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
-}
-async function safe9(promise) {
-  try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError9(error));
-  }
-}
 function withQuery2(path, params) {
   const searchParams = new URLSearchParams();
   for (const [key, value] of Object.entries(params)) {
@@ -2091,11 +1981,11 @@ var SchedulingService = class {
     this.client = client;
   }
   async getServices() {
-    return safe9(this.client.get("/api/v1/scheduling/services"));
+    return safe(this.client.get("/api/v1/scheduling/services"));
   }
   async getService(serviceId) {
     const encodedId = encodeURIComponent(serviceId);
-    return safe9(this.client.get(`/api/v1/scheduling/services/${encodedId}`));
+    return safe(this.client.get(`/api/v1/scheduling/services/${encodedId}`));
   }
   async getAvailableSlots(input) {
     const path = withQuery2("/api/v1/scheduling/slots", {
@@ -2104,7 +1994,7 @@ var SchedulingService = class {
       participant_count: input.participant_count,
       duration_minutes: input.duration_minutes
     });
-    return safe9(this.client.get(path));
+    return safe(this.client.get(path));
   }
   async checkSlotAvailability(input) {
     const path = withQuery2("/api/v1/scheduling/slots/check", {
@@ -2113,7 +2003,7 @@ var SchedulingService = class {
       duration_minutes: input.duration_minutes,
       participant_count: input.participant_count
     });
-    return safe9(this.client.get(path));
+    return safe(this.client.get(path));
   }
   async getServiceAvailability(params) {
     const path = withQuery2("/api/v1/scheduling/availability", {
@@ -2123,17 +2013,17 @@ var SchedulingService = class {
       location_id: params.location_id,
       participant_count: params.participant_count
     });
-    return safe9(this.client.get(path));
+    return safe(this.client.get(path));
   }
   async getBooking(bookingId) {
     const encodedId = encodeURIComponent(bookingId);
-    return safe9(this.client.get(`/api/v1/scheduling/bookings/${encodedId}`));
+    return safe(this.client.get(`/api/v1/scheduling/bookings/${encodedId}`));
   }
   async getCustomerBookings(customerId) {
     const path = withQuery2("/api/v1/scheduling/bookings", {
       customer_id: customerId
     });
-    return safe9(this.client.get(path));
+    return safe(this.client.get(path));
   }
   async getUpcomingBookings() {
     const result = await this.getCustomerBookings();
@@ -2152,14 +2042,14 @@ var SchedulingService = class {
   }
   async cancelBooking(input) {
     const encodedId = encodeURIComponent(input.booking_id);
-    return safe9(
+    return safe(
       this.client.post(`/api/v1/scheduling/bookings/${encodedId}/cancel`, {
         reason: input.reason
       })
     );
   }
   async rescheduleBooking(input) {
-    return safe9(
+    return safe(
       this.client.post("/api/v1/scheduling/bookings/reschedule", input)
     );
   }
@@ -2183,65 +2073,37 @@ var SchedulingService = class {
 };
 
 // src/lite.ts
-function toCimplifyError10(error) {
-  if (error instanceof CimplifyError) return error;
-  if (error instanceof Error) {
-    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
-  }
-  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
-}
-async function safe10(promise) {
-  try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError10(error));
-  }
-}
 var LiteService = class {
   constructor(client) {
     this.client = client;
   }
   async getBootstrap() {
-    return safe10(this.client.get("/api/v1/lite/bootstrap"));
+    return safe(this.client.get("/api/v1/lite/bootstrap"));
   }
   async getTable(tableId) {
     const encodedId = encodeURIComponent(tableId);
-    return safe10(this.client.get(`/api/v1/lite/tables/${encodedId}`));
+    return safe(this.client.get(`/api/v1/lite/tables/${encodedId}`));
   }
   async getMenu() {
-    return safe10(this.client.get("/api/v1/lite/menu"));
+    return safe(this.client.get("/api/v1/lite/menu"));
   }
   async getMenuByCategory(categoryId) {
     const encodedId = encodeURIComponent(categoryId);
-    return safe10(this.client.get(`/api/v1/lite/menu/categories/${encodedId}`));
+    return safe(this.client.get(`/api/v1/lite/menu/categories/${encodedId}`));
   }
 };
 
 // src/fx.ts
-function toCimplifyError11(error) {
-  if (error instanceof CimplifyError) return error;
-  if (error instanceof Error) {
-    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
-  }
-  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
-}
-async function safe11(promise) {
-  try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError11(error));
-  }
-}
 var FxService = class {
   constructor(client) {
     this.client = client;
   }
   async getRate(from, to) {
     const path = `/api/v1/fx/rate?from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`;
-    return safe11(this.client.get(path));
+    return safe(this.client.get(path));
   }
   async lockQuote(request) {
-    return safe11(this.client.post("/api/v1/fx/quotes", request));
+    return safe(this.client.post("/api/v1/fx/quotes", request));
   }
 };
 
@@ -2356,6 +2218,11 @@ var CimplifyElements = class {
       window.addEventListener("message", this.boundHandleMessage);
     }
   }
+  debug(...args) {
+    if (this.client.isTestMode()) {
+      console.debug(...args);
+    }
+  }
   create(type, options = {}) {
     const existing = this.elements.get(type);
     if (existing) return existing;
@@ -2410,9 +2277,9 @@ var CimplifyElements = class {
   processCheckout(options) {
     let abortFn = null;
     const task = (async () => {
-      console.debug("[cimplify:checkout] processCheckout called", { cart_id: options.cart_id, order_type: options.order_type, location_id: options.location_id });
+      this.debug("[cimplify:checkout] processCheckout called", { cart_id: options.cart_id, order_type: options.order_type, location_id: options.location_id });
       if (this.checkoutInProgress) {
-        console.debug("[cimplify:checkout] BLOCKED: already processing");
+        this.debug("[cimplify:checkout] BLOCKED: already processing");
         return toCheckoutError(
           "ALREADY_PROCESSING",
           "Checkout is already in progress.",
@@ -2421,7 +2288,7 @@ var CimplifyElements = class {
       }
       this.checkoutInProgress = true;
       if (!options.cart_id) {
-        console.debug("[cimplify:checkout] BLOCKED: no cart_id");
+        this.debug("[cimplify:checkout] BLOCKED: no cart_id");
         this.checkoutInProgress = false;
         return toCheckoutError(
           "INVALID_CART",
@@ -2430,7 +2297,7 @@ var CimplifyElements = class {
         );
       }
       if (!options.order_type) {
-        console.debug("[cimplify:checkout] BLOCKED: no order_type");
+        this.debug("[cimplify:checkout] BLOCKED: no order_type");
         this.checkoutInProgress = false;
         return toCheckoutError(
           "ORDER_TYPE_REQUIRED",
@@ -2440,7 +2307,7 @@ var CimplifyElements = class {
       }
       const checkoutElement = this.elements.get(ELEMENT_TYPES.CHECKOUT) || this.elements.get(ELEMENT_TYPES.PAYMENT);
       if (!checkoutElement) {
-        console.debug("[cimplify:checkout] BLOCKED: no checkout element");
+        this.debug("[cimplify:checkout] BLOCKED: no checkout element");
         this.checkoutInProgress = false;
         return toCheckoutError(
           "NO_PAYMENT_ELEMENT",
@@ -2449,7 +2316,7 @@ var CimplifyElements = class {
         );
       }
       if (!checkoutElement.isMounted()) {
-        console.debug("[cimplify:checkout] BLOCKED: checkout element not mounted");
+        this.debug("[cimplify:checkout] BLOCKED: checkout element not mounted");
         this.checkoutInProgress = false;
         return toCheckoutError(
           "PAYMENT_NOT_MOUNTED",
@@ -2461,7 +2328,7 @@ var CimplifyElements = class {
       if (!isUnifiedCheckout) {
         const authElement = this.elements.get(ELEMENT_TYPES.AUTH);
         if (authElement && !this.accessToken) {
-          console.debug("[cimplify:checkout] BLOCKED: auth incomplete");
+          this.debug("[cimplify:checkout] BLOCKED: auth incomplete");
           this.checkoutInProgress = false;
           return toCheckoutError(
             "AUTH_INCOMPLETE",
@@ -2471,13 +2338,13 @@ var CimplifyElements = class {
         }
         const addressElement = this.elements.get(ELEMENT_TYPES.ADDRESS);
         if (addressElement) {
-          console.debug("[cimplify:checkout] getting address data...");
+          this.debug("[cimplify:checkout] getting address data...");
           await addressElement.getData();
-          console.debug("[cimplify:checkout] address data resolved", this.addressData);
+          this.debug("[cimplify:checkout] address data resolved", this.addressData);
         }
         await this.hydrateCustomerData();
       }
-      console.debug("[cimplify:checkout] customer data hydrated", { customerData: this.customerData, accountId: this.accountId, isUnifiedCheckout });
+      this.debug("[cimplify:checkout] customer data hydrated", { customerData: this.customerData, accountId: this.accountId, isUnifiedCheckout });
       const processMessage = {
         type: MESSAGE_TYPES.PROCESS_CHECKOUT,
         cart_id: options.cart_id,
@@ -2553,7 +2420,7 @@ var CimplifyElements = class {
             return;
           }
           if (message.type === MESSAGE_TYPES.CHECKOUT_COMPLETE) {
-            console.debug("[cimplify:checkout] received checkout_complete", { success: message.success, error: message.error });
+            this.debug("[cimplify:checkout] received checkout_complete", { success: message.success, error: message.error });
             settle({
               success: message.success,
               order: message.order,
@@ -2576,9 +2443,9 @@ var CimplifyElements = class {
           );
         };
         this.activeCheckoutAbort = abortFn;
-        console.debug("[cimplify:checkout] sending process_checkout to checkout iframe", { cart_id: processMessage.cart_id, order_type: processMessage.order_type, hasCustomer: !!processMessage.customer, hasAddress: !!processMessage.address, isUnifiedCheckout });
+        this.debug("[cimplify:checkout] sending process_checkout to checkout iframe", { cart_id: processMessage.cart_id, order_type: processMessage.order_type, hasCustomer: !!processMessage.customer, hasAddress: !!processMessage.address, isUnifiedCheckout });
         checkoutElement.sendMessage(processMessage);
-        console.debug("[cimplify:checkout] postMessage sent, waiting for checkout_complete...");
+        this.debug("[cimplify:checkout] postMessage sent, waiting for checkout_complete...");
       });
     })();
     const abortable = task;