@cimplify/sdk 0.3.0 → 0.3.2

package/dist/index.mjs

@@ -64,7 +64,91 @@ function isRetryableError(error) {
   return false;
 }
 
+// src/types/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok === true;
+}
+function isErr(result) {
+  return result.ok === false;
+}
+function mapResult(result, fn) {
+  return result.ok ? ok(fn(result.value)) : result;
+}
+function mapError(result, fn) {
+  return result.ok ? result : err(fn(result.error));
+}
+function flatMap(result, fn) {
+  return result.ok ? fn(result.value) : result;
+}
+function getOrElse(result, defaultFn) {
+  return result.ok ? result.value : defaultFn();
+}
+function unwrap(result) {
+  if (result.ok) {
+    return result.value;
+  }
+  throw result.error;
+}
+function toNullable(result) {
+  return result.ok ? result.value : void 0;
+}
+async function fromPromise(promise, mapError2) {
+  try {
+    const value = await promise;
+    return ok(value);
+  } catch (error) {
+    return err(mapError2(error));
+  }
+}
+function tryCatch(fn, mapError2) {
+  try {
+    return ok(fn());
+  } catch (error) {
+    return err(mapError2(error));
+  }
+}
+function combine(results) {
+  const values = [];
+  for (const result of results) {
+    if (!result.ok) {
+      return result;
+    }
+    values.push(result.value);
+  }
+  return ok(values);
+}
+function combineObject(results) {
+  const values = {};
+  for (const [key, result] of Object.entries(results)) {
+    if (!result.ok) {
+      return result;
+    }
+    values[key] = result.value;
+  }
+  return ok(values);
+}
+
 // src/catalogue.ts
+function toCimplifyError(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 safe(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError(error));
+  }
+}
 var CatalogueQueries = class {
   constructor(client) {
     this.client = client;
@@ -105,111 +189,125 @@ var CatalogueQueries = class {
     if (options?.offset) {
       query2 += `#offset(${options.offset})`;
     }
-    return this.client.query(query2);
+    return safe(this.client.query(query2));
   }
   async getProduct(id) {
-    return this.client.query(`products.${id}`);
+    return safe(this.client.query(`products.${id}`));
   }
   async getProductBySlug(slug) {
-    const products = await this.client.query(
-      `products[?(@.slug=='${slug}')]`
+    const result = await safe(
+      this.client.query(`products[?(@.slug=='${slug}')]`)
     );
-    if (!products.length) {
-      throw new Error(`Product not found: ${slug}`);
+    if (!result.ok) return result;
+    if (!result.value.length) {
+      return err(new CimplifyError("NOT_FOUND", `Product not found: ${slug}`, false));
     }
-    return products[0];
+    return ok(result.value[0]);
   }
   // --------------------------------------------------------------------------
   // VARIANTS
   // --------------------------------------------------------------------------
   async getVariants(productId) {
-    return this.client.query(`products.${productId}.variants`);
+    return safe(this.client.query(`products.${productId}.variants`));
   }
   async getVariantAxes(productId) {
-    return this.client.query(`products.${productId}.variant_axes`);
+    return safe(this.client.query(`products.${productId}.variant_axes`));
   }
   /**
    * Find a variant by axis selections (e.g., { "Size": "Large", "Color": "Red" })
    * Returns the matching variant or null if no match found.
    */
   async getVariantByAxisSelections(productId, selections) {
-    return this.client.query(`products.${productId}.variant`, {
-      axis_selections: selections
-    });
+    return safe(
+      this.client.query(`products.${productId}.variant`, {
+        axis_selections: selections
+      })
+    );
   }
   /**
    * Get a specific variant by its ID
    */
   async getVariantById(productId, variantId) {
-    return this.client.query(`products.${productId}.variant.${variantId}`);
+    return safe(this.client.query(`products.${productId}.variant.${variantId}`));
   }
   // --------------------------------------------------------------------------
   // ADD-ONS
   // --------------------------------------------------------------------------
   async getAddOns(productId) {
-    return this.client.query(`products.${productId}.add_ons`);
+    return safe(this.client.query(`products.${productId}.add_ons`));
   }
   // --------------------------------------------------------------------------
   // CATEGORIES
   // --------------------------------------------------------------------------
   async getCategories() {
-    return this.client.query("categories");
+    return safe(this.client.query("categories"));
   }
   async getCategory(id) {
-    return this.client.query(`categories.${id}`);
+    return safe(this.client.query(`categories.${id}`));
   }
   async getCategoryBySlug(slug) {
-    const categories = await this.client.query(`categories[?(@.slug=='${slug}')]`);
-    if (!categories.length) {
-      throw new Error(`Category not found: ${slug}`);
+    const result = await safe(
+      this.client.query(`categories[?(@.slug=='${slug}')]`)
+    );
+    if (!result.ok) return result;
+    if (!result.value.length) {
+      return err(new CimplifyError("NOT_FOUND", `Category not found: ${slug}`, false));
     }
-    return categories[0];
+    return ok(result.value[0]);
   }
   async getCategoryProducts(categoryId) {
-    return this.client.query(`products[?(@.category_id=='${categoryId}')]`);
+    return safe(this.client.query(`products[?(@.category_id=='${categoryId}')]`));
   }
   // --------------------------------------------------------------------------
   // COLLECTIONS
   // --------------------------------------------------------------------------
   async getCollections() {
-    return this.client.query("collections");
+    return safe(this.client.query("collections"));
   }
   async getCollection(id) {
-    return this.client.query(`collections.${id}`);
+    return safe(this.client.query(`collections.${id}`));
   }
   async getCollectionBySlug(slug) {
-    const collections = await this.client.query(`collections[?(@.slug=='${slug}')]`);
-    if (!collections.length) {
-      throw new Error(`Collection not found: ${slug}`);
+    const result = await safe(
+      this.client.query(`collections[?(@.slug=='${slug}')]`)
+    );
+    if (!result.ok) return result;
+    if (!result.value.length) {
+      return err(new CimplifyError("NOT_FOUND", `Collection not found: ${slug}`, false));
     }
-    return collections[0];
+    return ok(result.value[0]);
   }
   async getCollectionProducts(collectionId) {
-    return this.client.query(`collections.${collectionId}.products`);
+    return safe(this.client.query(`collections.${collectionId}.products`));
   }
   async searchCollections(query2, limit = 20) {
-    return this.client.query(
-      `collections[?(@.name contains '${query2}')]#limit(${limit})`
+    return safe(
+      this.client.query(`collections[?(@.name contains '${query2}')]#limit(${limit})`)
     );
   }
   // --------------------------------------------------------------------------
   // BUNDLES
   // --------------------------------------------------------------------------
   async getBundles() {
-    return this.client.query("bundles");
+    return safe(this.client.query("bundles"));
   }
   async getBundle(id) {
-    return this.client.query(`bundles.${id}`);
+    return safe(this.client.query(`bundles.${id}`));
   }
   async getBundleBySlug(slug) {
-    const bundles = await this.client.query(`bundles[?(@.slug=='${slug}')]`);
-    if (!bundles.length) {
-      throw new Error(`Bundle not found: ${slug}`);
+    const result = await safe(
+      this.client.query(`bundles[?(@.slug=='${slug}')]`)
+    );
+    if (!result.ok) return result;
+    if (!result.value.length) {
+      return err(new CimplifyError("NOT_FOUND", `Bundle not found: ${slug}`, false));
     }
-    return bundles[0];
+    return ok(result.value[0]);
   }
   async searchBundles(query2, limit = 20) {
-    return this.client.query(`bundles[?(@.name contains '${query2}')]#limit(${limit})`);
+    return safe(
+      this.client.query(`bundles[?(@.name contains '${query2}')]#limit(${limit})`)
+    );
   }
   // --------------------------------------------------------------------------
   // COMPOSITES (Build-Your-Own)
@@ -219,20 +317,22 @@ var CatalogueQueries = class {
     if (options?.limit) {
       query2 += `#limit(${options.limit})`;
     }
-    return this.client.query(query2);
+    return safe(this.client.query(query2));
   }
   async getComposite(id) {
-    return this.client.query(`composites.${id}`);
+    return safe(this.client.query(`composites.${id}`));
   }
   async getCompositeByProductId(productId) {
-    return this.client.query(`composites.by_product.${productId}`);
+    return safe(this.client.query(`composites.by_product.${productId}`));
   }
   async calculateCompositePrice(compositeId, selections, locationId) {
-    return this.client.call("composite.calculatePrice", {
-      composite_id: compositeId,
-      selections,
-      location_id: locationId
-    });
+    return safe(
+      this.client.call("composite.calculatePrice", {
+        composite_id: compositeId,
+        selections,
+        location_id: locationId
+      })
+    );
   }
   // --------------------------------------------------------------------------
   // SEARCH
@@ -244,14 +344,16 @@ var CatalogueQueries = class {
       searchQuery = `products[?(@.name contains '${query2}' && @.category_id=='${options.category}')]`;
     }
     searchQuery += `#limit(${limit})`;
-    return this.client.query(searchQuery);
+    return safe(this.client.query(searchQuery));
   }
   async searchProducts(query2, options) {
-    return this.client.call("catalogue.search", {
-      query: query2,
-      limit: options?.limit ?? 20,
-      category: options?.category
-    });
+    return safe(
+      this.client.call("catalogue.search", {
+        query: query2,
+        limit: options?.limit ?? 20,
+        category: options?.category
+      })
+    );
   }
   // --------------------------------------------------------------------------
   // MENU (Restaurant-specific)
@@ -264,99 +366,29 @@ var CatalogueQueries = class {
     if (options?.limit) {
       query2 += `#limit(${options.limit})`;
     }
-    return this.client.query(query2);
+    return safe(this.client.query(query2));
   }
   async getMenuCategory(categoryId) {
-    return this.client.query(`menu.category.${categoryId}`);
+    return safe(this.client.query(`menu.category.${categoryId}`));
   }
   async getMenuItem(itemId) {
-    return this.client.query(`menu.${itemId}`);
+    return safe(this.client.query(`menu.${itemId}`));
   }
 };
 
-// src/types/result.ts
-function ok(value) {
-  return { ok: true, value };
-}
-function err(error) {
-  return { ok: false, error };
-}
-function isOk(result) {
-  return result.ok === true;
-}
-function isErr(result) {
-  return result.ok === false;
-}
-function mapResult(result, fn) {
-  return result.ok ? ok(fn(result.value)) : result;
-}
-function mapError(result, fn) {
-  return result.ok ? result : err(fn(result.error));
-}
-function flatMap(result, fn) {
-  return result.ok ? fn(result.value) : result;
-}
-function getOrElse(result, defaultFn) {
-  return result.ok ? result.value : defaultFn();
-}
-function unwrap(result) {
-  if (result.ok) {
-    return result.value;
-  }
-  throw result.error;
-}
-function toNullable(result) {
-  return result.ok ? result.value : void 0;
-}
-async function fromPromise(promise, mapError2) {
-  try {
-    const value = await promise;
-    return ok(value);
-  } catch (error) {
-    return err(mapError2(error));
-  }
-}
-function tryCatch(fn, mapError2) {
-  try {
-    return ok(fn());
-  } catch (error) {
-    return err(mapError2(error));
-  }
-}
-function combine(results) {
-  const values = [];
-  for (const result of results) {
-    if (!result.ok) {
-      return result;
-    }
-    values.push(result.value);
-  }
-  return ok(values);
-}
-function combineObject(results) {
-  const values = {};
-  for (const [key, result] of Object.entries(results)) {
-    if (!result.ok) {
-      return result;
-    }
-    values[key] = result.value;
-  }
-  return ok(values);
-}
-
 // src/cart.ts
-function toCimplifyError(error) {
+function toCimplifyError2(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 safe(promise) {
+async function safe2(promise) {
   try {
     return ok(await promise);
   } catch (error) {
-    return err(toCimplifyError(error));
+    return err(toCimplifyError2(error));
   }
 }
 var CartOperations = class {
@@ -371,19 +403,19 @@ var CartOperations = class {
    * This is the main method for storefront display.
    */
   async get() {
-    return safe(this.client.query("cart#enriched"));
+    return safe2(this.client.query("cart#enriched"));
   }
   async getRaw() {
-    return safe(this.client.query("cart"));
+    return safe2(this.client.query("cart"));
   }
   async getItems() {
-    return safe(this.client.query("cart_items"));
+    return safe2(this.client.query("cart_items"));
   }
   async getCount() {
-    return safe(this.client.query("cart#count"));
+    return safe2(this.client.query("cart#count"));
   }
   async getTotal() {
-    return safe(this.client.query("cart#total"));
+    return safe2(this.client.query("cart#total"));
   }
   async getSummary() {
     const cartResult = await this.get();
@@ -427,10 +459,10 @@ var CartOperations = class {
    * ```
    */
   async addItem(input) {
-    return safe(this.client.call("cart.addItem", input));
+    return safe2(this.client.call("cart.addItem", input));
   }
   async updateItem(cartItemId, updates) {
-    return safe(
+    return safe2(
       this.client.call("cart.updateItem", {
         cart_item_id: cartItemId,
         ...updates
@@ -438,7 +470,7 @@ var CartOperations = class {
     );
   }
   async updateQuantity(cartItemId, quantity) {
-    return safe(
+    return safe2(
       this.client.call("cart.updateItemQuantity", {
         cart_item_id: cartItemId,
         quantity
@@ -446,27 +478,27 @@ var CartOperations = class {
     );
   }
   async removeItem(cartItemId) {
-    return safe(
+    return safe2(
       this.client.call("cart.removeItem", {
         cart_item_id: cartItemId
       })
     );
   }
   async clear() {
-    return safe(this.client.call("cart.clearCart"));
+    return safe2(this.client.call("cart.clearCart"));
   }
   // --------------------------------------------------------------------------
   // COUPONS & DISCOUNTS
   // --------------------------------------------------------------------------
   async applyCoupon(code) {
-    return safe(
+    return safe2(
       this.client.call("cart.applyCoupon", {
         coupon_code: code
       })
     );
   }
   async removeCoupon() {
-    return safe(this.client.call("cart.removeCoupon"));
+    return safe2(this.client.call("cart.removeCoupon"));
   }
   // --------------------------------------------------------------------------
   // CONVENIENCE METHODS
@@ -597,18 +629,18 @@ var DEFAULT_CURRENCY = "GHS";
 var DEFAULT_COUNTRY = "GHA";
 
 // src/checkout.ts
-function toCimplifyError2(error) {
+function toCimplifyError3(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 safe2(promise) {
+async function safe3(promise) {
   try {
     return ok(await promise);
   } catch (error) {
-    return err(toCimplifyError2(error));
+    return err(toCimplifyError3(error));
   }
 }
 var CheckoutService = class {
@@ -641,14 +673,14 @@ var CheckoutService = class {
    * ```
    */
   async process(data) {
-    return safe2(
+    return safe3(
       this.client.call(CHECKOUT_MUTATION.PROCESS, {
         checkout_data: data
       })
     );
   }
   async initializePayment(orderId, method) {
-    return safe2(
+    return safe3(
       this.client.call("order.initializePayment", {
         order_id: orderId,
         payment_method: method
@@ -656,17 +688,17 @@ var CheckoutService = class {
     );
   }
   async submitAuthorization(input) {
-    return safe2(
+    return safe3(
       this.client.call(PAYMENT_MUTATION.SUBMIT_AUTHORIZATION, input)
     );
   }
   async pollPaymentStatus(orderId) {
-    return safe2(
+    return safe3(
       this.client.call(PAYMENT_MUTATION.CHECK_STATUS, orderId)
     );
   }
   async updateOrderCustomer(orderId, customer) {
-    return safe2(
+    return safe3(
       this.client.call(ORDER_MUTATION.UPDATE_CUSTOMER, {
         order_id: orderId,
         ...customer
@@ -674,7 +706,7 @@ var CheckoutService = class {
     );
   }
   async verifyPayment(orderId) {
-    return safe2(
+    return safe3(
       this.client.call("order.verifyPayment", {
         order_id: orderId
       })
@@ -683,6 +715,20 @@ var CheckoutService = class {
 };
 
 // src/orders.ts
+function toCimplifyError4(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 safe4(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError4(error));
+  }
+}
 var OrderQueries = class {
   constructor(client) {
     this.client = client;
@@ -699,38 +745,40 @@ var OrderQueries = class {
     if (options?.offset) {
       query2 += `#offset(${options.offset})`;
     }
-    return this.client.query(query2);
+    return safe4(this.client.query(query2));
   }
   async get(orderId) {
-    return this.client.query(`orders.${orderId}`);
+    return safe4(this.client.query(`orders.${orderId}`));
   }
   async getRecent(limit = 5) {
-    return this.client.query(`orders#sort(created_at,desc)#limit(${limit})`);
+    return safe4(this.client.query(`orders#sort(created_at,desc)#limit(${limit})`));
   }
   async getByStatus(status) {
-    return this.client.query(`orders[?(@.status=='${status}')]`);
+    return safe4(this.client.query(`orders[?(@.status=='${status}')]`));
   }
   async cancel(orderId, reason) {
-    return this.client.call("order.cancelOrder", {
-      order_id: orderId,
-      reason
-    });
+    return safe4(
+      this.client.call("order.cancelOrder", {
+        order_id: orderId,
+        reason
+      })
+    );
   }
 };
 
 // src/link.ts
-function toCimplifyError3(error) {
+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 safe3(promise) {
+async function safe5(promise) {
   try {
     return ok(await promise);
   } catch (error) {
-    return err(toCimplifyError3(error));
+    return err(toCimplifyError5(error));
   }
 }
 var LinkService = class {
@@ -741,10 +789,10 @@ var LinkService = class {
   // AUTHENTICATION
   // --------------------------------------------------------------------------
   async requestOtp(input) {
-    return safe3(this.client.linkPost("/v1/link/auth/request-otp", input));
+    return safe5(this.client.linkPost("/v1/link/auth/request-otp", input));
   }
   async verifyOtp(input) {
-    const result = await safe3(
+    const result = await safe5(
       this.client.linkPost("/v1/link/auth/verify-otp", input)
     );
     if (result.ok && result.value.session_token) {
@@ -753,7 +801,7 @@ var LinkService = class {
     return result;
   }
   async logout() {
-    const result = await safe3(this.client.linkPost("/v1/link/auth/logout"));
+    const result = await safe5(this.client.linkPost("/v1/link/auth/logout"));
     if (result.ok) {
       this.client.clearSession();
     }
@@ -763,32 +811,32 @@ var LinkService = class {
   // STATUS & DATA
   // --------------------------------------------------------------------------
   async checkStatus(contact) {
-    return safe3(
+    return safe5(
       this.client.call(LINK_MUTATION.CHECK_STATUS, {
         contact
       })
     );
   }
   async getLinkData() {
-    return safe3(this.client.query(LINK_QUERY.DATA));
+    return safe5(this.client.query(LINK_QUERY.DATA));
   }
   async getAddresses() {
-    return safe3(this.client.query(LINK_QUERY.ADDRESSES));
+    return safe5(this.client.query(LINK_QUERY.ADDRESSES));
   }
   async getMobileMoney() {
-    return safe3(this.client.query(LINK_QUERY.MOBILE_MONEY));
+    return safe5(this.client.query(LINK_QUERY.MOBILE_MONEY));
   }
   async getPreferences() {
-    return safe3(this.client.query(LINK_QUERY.PREFERENCES));
+    return safe5(this.client.query(LINK_QUERY.PREFERENCES));
   }
   // --------------------------------------------------------------------------
   // ENROLLMENT
   // --------------------------------------------------------------------------
   async enroll(data) {
-    return safe3(this.client.call(LINK_MUTATION.ENROLL, data));
+    return safe5(this.client.call(LINK_MUTATION.ENROLL, data));
   }
   async enrollAndLinkOrder(data) {
-    return safe3(
+    return safe5(
       this.client.call(LINK_MUTATION.ENROLL_AND_LINK_ORDER, data)
     );
   }
@@ -796,25 +844,25 @@ var LinkService = class {
   // PREFERENCES
   // --------------------------------------------------------------------------
   async updatePreferences(preferences) {
-    return safe3(this.client.call(LINK_MUTATION.UPDATE_PREFERENCES, preferences));
+    return safe5(this.client.call(LINK_MUTATION.UPDATE_PREFERENCES, preferences));
   }
   // --------------------------------------------------------------------------
   // ADDRESSES
   // --------------------------------------------------------------------------
   async createAddress(input) {
-    return safe3(this.client.call(LINK_MUTATION.CREATE_ADDRESS, input));
+    return safe5(this.client.call(LINK_MUTATION.CREATE_ADDRESS, input));
   }
   async updateAddress(input) {
-    return safe3(this.client.call(LINK_MUTATION.UPDATE_ADDRESS, input));
+    return safe5(this.client.call(LINK_MUTATION.UPDATE_ADDRESS, input));
   }
   async deleteAddress(addressId) {
-    return safe3(this.client.call(LINK_MUTATION.DELETE_ADDRESS, addressId));
+    return safe5(this.client.call(LINK_MUTATION.DELETE_ADDRESS, addressId));
   }
   async setDefaultAddress(addressId) {
-    return safe3(this.client.call(LINK_MUTATION.SET_DEFAULT_ADDRESS, addressId));
+    return safe5(this.client.call(LINK_MUTATION.SET_DEFAULT_ADDRESS, addressId));
   }
   async trackAddressUsage(addressId) {
-    return safe3(
+    return safe5(
       this.client.call(LINK_MUTATION.TRACK_ADDRESS_USAGE, {
         address_id: addressId
       })
@@ -824,25 +872,25 @@ var LinkService = class {
   // MOBILE MONEY
   // --------------------------------------------------------------------------
   async createMobileMoney(input) {
-    return safe3(this.client.call(LINK_MUTATION.CREATE_MOBILE_MONEY, input));
+    return safe5(this.client.call(LINK_MUTATION.CREATE_MOBILE_MONEY, input));
   }
   async deleteMobileMoney(mobileMoneyId) {
-    return safe3(this.client.call(LINK_MUTATION.DELETE_MOBILE_MONEY, mobileMoneyId));
+    return safe5(this.client.call(LINK_MUTATION.DELETE_MOBILE_MONEY, mobileMoneyId));
   }
   async setDefaultMobileMoney(mobileMoneyId) {
-    return safe3(
+    return safe5(
       this.client.call(LINK_MUTATION.SET_DEFAULT_MOBILE_MONEY, mobileMoneyId)
     );
   }
   async trackMobileMoneyUsage(mobileMoneyId) {
-    return safe3(
+    return safe5(
       this.client.call(LINK_MUTATION.TRACK_MOBILE_MONEY_USAGE, {
         mobile_money_id: mobileMoneyId
       })
     );
   }
   async verifyMobileMoney(mobileMoneyId) {
-    return safe3(
+    return safe5(
       this.client.call(LINK_MUTATION.VERIFY_MOBILE_MONEY, mobileMoneyId)
     );
   }
@@ -850,46 +898,60 @@ var LinkService = class {
   // SESSIONS
   // --------------------------------------------------------------------------
   async getSessions() {
-    return safe3(this.client.linkGet("/v1/link/sessions"));
+    return safe5(this.client.linkGet("/v1/link/sessions"));
   }
   async revokeSession(sessionId) {
-    return safe3(this.client.linkDelete(`/v1/link/sessions/${sessionId}`));
+    return safe5(this.client.linkDelete(`/v1/link/sessions/${sessionId}`));
   }
   async revokeAllSessions() {
-    return safe3(this.client.linkDelete("/v1/link/sessions"));
+    return safe5(this.client.linkDelete("/v1/link/sessions"));
   }
   // --------------------------------------------------------------------------
   // REST ALTERNATIVES (for direct API access)
   // --------------------------------------------------------------------------
   async getAddressesRest() {
-    return safe3(this.client.linkGet("/v1/link/addresses"));
+    return safe5(this.client.linkGet("/v1/link/addresses"));
   }
   async createAddressRest(input) {
-    return safe3(this.client.linkPost("/v1/link/addresses", input));
+    return safe5(this.client.linkPost("/v1/link/addresses", input));
   }
   async deleteAddressRest(addressId) {
-    return safe3(this.client.linkDelete(`/v1/link/addresses/${addressId}`));
+    return safe5(this.client.linkDelete(`/v1/link/addresses/${addressId}`));
   }
   async setDefaultAddressRest(addressId) {
-    return safe3(this.client.linkPost(`/v1/link/addresses/${addressId}/default`));
+    return safe5(this.client.linkPost(`/v1/link/addresses/${addressId}/default`));
   }
   async getMobileMoneyRest() {
-    return safe3(this.client.linkGet("/v1/link/mobile-money"));
+    return safe5(this.client.linkGet("/v1/link/mobile-money"));
   }
   async createMobileMoneyRest(input) {
-    return safe3(this.client.linkPost("/v1/link/mobile-money", input));
+    return safe5(this.client.linkPost("/v1/link/mobile-money", input));
   }
   async deleteMobileMoneyRest(mobileMoneyId) {
-    return safe3(this.client.linkDelete(`/v1/link/mobile-money/${mobileMoneyId}`));
+    return safe5(this.client.linkDelete(`/v1/link/mobile-money/${mobileMoneyId}`));
   }
   async setDefaultMobileMoneyRest(mobileMoneyId) {
-    return safe3(
+    return safe5(
       this.client.linkPost(`/v1/link/mobile-money/${mobileMoneyId}/default`)
     );
   }
 };
 
 // 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;
@@ -898,52 +960,72 @@ var AuthService = class {
   // STATUS & USER
   // --------------------------------------------------------------------------
   async getStatus() {
-    return this.client.query("auth");
+    return safe6(this.client.query("auth"));
   }
   async getCurrentUser() {
-    const status = await this.getStatus();
-    return status.customer || null;
+    const result = await this.getStatus();
+    if (!result.ok) return result;
+    return ok(result.value.customer || null);
   }
   async isAuthenticated() {
-    const status = await this.getStatus();
-    return status.is_authenticated;
+    const result = await this.getStatus();
+    if (!result.ok) return result;
+    return ok(result.value.is_authenticated);
   }
   // --------------------------------------------------------------------------
   // OTP AUTHENTICATION
   // --------------------------------------------------------------------------
   async requestOtp(contact, contactType) {
-    await this.client.call(AUTH_MUTATION.REQUEST_OTP, {
-      contact,
-      contact_type: contactType
-    });
+    return safe6(
+      this.client.call(AUTH_MUTATION.REQUEST_OTP, {
+        contact,
+        contact_type: contactType
+      })
+    );
   }
   async verifyOtp(code, contact) {
-    return this.client.call(AUTH_MUTATION.VERIFY_OTP, {
-      otp_code: code,
-      contact
-    });
+    return safe6(
+      this.client.call(AUTH_MUTATION.VERIFY_OTP, {
+        otp_code: code,
+        contact
+      })
+    );
   }
   // --------------------------------------------------------------------------
   // SESSION MANAGEMENT
   // --------------------------------------------------------------------------
   async logout() {
-    return this.client.call("auth.logout");
+    return safe6(this.client.call("auth.logout"));
   }
   // --------------------------------------------------------------------------
   // PROFILE MANAGEMENT
   // --------------------------------------------------------------------------
   async updateProfile(input) {
-    return this.client.call("auth.update_profile", input);
+    return safe6(this.client.call("auth.update_profile", input));
   }
   async changePassword(input) {
-    return this.client.call("auth.change_password", input);
+    return safe6(this.client.call("auth.change_password", input));
   }
   async resetPassword(email) {
-    return this.client.call("auth.reset_password", { email });
+    return safe6(this.client.call("auth.reset_password", { email }));
   }
 };
 
 // src/business.ts
+function toCimplifyError7(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 safe7(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError7(error));
+  }
+}
 var BusinessService = class {
   constructor(client) {
     this.client = client;
@@ -952,49 +1034,55 @@ var BusinessService = class {
   // BUSINESS INFO
   // --------------------------------------------------------------------------
   async getInfo() {
-    return this.client.query("business.info");
+    return safe7(this.client.query("business.info"));
   }
   async getByHandle(handle) {
-    return this.client.query(`business.handle.${handle}`);
+    return safe7(this.client.query(`business.handle.${handle}`));
   }
   async getByDomain(domain) {
-    return this.client.query("business.domain", { domain });
+    return safe7(this.client.query("business.domain", { domain }));
   }
   async getSettings() {
-    return this.client.query("business.settings");
+    return safe7(this.client.query("business.settings"));
   }
   async getTheme() {
-    return this.client.query("business.theme");
+    return safe7(this.client.query("business.theme"));
   }
   // --------------------------------------------------------------------------
   // LOCATIONS
   // --------------------------------------------------------------------------
   async getLocations() {
-    return this.client.query("business.locations");
+    return safe7(this.client.query("business.locations"));
   }
   async getLocation(locationId) {
-    return this.client.query(`business.locations.${locationId}`);
+    return safe7(this.client.query(`business.locations.${locationId}`));
   }
   // --------------------------------------------------------------------------
   // HOURS
   // --------------------------------------------------------------------------
   async getHours() {
-    return this.client.query("business.hours");
+    return safe7(this.client.query("business.hours"));
   }
   async getLocationHours(locationId) {
-    return this.client.query(`business.locations.${locationId}.hours`);
+    return safe7(this.client.query(`business.locations.${locationId}.hours`));
   }
   // --------------------------------------------------------------------------
   // BOOTSTRAP (for storefront initialization)
   // --------------------------------------------------------------------------
   async getBootstrap() {
-    const [business, locations, categories] = await Promise.all([
+    const [businessResult, locationsResult, categoriesResult] = await Promise.all([
       this.getInfo(),
       this.getLocations(),
-      this.client.query("categories#select(id,name,slug)")
+      safe7(this.client.query("categories#select(id,name,slug)"))
     ]);
+    if (!businessResult.ok) return businessResult;
+    if (!locationsResult.ok) return locationsResult;
+    if (!categoriesResult.ok) return categoriesResult;
+    const business = businessResult.value;
+    const locations = locationsResult.value;
+    const categories = categoriesResult.value;
     const defaultLocation = locations[0];
-    return {
+    return ok({
       business,
       location: defaultLocation,
       locations,
@@ -1002,11 +1090,25 @@ var BusinessService = class {
       currency: business.default_currency,
       is_open: defaultLocation?.accepts_online_orders ?? false,
       accepts_orders: defaultLocation?.accepts_online_orders ?? false
-    };
+    });
   }
 };
 
 // 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;
@@ -1015,41 +1117,51 @@ var InventoryService = class {
   // STOCK QUERIES
   // --------------------------------------------------------------------------
   async getStockLevels() {
-    return this.client.query("inventory.stock_levels");
+    return safe8(this.client.query("inventory.stock_levels"));
   }
   async getProductStock(productId, locationId) {
     if (locationId) {
-      return this.client.query("inventory.product", {
-        product_id: productId,
-        location_id: locationId
-      });
+      return safe8(
+        this.client.query("inventory.product", {
+          product_id: productId,
+          location_id: locationId
+        })
+      );
     }
-    return this.client.query("inventory.product", {
-      product_id: productId
-    });
+    return safe8(
+      this.client.query("inventory.product", {
+        product_id: productId
+      })
+    );
   }
   async getVariantStock(variantId, locationId) {
-    return this.client.query("inventory.variant", {
-      variant_id: variantId,
-      location_id: locationId
-    });
+    return safe8(
+      this.client.query("inventory.variant", {
+        variant_id: variantId,
+        location_id: locationId
+      })
+    );
   }
   // --------------------------------------------------------------------------
   // AVAILABILITY CHECKS
   // --------------------------------------------------------------------------
   async checkProductAvailability(productId, quantity, locationId) {
-    return this.client.query("inventory.check_availability", {
-      product_id: productId,
-      quantity,
-      location_id: locationId
-    });
+    return safe8(
+      this.client.query("inventory.check_availability", {
+        product_id: productId,
+        quantity,
+        location_id: locationId
+      })
+    );
   }
   async checkVariantAvailability(variantId, quantity, locationId) {
-    return this.client.query("inventory.check_availability", {
-      variant_id: variantId,
-      quantity,
-      location_id: locationId
-    });
+    return safe8(
+      this.client.query("inventory.check_availability", {
+        variant_id: variantId,
+        quantity,
+        location_id: locationId
+      })
+    );
   }
   async checkMultipleAvailability(items, locationId) {
     const results = await Promise.all(
@@ -1057,28 +1169,47 @@ var InventoryService = class {
         (item) => item.variant_id ? this.checkVariantAvailability(item.variant_id, item.quantity, locationId) : this.checkProductAvailability(item.product_id, item.quantity, locationId)
       )
     );
-    return results;
+    for (const result of results) {
+      if (!result.ok) return result;
+    }
+    return ok(results.map((r) => r.value));
   }
   // --------------------------------------------------------------------------
   // SUMMARY
   // --------------------------------------------------------------------------
   async getSummary() {
-    return this.client.query("inventory.summary");
+    return safe8(this.client.query("inventory.summary"));
   }
   // --------------------------------------------------------------------------
   // CONVENIENCE METHODS
   // --------------------------------------------------------------------------
   async isInStock(productId, locationId) {
     const result = await this.checkProductAvailability(productId, 1, locationId);
-    return result.is_available;
+    if (!result.ok) return result;
+    return ok(result.value.is_available);
   }
   async getAvailableQuantity(productId, locationId) {
-    const stock = await this.getProductStock(productId, locationId);
-    return stock.available_quantity;
+    const result = await this.getProductStock(productId, locationId);
+    if (!result.ok) return result;
+    return ok(result.value.available_quantity);
   }
 };
 
 // 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));
+  }
+}
 var SchedulingService = class {
   constructor(client) {
     this.client = client;
@@ -1087,86 +1218,113 @@ var SchedulingService = class {
   // SERVICES
   // --------------------------------------------------------------------------
   async getServices() {
-    return this.client.query("scheduling.services");
+    return safe9(this.client.query("scheduling.services"));
   }
   /**
    * Get a specific service by ID
    * Note: Filters from all services client-side (no single-service endpoint)
    */
   async getService(serviceId) {
-    const services = await this.getServices();
-    return services.find((s) => s.id === serviceId) || null;
+    const result = await this.getServices();
+    if (!result.ok) return result;
+    return ok(result.value.find((s) => s.id === serviceId) || null);
   }
   // --------------------------------------------------------------------------
   // AVAILABILITY
   // --------------------------------------------------------------------------
   async getAvailableSlots(input) {
-    return this.client.query(
-      "scheduling.slots",
-      input
+    return safe9(
+      this.client.query(
+        "scheduling.slots",
+        input
+      )
     );
   }
   async checkSlotAvailability(input) {
-    return this.client.query(
-      "scheduling.check_availability",
-      input
+    return safe9(
+      this.client.query(
+        "scheduling.check_availability",
+        input
+      )
     );
   }
   async getServiceAvailability(params) {
-    return this.client.query(
-      "scheduling.availability",
-      params
+    return safe9(
+      this.client.query(
+        "scheduling.availability",
+        params
+      )
     );
   }
   // --------------------------------------------------------------------------
   // BOOKINGS
   // --------------------------------------------------------------------------
   async getBooking(bookingId) {
-    return this.client.query(`scheduling.${bookingId}`);
+    return safe9(this.client.query(`scheduling.${bookingId}`));
   }
   async getCustomerBookings() {
-    return this.client.query("scheduling");
+    return safe9(this.client.query("scheduling"));
   }
   async getUpcomingBookings() {
-    return this.client.query(
-      "scheduling[?(@.status!='completed' && @.status!='cancelled')]#sort(start_time,asc)"
+    return safe9(
+      this.client.query(
+        "scheduling[?(@.status!='completed' && @.status!='cancelled')]#sort(start_time,asc)"
+      )
     );
   }
   async getPastBookings(limit = 10) {
-    return this.client.query(
-      `scheduling[?(@.status=='completed')]#sort(start_time,desc)#limit(${limit})`
+    return safe9(
+      this.client.query(
+        `scheduling[?(@.status=='completed')]#sort(start_time,desc)#limit(${limit})`
+      )
     );
   }
   // --------------------------------------------------------------------------
   // BOOKING MANAGEMENT
   // --------------------------------------------------------------------------
   async cancelBooking(input) {
-    return this.client.call("scheduling.cancel_booking", input);
+    return safe9(this.client.call("scheduling.cancel_booking", input));
   }
   async rescheduleBooking(input) {
-    return this.client.call("scheduling.reschedule_booking", input);
+    return safe9(this.client.call("scheduling.reschedule_booking", input));
   }
   // --------------------------------------------------------------------------
   // CONVENIENCE METHODS
   // --------------------------------------------------------------------------
   async getNextAvailableSlot(serviceId, fromDate) {
     const date = fromDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    const slots = await this.getAvailableSlots({
+    const result = await this.getAvailableSlots({
       service_id: serviceId,
       date
     });
-    return slots.find((slot) => slot.is_available) || null;
+    if (!result.ok) return result;
+    return ok(result.value.find((slot) => slot.is_available) || null);
   }
   async hasAvailabilityOn(serviceId, date) {
-    const slots = await this.getAvailableSlots({
+    const result = await this.getAvailableSlots({
       service_id: serviceId,
       date
     });
-    return slots.some((slot) => slot.is_available);
+    if (!result.ok) return result;
+    return ok(result.value.some((slot) => slot.is_available));
   }
 };
 
 // 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;
@@ -1175,54 +1333,107 @@ var LiteService = class {
   // BOOTSTRAP
   // --------------------------------------------------------------------------
   async getBootstrap() {
-    return this.client.query("lite.bootstrap");
+    return safe10(this.client.query("lite.bootstrap"));
   }
   // --------------------------------------------------------------------------
   // TABLE MANAGEMENT
   // --------------------------------------------------------------------------
   async getTable(tableId) {
-    return this.client.query(`lite.table.${tableId}`);
+    return safe10(this.client.query(`lite.table.${tableId}`));
   }
   async getTableByNumber(tableNumber, locationId) {
-    return this.client.query("lite.table_by_number", {
-      table_number: tableNumber,
-      location_id: locationId
-    });
+    return safe10(
+      this.client.query("lite.table_by_number", {
+        table_number: tableNumber,
+        location_id: locationId
+      })
+    );
   }
   // --------------------------------------------------------------------------
   // KITCHEN ORDERS
   // --------------------------------------------------------------------------
   async sendToKitchen(tableId, items) {
-    return this.client.call("lite.send_to_kitchen", {
-      table_id: tableId,
-      items
-    });
+    return safe10(
+      this.client.call("lite.send_to_kitchen", {
+        table_id: tableId,
+        items
+      })
+    );
   }
   async callWaiter(tableId, reason) {
-    return this.client.call("lite.call_waiter", {
-      table_id: tableId,
-      reason
-    });
+    return safe10(
+      this.client.call("lite.call_waiter", {
+        table_id: tableId,
+        reason
+      })
+    );
   }
   async requestBill(tableId) {
-    return this.client.call("lite.request_bill", {
-      table_id: tableId
-    });
+    return safe10(
+      this.client.call("lite.request_bill", {
+        table_id: tableId
+      })
+    );
   }
   // --------------------------------------------------------------------------
   // MENU (optimized for lite/QR experience)
   // --------------------------------------------------------------------------
   async getMenu() {
-    return this.client.query("lite.menu");
+    return safe10(this.client.query("lite.menu"));
   }
   async getMenuByCategory(categoryId) {
-    return this.client.query(`lite.menu.category.${categoryId}`);
+    return safe10(this.client.query(`lite.menu.category.${categoryId}`));
   }
 };
 
 // src/client.ts
 var SESSION_TOKEN_HEADER = "x-session-token";
 var SESSION_STORAGE_KEY = "cimplify_session_token";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_RETRY_DELAY_MS = 1e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryable(error) {
+  if (error instanceof TypeError && error.message.includes("fetch")) {
+    return true;
+  }
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return true;
+  }
+  if (error instanceof CimplifyError) {
+    return error.retryable;
+  }
+  if (error instanceof CimplifyError && error.code === "SERVER_ERROR") {
+    return true;
+  }
+  return false;
+}
+function toNetworkError(error) {
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return new CimplifyError(
+      ErrorCode.TIMEOUT,
+      "Request timed out. Please check your connection and try again.",
+      true
+    );
+  }
+  if (error instanceof TypeError && error.message.includes("fetch")) {
+    return new CimplifyError(
+      ErrorCode.NETWORK_ERROR,
+      "Network error. Please check your internet connection.",
+      true
+    );
+  }
+  if (error instanceof CimplifyError) {
+    return error;
+  }
+  return new CimplifyError(
+    ErrorCode.UNKNOWN_ERROR,
+    error instanceof Error ? error.message : "An unknown error occurred",
+    false
+  );
+}
 function deriveUrls() {
   const hostname = typeof window !== "undefined" ? window.location.hostname : "";
   if (hostname === "localhost" || hostname === "127.0.0.1") {
@@ -1245,6 +1456,9 @@ var CimplifyClient = class {
     this.baseUrl = urls.baseUrl;
     this.linkApiUrl = urls.linkApiUrl;
     this.credentials = config.credentials || "include";
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.retryDelay = config.retryDelay ?? DEFAULT_RETRY_DELAY_MS;
     this.sessionToken = this.loadSessionToken();
   }
   getSessionToken() {
@@ -1290,12 +1504,47 @@ var CimplifyClient = class {
       this.saveSessionToken(newToken);
     }
   }
+  /**
+   * Resilient fetch with timeout and automatic retries for network errors.
+   * Uses exponential backoff: 1s, 2s, 4s between retries.
+   */
+  async resilientFetch(url, options) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(url, {
+          ...options,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (response.ok || response.status >= 400 && response.status < 500) {
+          return response;
+        }
+        if (response.status >= 500 && attempt < this.maxRetries) {
+          const delay = this.retryDelay * Math.pow(2, attempt);
+          await sleep(delay);
+          continue;
+        }
+        return response;
+      } catch (error) {
+        lastError = error;
+        if (!isRetryable(error) || attempt >= this.maxRetries) {
+          throw toNetworkError(error);
+        }
+        const delay = this.retryDelay * Math.pow(2, attempt);
+        await sleep(delay);
+      }
+    }
+    throw toNetworkError(lastError);
+  }
   async query(query2, variables) {
     const body = { query: query2 };
     if (variables) {
       body.variables = variables;
     }
-    const response = await fetch(`${this.baseUrl}/api/q`, {
+    const response = await this.resilientFetch(`${this.baseUrl}/api/q`, {
       method: "POST",
       credentials: this.credentials,
       headers: this.getHeaders(),
@@ -1309,7 +1558,7 @@ var CimplifyClient = class {
       method,
       args: args !== void 0 ? [args] : []
     };
-    const response = await fetch(`${this.baseUrl}/api/m`, {
+    const response = await this.resilientFetch(`${this.baseUrl}/api/m`, {
       method: "POST",
       credentials: this.credentials,
       headers: this.getHeaders(),
@@ -1319,7 +1568,7 @@ var CimplifyClient = class {
     return this.handleResponse(response);
   }
   async get(path) {
-    const response = await fetch(`${this.baseUrl}${path}`, {
+    const response = await this.resilientFetch(`${this.baseUrl}${path}`, {
       method: "GET",
       credentials: this.credentials,
       headers: this.getHeaders()
@@ -1328,7 +1577,7 @@ var CimplifyClient = class {
     return this.handleRestResponse(response);
   }
   async post(path, body) {
-    const response = await fetch(`${this.baseUrl}${path}`, {
+    const response = await this.resilientFetch(`${this.baseUrl}${path}`, {
       method: "POST",
       credentials: this.credentials,
       headers: this.getHeaders(),
@@ -1338,7 +1587,7 @@ var CimplifyClient = class {
     return this.handleRestResponse(response);
   }
   async delete(path) {
-    const response = await fetch(`${this.baseUrl}${path}`, {
+    const response = await this.resilientFetch(`${this.baseUrl}${path}`, {
       method: "DELETE",
       credentials: this.credentials,
       headers: this.getHeaders()
@@ -1347,7 +1596,7 @@ var CimplifyClient = class {
     return this.handleRestResponse(response);
   }
   async linkGet(path) {
-    const response = await fetch(`${this.linkApiUrl}${path}`, {
+    const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
       method: "GET",
       credentials: this.credentials,
       headers: this.getHeaders()
@@ -1356,7 +1605,7 @@ var CimplifyClient = class {
     return this.handleRestResponse(response);
   }
   async linkPost(path, body) {
-    const response = await fetch(`${this.linkApiUrl}${path}`, {
+    const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
       method: "POST",
       credentials: this.credentials,
       headers: this.getHeaders(),
@@ -1366,7 +1615,7 @@ var CimplifyClient = class {
     return this.handleRestResponse(response);
   }
   async linkDelete(path) {
-    const response = await fetch(`${this.linkApiUrl}${path}`, {
+    const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
       method: "DELETE",
       credentials: this.credentials,
       headers: this.getHeaders()