@thorprovider/adapters 4.1.0 → 4.2.1

package/dist/index.js

@@ -44,17 +44,21 @@ __export(src_exports, {
   ConfigurationError: () => ConfigurationError,
   MAGENTO_CAPABILITIES: () => MAGENTO_CAPABILITIES,
   MEDUSA_CAPABILITIES: () => MEDUSA_CAPABILITIES,
+  MOCK_CAPABILITIES: () => MOCK_CAPABILITIES,
   MagentoProvider: () => MagentoProvider,
   MedusaMetadataAdapter: () => MedusaMetadataAdapter,
   MedusaProvider: () => MedusaProvider,
   MetricsService: () => MetricsService,
+  MockProvider: () => MockProvider,
   ProviderAPIError: () => ProviderAPIError,
   ProviderNotFoundError: () => ProviderNotFoundError,
   ResourceNotFoundError: () => ResourceNotFoundError,
   SHOPIFY_CAPABILITIES: () => SHOPIFY_CAPABILITIES,
   SPREE_CAPABILITIES: () => SPREE_CAPABILITIES,
+  STELORDER_CAPABILITIES: () => STELORDER_CAPABILITIES,
   ShopifyProvider: () => ShopifyProvider,
   SpreeProvider: () => SpreeProvider,
+  StelOrderProvider: () => StelOrderProvider,
   StorefrontConfigError: () => import_types2.StorefrontConfigError,
   WOOCOMMERCE_CAPABILITIES: () => WOOCOMMERCE_CAPABILITIES,
   WooCommerceProvider: () => WooCommerceProvider,
@@ -94,6 +98,31 @@ module.exports = __toCommonJS(src_exports);
 var import_types2 = require("@thorprovider/types");
 
 // src/types/capabilities.types.ts
+var MOCK_CAPABILITIES = {
+  updateProfile: false,
+  updateEmail: false,
+  changePasswordDirect: false,
+  changePasswordViaEmail: false,
+  deleteAccount: false,
+  uploadAvatar: false,
+  avatarViaMetadata: false,
+  customAttributes: false,
+  fetchOrders: true,
+  cancelOrder: true,
+  manageAddresses: false,
+  defaultAddress: false,
+  applyDiscounts: true,
+  shippingCalculation: true,
+  guestCheckout: true,
+  savedPaymentMethods: false,
+  listPaymentProviders: true,
+  regionSpecificPayments: true,
+  wishlist: false,
+  advancedSearch: false,
+  facetedFilters: false,
+  productReviews: false,
+  loyaltyProgram: false
+};
 var MEDUSA_CAPABILITIES = {
   // Profile Management
   updateProfile: true,
@@ -136,6 +165,41 @@ var MEDUSA_CAPABILITIES = {
   loyaltyProgram: false
   // Requires custom implementation
 };
+var STELORDER_CAPABILITIES = {
+  // Profile Management
+  updateProfile: false,
+  updateEmail: false,
+  changePasswordDirect: false,
+  changePasswordViaEmail: false,
+  deleteAccount: false,
+  // Avatar
+  uploadAvatar: false,
+  avatarViaMetadata: false,
+  // Custom Attributes
+  customAttributes: false,
+  // Orders
+  fetchOrders: true,
+  cancelOrder: false,
+  // Addresses
+  manageAddresses: true,
+  defaultAddress: false,
+  // Cart/Checkout
+  applyDiscounts: false,
+  shippingCalculation: false,
+  guestCheckout: false,
+  savedPaymentMethods: false,
+  listPaymentProviders: true,
+  regionSpecificPayments: false,
+  // Wishlist
+  wishlist: false,
+  // Search
+  advancedSearch: false,
+  facetedFilters: false,
+  // Reviews
+  productReviews: false,
+  // Loyalty
+  loyaltyProgram: false
+};
 var SHOPIFY_CAPABILITIES = {
   // Profile Management
   updateProfile: true,
@@ -8042,6 +8106,2036 @@ var MagentoProvider = class {
   }
 };
 
+// src/providers/stelorder/transforms.ts
+function normalizeStelCollection(payload) {
+  if (!payload) {
+    return [];
+  }
+  return Array.isArray(payload) ? payload : [payload];
+}
+function normalizeStelEntity(payload) {
+  if (!payload) {
+    return void 0;
+  }
+  return Array.isArray(payload) ? payload[0] : payload;
+}
+function transformStelMoney(amount, currencyCode = "USD") {
+  const normalizedAmount = typeof amount === "string" ? Number.parseFloat(amount) : amount ?? 0;
+  return {
+    amount: Number.isFinite(normalizedAmount) ? normalizedAmount.toFixed(2) : "0.00",
+    currencyCode: currencyCode.toUpperCase()
+  };
+}
+function transformStelImage(url, altText = "") {
+  const normalizedUrl = url?.trim();
+  if (!normalizedUrl) {
+    return void 0;
+  }
+  return {
+    url: normalizedUrl,
+    altText,
+    width: 800,
+    height: 800
+  };
+}
+function normalizeStelDate(value) {
+  if (!value) {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? (/* @__PURE__ */ new Date()).toISOString() : parsed.toISOString();
+}
+function toStelStringId(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  return String(value);
+}
+function slugify(value) {
+  return value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function buildStelHandle(...candidates) {
+  for (const candidate of candidates) {
+    if (candidate === null || candidate === void 0) {
+      continue;
+    }
+    const normalized = slugify(String(candidate).trim());
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return "stel-item";
+}
+function transformStelProductImages(product) {
+  const images = [];
+  if (!product["item-images"]) {
+    return images;
+  }
+  const sorted = [...product["item-images"]].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  for (const img of sorted) {
+    const transformed = transformStelImage(img["item-image-path"], product.name ?? "");
+    if (transformed) {
+      images.push(transformed);
+    }
+  }
+  return images;
+}
+function deriveStelStockStatus(product) {
+  if (!product["stock-enabled"]) {
+    return "in_stock";
+  }
+  const realStock = product["real-stock"] ?? 0;
+  const minimumStock = product["minimum-stock"] ?? 0;
+  if (realStock <= 0) {
+    return "out_of_stock";
+  }
+  if (realStock <= minimumStock) {
+    return "low_stock";
+  }
+  return "in_stock";
+}
+function buildSyntheticVariant(product, currencyCode) {
+  const price = transformStelMoney(product["sales-price"], currencyCode);
+  const stockStatus = deriveStelStockStatus(product);
+  const quantityAvailable = product["stock-enabled"] ? product["real-stock"] ?? 0 : void 0;
+  const image = product["item-images"]?.[0] ? transformStelImage(product["item-images"][0]["item-image-path"], product.name ?? "") : void 0;
+  return {
+    id: toStelStringId(product.id),
+    title: "Default",
+    sku: product.barcode ?? product["full-reference"] ?? void 0,
+    availableForSale: stockStatus !== "out_of_stock",
+    selectedOptions: [],
+    price,
+    compareAtPrice: void 0,
+    quantityAvailable,
+    stockStatus,
+    image
+  };
+}
+function transformStelProduct(raw, currencyCode) {
+  const id = toStelStringId(raw.id);
+  const handle = buildStelHandle(raw["full-reference"], raw.reference, raw.name, raw.id);
+  const price = transformStelMoney(raw["sales-price"], currencyCode);
+  const images = transformStelProductImages(raw);
+  const variant = buildSyntheticVariant(raw, currencyCode);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id,
+    handle,
+    title: raw.name ?? "",
+    description: raw.description ?? "",
+    availableForSale: variant.availableForSale,
+    options: [],
+    variants: [variant],
+    featuredImage: images[0],
+    images,
+    priceRange: {
+      minVariantPrice: price,
+      maxVariantPrice: price
+    },
+    productType: void 0,
+    vendor: void 0,
+    tags: raw.promotional ? ["promotional"] : [],
+    createdAt: normalizeStelDate(raw["creation-date"]),
+    updatedAt: normalizeStelDate(raw["utc-last-modification-date"]) || now,
+    metadata: {
+      stelFullReference: raw["full-reference"],
+      stelReference: raw.reference,
+      stelBarcode: raw.barcode,
+      stelCategoryId: raw["product-category-id"],
+      stelInactive: raw.inactive,
+      stelPromotional: raw.promotional,
+      stelPurchasePrice: raw["purchase-price"]
+    }
+  };
+}
+function transformStelCategory(raw) {
+  const id = toStelStringId(raw.id);
+  const handle = buildStelHandle(raw.slug, raw.name, raw.id);
+  return {
+    id,
+    name: raw.name ?? "",
+    handle,
+    description: raw.description ?? void 0,
+    parentCategoryId: raw["parent-category-id"] ? toStelStringId(raw["parent-category-id"]) : void 0,
+    metadata: {
+      stelSlug: raw.slug
+    }
+  };
+}
+function transformStelCategoryToCollection(raw) {
+  const id = toStelStringId(raw.id);
+  const handle = buildStelHandle(raw.slug, raw.name, raw.id);
+  return {
+    id,
+    handle,
+    title: raw.name ?? "",
+    description: raw.description ?? "",
+    path: `/collections/${handle}`,
+    updatedAt: normalizeStelDate(raw["utc-last-modification-date"])
+  };
+}
+function transformStelWarehouseToStockLocation(raw) {
+  return {
+    id: toStelStringId(raw.id),
+    name: raw.name ?? "Warehouse"
+  };
+}
+function transformStelProductWarehouseToInventoryLevel(pw) {
+  return {
+    locationId: toStelStringId(pw["warehouse-id"]),
+    locationName: pw["warehouse-path"] ?? `Warehouse ${pw["warehouse-id"] ?? "unknown"}`,
+    availableQuantity: pw["real-stock"] ?? 0,
+    reservedQuantity: Math.max(0, (pw["virtual-stock"] ?? 0) - (pw["real-stock"] ?? 0)),
+    stockedQuantity: pw["virtual-stock"] ?? pw["real-stock"] ?? 0
+  };
+}
+function splitStelName(fullName) {
+  if (!fullName?.trim()) {
+    return { firstName: "", lastName: "" };
+  }
+  const parts = fullName.trim().split(/\s+/);
+  const firstName = parts[0] ?? "";
+  const lastName = parts.length > 1 ? parts.slice(1).join(" ") : "";
+  return { firstName, lastName };
+}
+function transformStelClient(raw) {
+  const { firstName, lastName } = splitStelName(raw.name ?? raw["business-name"]);
+  return {
+    id: toStelStringId(raw.id),
+    email: raw.email ?? "",
+    firstName: firstName || null,
+    lastName: lastName || null,
+    phone: raw.phone ?? raw.mobile ?? null,
+    hasAccount: true,
+    createdAt: normalizeStelDate(raw["utc-last-modification-date"]),
+    updatedAt: normalizeStelDate(raw["utc-last-modification-date"]),
+    metadata: {
+      stelBusinessName: raw["business-name"],
+      stelRateId: raw["rate-id"],
+      stelPaymentOptionId: raw["payment-option-id"],
+      stelPaymentTermId: raw["payment-term-id"],
+      stelDeliveryOptionId: raw["delivery-option-id"]
+    }
+  };
+}
+function deriveStelOrderStatus(raw) {
+  if (raw.deleted) {
+    return "cancelled";
+  }
+  const status = (raw.status ?? "").toLowerCase();
+  if (status.includes("cancel") || status.includes("anulad")) {
+    return "cancelled";
+  }
+  if (status.includes("complet") || status.includes("cerrad") || status.includes("settled")) {
+    return "completed";
+  }
+  if (status.includes("process") || status.includes("confirm")) {
+    return "processing";
+  }
+  return "pending";
+}
+function deriveStelPaymentStatus(raw) {
+  const orderStatus = deriveStelOrderStatus(raw);
+  if (orderStatus === "completed") {
+    return "paid";
+  }
+  if (orderStatus === "cancelled") {
+    return "pending";
+  }
+  return "pending";
+}
+function deriveStelFulfillmentStatus(raw) {
+  const orderStatus = deriveStelOrderStatus(raw);
+  if (orderStatus === "completed") {
+    return "fulfilled";
+  }
+  return "unfulfilled";
+}
+function transformStelDocumentLine(line, index, currencyCode) {
+  const unitPrice = line["item-base-price"] ?? 0;
+  const quantity = line.units ?? 1;
+  const lineTotal = unitPrice * quantity;
+  return {
+    id: toStelStringId(line["item-id"] ?? index),
+    title: line["item-name"] ?? "",
+    variantTitle: void 0,
+    quantity,
+    price: transformStelMoney(unitPrice, currencyCode),
+    total: transformStelMoney(lineTotal, currencyCode),
+    sku: void 0,
+    productId: line["item-id"] ? toStelStringId(line["item-id"]) : void 0
+  };
+}
+function transformStelSalesOrder(raw, currencyCode) {
+  const id = toStelStringId(raw.id);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const items = (raw["document-lines"] ?? []).filter((line) => line["line-type"] === "ITEM" || !line["line-type"]).map((line, i) => transformStelDocumentLine(line, i, currencyCode));
+  const status = deriveStelOrderStatus(raw);
+  return {
+    id,
+    orderNumber: raw.reference ?? id,
+    email: raw.email ?? "",
+    status,
+    paymentStatus: deriveStelPaymentStatus(raw),
+    fulfillmentStatus: deriveStelFulfillmentStatus(raw),
+    customerId: raw["client-id"] ? toStelStringId(raw["client-id"]) : void 0,
+    items,
+    subtotal: transformStelMoney(raw["total-base"], currencyCode),
+    total: transformStelMoney(raw.total, currencyCode),
+    tax: raw["total-tax"] != null ? transformStelMoney(raw["total-tax"], currencyCode) : void 0,
+    createdAt: normalizeStelDate(raw["creation-date"]),
+    updatedAt: normalizeStelDate(raw["utc-last-modification-date"]) || now,
+    cancelledAt: status === "cancelled" ? normalizeStelDate(raw["utc-last-modification-date"]) : void 0,
+    completedAt: status === "completed" ? normalizeStelDate(raw["utc-last-modification-date"]) : void 0,
+    metadata: {
+      stelReference: raw.reference,
+      stelStatus: raw.status,
+      stelPaymentOptionId: raw["payment-option-id"],
+      stelPaymentTermId: raw["payment-term-id"],
+      stelDeliveryOptionId: raw["delivery-option-id"]
+    }
+  };
+}
+function inferPaymentMethodType(name) {
+  if (!name) {
+    return "other";
+  }
+  const lower = name.toLowerCase();
+  if (lower.includes("transfer") || lower.includes("bank") || lower.includes("sepa") || lower.includes("iban")) {
+    return "bank_transfer";
+  }
+  if (lower.includes("card") || lower.includes("tarjeta") || lower.includes("visa") || lower.includes("master")) {
+    return "card";
+  }
+  if (lower.includes("paypal") || lower.includes("wallet") || lower.includes("apple") || lower.includes("google")) {
+    return "wallet";
+  }
+  if (lower.includes("cash") || lower.includes("contrar") || lower.includes("efectivo") || lower.includes("cod")) {
+    return "cash_on_delivery";
+  }
+  if (lower.includes("crypto") || lower.includes("bitcoin")) {
+    return "crypto";
+  }
+  return "other";
+}
+function transformStelPaymentOption(raw) {
+  return {
+    id: toStelStringId(raw.id),
+    name: raw.name ?? "Payment Option",
+    type: inferPaymentMethodType(raw.name),
+    isEnabled: !raw.deleted,
+    requiresSetup: false,
+    description: raw.description ?? void 0,
+    metadata: {
+      stelPath: raw.path,
+      source: "paymentOption"
+    }
+  };
+}
+function transformStelDeliveryOption(raw, currencyCode) {
+  return {
+    id: toStelStringId(raw.id),
+    name: raw.name ?? "Delivery Option",
+    price: transformStelMoney(0, currencyCode),
+    description: raw.description ?? void 0
+  };
+}
+
+// src/providers/stelorder/client.ts
+var DEFAULT_RETRY_CONFIG2 = {
+  maxRetries: 2,
+  initialDelayMs: 300,
+  backoffMultiplier: 2,
+  maxDelayMs: 5e3,
+  timeoutMs: 1e4,
+  retryableStatusCodes: [408, 429, 500, 502, 503, 504]
+};
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function calculateDelay2(attempt, retryConfig) {
+  const delay = retryConfig.initialDelayMs * Math.pow(retryConfig.backoffMultiplier, attempt);
+  return Math.min(delay, retryConfig.maxDelayMs);
+}
+function isRetryableError2(error, retryConfig) {
+  if (error instanceof ProviderAPIError) {
+    return typeof error.status === "number" && retryConfig.retryableStatusCodes.includes(error.status);
+  }
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message.toLowerCase();
+  return error.name === "AbortError" || error.name === "TimeoutError" || message.includes("fetch failed") || message.includes("timeout") || message.includes("econnrefused") || message.includes("etimedout");
+}
+function createRetryingFetch(fetchImplementation, retryConfig, logger2) {
+  return async (url, init) => {
+    let lastError = new Error("Unknown STEL Order request error");
+    for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt += 1) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), retryConfig.timeoutMs);
+      try {
+        const response = await fetchImplementation(url, {
+          ...init,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok && retryConfig.retryableStatusCodes.includes(response.status)) {
+          throw new ProviderAPIError(
+            `STEL Order API error: ${response.status} ${response.statusText}`,
+            "stelorder",
+            response.status
+          );
+        }
+        return response;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        lastError = error;
+        if (attempt >= retryConfig.maxRetries || !isRetryableError2(error, retryConfig)) {
+          throw error;
+        }
+        const delay = calculateDelay2(attempt, retryConfig);
+        logger2.warn("STEL request failed, retrying.", {
+          url,
+          attempt: attempt + 1,
+          maxAttempts: retryConfig.maxRetries + 1,
+          nextRetryIn: delay,
+          error: extractErrorMessage(error)
+        });
+        await sleep2(delay);
+      }
+    }
+    throw lastError;
+  };
+}
+async function parseErrorResponse(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  try {
+    if (contentType.includes("application/json")) {
+      const body = await response.json();
+      const message = extractErrorMessage(body);
+      if (message && message !== "An unknown error occurred") {
+        return message;
+      }
+    }
+  } catch {
+  }
+  try {
+    const text = await response.text();
+    if (text.trim()) {
+      return text.trim();
+    }
+  } catch {
+  }
+  return `STEL Order API error: ${response.status} ${response.statusText}`;
+}
+function normalizeStelApiBaseUrl(baseUrl) {
+  const trimmed = baseUrl.trim();
+  if (!trimmed) {
+    throw new ConfigurationError("Stel Order baseUrl is required.");
+  }
+  const normalized = trimmed.replace(/\/api\/openapi\.json$/i, "").replace(/\/+$/, "");
+  return normalized.endsWith("/app") ? normalized : `${normalized}/app`;
+}
+var StelOrderClient = class {
+  apiBaseUrl;
+  apiKey;
+  logger;
+  retryConfig;
+  fetchImplementation;
+  constructor(config) {
+    const apiKey = config.apiKey ?? config.publishableKey;
+    if (!apiKey) {
+      throw new ConfigurationError(
+        "Stel Order API key is required. Pass `apiKey` or `publishableKey` to createProvider()."
+      );
+    }
+    this.apiBaseUrl = normalizeStelApiBaseUrl(config.baseUrl);
+    this.apiKey = apiKey;
+    this.logger = createLogger("StelOrderClient", config.debug);
+    this.retryConfig = {
+      ...DEFAULT_RETRY_CONFIG2,
+      ...config.retry
+    };
+    this.fetchImplementation = config.customFetch ? createRetryingFetch(config.customFetch, this.retryConfig, this.logger) : void 0;
+    this.logger.info("Initializing Stel Order client", {
+      apiBaseUrl: this.apiBaseUrl,
+      retryConfig: this.retryConfig
+    });
+  }
+  async list(resource, query) {
+    const payload = await this.request({
+      method: "GET",
+      path: resource,
+      query
+    });
+    return normalizeStelCollection(payload);
+  }
+  async getOne(resource, id, query) {
+    const payload = await this.request({
+      method: "GET",
+      path: `${resource}/${id}`,
+      query
+    });
+    return normalizeStelEntity(payload);
+  }
+  async create(resource, body) {
+    return this.request({
+      method: "POST",
+      path: resource,
+      body
+    });
+  }
+  async update(resource, id, body) {
+    return this.request({
+      method: "PUT",
+      path: `${resource}/${id}`,
+      body
+    });
+  }
+  async remove(resource, id) {
+    await this.request({
+      method: "DELETE",
+      path: `${resource}/${id}`
+    });
+  }
+  buildUrl(path, query) {
+    const normalizedPath = path.replace(/^\/+/, "");
+    const url = new URL(`${this.apiBaseUrl}/${normalizedPath}`);
+    if (!query) {
+      return url.toString();
+    }
+    for (const [key, value] of Object.entries(query)) {
+      if (value === void 0 || value === null || value === "") {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        url.searchParams.set(key, value.map(String).join(","));
+        continue;
+      }
+      url.searchParams.set(key, String(value));
+    }
+    return url.toString();
+  }
+  buildHeaders(headers, hasBody = false) {
+    const normalizedHeaders = new Headers(headers);
+    normalizedHeaders.set("Accept", "application/json");
+    normalizedHeaders.set("APIKEY", this.apiKey);
+    if (hasBody && !normalizedHeaders.has("Content-Type")) {
+      normalizedHeaders.set("Content-Type", "application/json");
+    }
+    return normalizedHeaders;
+  }
+  async executeFetch(url, init) {
+    if (this.fetchImplementation) {
+      return this.fetchImplementation(url, init);
+    }
+    return fetchWithRetry(url, init, this.retryConfig);
+  }
+  async request(options) {
+    const url = this.buildUrl(options.path, options.query);
+    const hasBody = options.body !== void 0;
+    this.logger.debug("STEL request", {
+      method: options.method,
+      url
+    });
+    const response = await this.executeFetch(url, {
+      method: options.method,
+      headers: this.buildHeaders(options.headers, hasBody),
+      body: hasBody ? JSON.stringify(options.body) : void 0
+    });
+    if (!response.ok) {
+      const message = await parseErrorResponse(response);
+      throw new ProviderAPIError(message, "stelorder", response.status);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      return await response.json();
+    }
+    return await response.text();
+  }
+};
+
+// src/providers/stelorder/index.ts
+var StelOrderProvider = class {
+  name = "stelorder";
+  version = "1.0.0";
+  capabilities = STELORDER_CAPABILITIES;
+  client;
+  logger;
+  currencyCode;
+  storefrontId;
+  companyName;
+  constructor(config) {
+    this.client = new StelOrderClient(config);
+    this.logger = createLogger("StelOrderProvider", config.debug);
+    this.currencyCode = config.currencyCode ?? "USD";
+    this.storefrontId = config.storefrontId ?? "stelorder-primary";
+    this.companyName = config.companyName ?? "Stel Order";
+    this.logger.info("Initializing Stel Order provider", {
+      storefrontId: this.storefrontId,
+      companyName: this.companyName,
+      currencyCode: this.currencyCode
+    });
+  }
+  // ============================================
+  // Product Operations
+  // ============================================
+  async getProduct(handle, _options) {
+    this.logger.debug("getProduct", { handle });
+    try {
+      if (/^\d+$/.test(handle)) {
+        const raw = await this.client.getOne("products", handle);
+        return raw ? transformStelProduct(raw, this.currencyCode) : void 0;
+      }
+      const rawProducts = await this.client.list("products", { limit: 100 });
+      for (const raw of rawProducts) {
+        const productHandle = buildStelHandle(raw["full-reference"], raw.reference, raw.name, raw.id);
+        if (productHandle === handle) {
+          return transformStelProduct(raw, this.currencyCode);
+        }
+      }
+      return void 0;
+    } catch (error) {
+      this.logger.error("getProduct failed", { handle, error });
+      throw this.wrapError("getProduct", error);
+    }
+  }
+  async getProducts(options) {
+    this.logger.debug("getProducts", { options });
+    try {
+      const query = {};
+      if (options?.first) {
+        query.limit = options.first;
+      }
+      if (options?.skip) {
+        query.start = options.skip;
+      }
+      if (typeof options?.after === "number") {
+        query.start = options.after;
+      }
+      if (options?.sortKey) {
+        query.sort = options.reverse ? `-${options.sortKey}` : options.sortKey;
+      }
+      if (options?.categoryIds?.length) {
+        query["product-category-id"] = `in:${options.categoryIds.join(",")}`;
+      }
+      const rawProducts = await this.client.list("products", query);
+      let products = rawProducts.filter((p) => !p.deleted && !p.inactive).map((p) => transformStelProduct(p, this.currencyCode));
+      if (options?.query) {
+        const needle = options.query.toLowerCase();
+        products = products.filter(
+          (p) => p.title.toLowerCase().includes(needle) || p.description.toLowerCase().includes(needle) || p.handle.includes(needle)
+        );
+      }
+      return products;
+    } catch (error) {
+      this.logger.error("getProducts failed", { options, error });
+      throw this.wrapError("getProducts", error);
+    }
+  }
+  async getProductRecommendations(_productId) {
+    return [];
+  }
+  // ============================================
+  // Category Operations
+  // ============================================
+  async getCategory(idOrHandle) {
+    this.logger.debug("getCategory", { idOrHandle });
+    try {
+      if (/^\d+$/.test(idOrHandle)) {
+        const raw = await this.client.getOne("productCategories", idOrHandle);
+        return raw ? transformStelCategory(raw) : void 0;
+      }
+      const rawCategories = await this.client.list("productCategories");
+      for (const raw of rawCategories) {
+        const catHandle = buildStelHandle(raw.slug, raw.name, raw.id);
+        if (catHandle === idOrHandle) {
+          return transformStelCategory(raw);
+        }
+      }
+      return void 0;
+    } catch (error) {
+      this.logger.error("getCategory failed", { idOrHandle, error });
+      throw this.wrapError("getCategory", error);
+    }
+  }
+  async getCategories(options) {
+    this.logger.debug("getCategories", { options });
+    try {
+      if (options?.customFetcher) {
+        return options.customFetcher(options);
+      }
+      const query = {};
+      if (options?.limit) {
+        query.limit = options.limit;
+      }
+      if (options?.parentCategoryId) {
+        query["parent-category-id"] = options.parentCategoryId;
+      }
+      const rawCategories = await this.client.list("productCategories", query);
+      let categories = rawCategories.filter((c) => !c.deleted).map(transformStelCategory);
+      if (options?.query) {
+        const needle = options.query.toLowerCase();
+        categories = categories.filter(
+          (c) => c.name.toLowerCase().includes(needle) || c.handle.includes(needle)
+        );
+      }
+      return categories;
+    } catch (error) {
+      this.logger.error("getCategories failed", { options, error });
+      throw this.wrapError("getCategories", error);
+    }
+  }
+  async getCategoryProducts(handle, options) {
+    this.logger.debug("getCategoryProducts", { handle, options });
+    try {
+      const category = await this.getCategory(handle);
+      if (!category) {
+        return [];
+      }
+      return this.getProducts({
+        categoryIds: [category.id],
+        first: options?.first,
+        sortKey: options?.sortKey,
+        reverse: options?.reverse,
+        after: options?.after
+      });
+    } catch (error) {
+      this.logger.error("getCategoryProducts failed", { handle, error });
+      throw this.wrapError("getCategoryProducts", error);
+    }
+  }
+  // ============================================
+  // Collection Operations (alias categories)
+  // ============================================
+  async getCollection(handle) {
+    this.logger.debug("getCollection", { handle });
+    try {
+      if (/^\d+$/.test(handle)) {
+        const raw = await this.client.getOne("productCategories", handle);
+        return raw ? transformStelCategoryToCollection(raw) : void 0;
+      }
+      const rawCategories = await this.client.list("productCategories");
+      for (const raw of rawCategories) {
+        const catHandle = buildStelHandle(raw.slug, raw.name, raw.id);
+        if (catHandle === handle) {
+          return transformStelCategoryToCollection(raw);
+        }
+      }
+      return void 0;
+    } catch (error) {
+      this.logger.error("getCollection failed", { handle, error });
+      throw this.wrapError("getCollection", error);
+    }
+  }
+  async getCollections(options) {
+    this.logger.debug("getCollections", { options });
+    try {
+      const query = {};
+      if (options?.limit) {
+        query.limit = options.limit;
+      }
+      const rawCategories = await this.client.list("productCategories", query);
+      let collections = rawCategories.filter((c) => !c.deleted).map(transformStelCategoryToCollection);
+      if (options?.query) {
+        const needle = options.query.toLowerCase();
+        collections = collections.filter(
+          (c) => c.title.toLowerCase().includes(needle) || c.handle.includes(needle)
+        );
+      }
+      return collections;
+    } catch (error) {
+      this.logger.error("getCollections failed", { options, error });
+      throw this.wrapError("getCollections", error);
+    }
+  }
+  async getCollectionProducts(handle, options) {
+    return this.getCategoryProducts(handle, options);
+  }
+  // ============================================
+  // Inventory Operations
+  // ============================================
+  async getStockLocations(_params) {
+    this.logger.debug("getStockLocations");
+    try {
+      const rawWarehouses = await this.client.list("warehouses");
+      return rawWarehouses.filter((w) => !w.deleted).map(transformStelWarehouseToStockLocation);
+    } catch (error) {
+      this.logger.error("getStockLocations failed", { error });
+      throw this.wrapError("getStockLocations", error);
+    }
+  }
+  async checkInventoryLevels(variantId, _salesChannelId) {
+    this.logger.debug("checkInventoryLevels", { variantId });
+    try {
+      const raw = await this.client.getOne("products", variantId);
+      if (!raw?.["product-warehouses"]?.length) {
+        return [];
+      }
+      return raw["product-warehouses"].map(transformStelProductWarehouseToInventoryLevel);
+    } catch (error) {
+      this.logger.error("checkInventoryLevels failed", { variantId, error });
+      throw this.wrapError("checkInventoryLevels", error);
+    }
+  }
+  validateCartStock(_cartId) {
+    return this.notSupported("validateCartStock");
+  }
+  getFulfillmentOptions(_cartId, _salesChannelId) {
+    return this.notSupported("getFulfillmentOptions");
+  }
+  // ============================================
+  // Cart Operations (unsupported — STEL is ERP, not storefront)
+  // ============================================
+  createCart(_options) {
+    return this.notSupported("createCart");
+  }
+  getCart(_cartId) {
+    return this.notSupported("getCart");
+  }
+  addToCart(_cartId, _lines) {
+    return this.notSupported("addToCart");
+  }
+  removeFromCart(_cartId, _lineIds) {
+    return this.notSupported("removeFromCart");
+  }
+  updateCart(_cartId, _lines) {
+    return this.notSupported("updateCart");
+  }
+  // ============================================
+  // Checkout Operations (unsupported)
+  // ============================================
+  completeCheckout(_cartId) {
+    return this.notSupported("completeCheckout");
+  }
+  getRegionCountries(_regionId) {
+    return this.notSupported("getRegionCountries");
+  }
+  addShippingMethod(_cartId, _methodId) {
+    return this.notSupported("addShippingMethod");
+  }
+  initiatePaymentSession(_cartId, _providerId) {
+    return this.notSupported("initiatePaymentSession");
+  }
+  applyDiscountCode(_cartId, _code) {
+    return this.notSupported("applyDiscountCode");
+  }
+  removeDiscountCode(_cartId, _code) {
+    return this.notSupported("removeDiscountCode");
+  }
+  // ============================================
+  // Payment Methods
+  // ============================================
+  async getPaymentMethods(_options) {
+    this.logger.debug("getPaymentMethods");
+    try {
+      const rawOptions = await this.client.list("paymentOptions");
+      return rawOptions.filter((o) => !o.deleted).map(transformStelPaymentOption);
+    } catch (error) {
+      this.logger.error("getPaymentMethods failed", { error });
+      throw this.wrapError("getPaymentMethods", error);
+    }
+  }
+  // ============================================
+  // Shipping / Delivery Methods
+  // ============================================
+  async getShippingMethods(_cartId) {
+    this.logger.debug("getShippingMethods (delivery options listing)");
+    try {
+      const rawOptions = await this.client.list("deliveryOptions");
+      return rawOptions.filter((o) => !o.deleted).map((o) => transformStelDeliveryOption(o, this.currencyCode));
+    } catch (error) {
+      this.logger.error("getShippingMethods failed", { error });
+      throw this.wrapError("getShippingMethods", error);
+    }
+  }
+  // ============================================
+  // Customer Operations (optional)
+  // ============================================
+  async getCustomer(customerId) {
+    this.logger.debug("getCustomer", { customerId });
+    try {
+      const raw = await this.client.getOne("clients", customerId);
+      return raw ? transformStelClient(raw) : void 0;
+    } catch (error) {
+      this.logger.error("getCustomer failed", { customerId, error });
+      throw this.wrapError("getCustomer", error);
+    }
+  }
+  async getCustomers(options) {
+    this.logger.debug("getCustomers", { options });
+    try {
+      if (options?.customFetcher) {
+        return options.customFetcher(options);
+      }
+      const query = {};
+      if (options?.limit) {
+        query.limit = options.limit;
+      }
+      if (options?.offset) {
+        query.start = options.offset;
+      }
+      const rawClients = await this.client.list("clients", query);
+      let customers = rawClients.filter((c) => !c.deleted).map(transformStelClient);
+      if (options?.search) {
+        const needle = options.search.toLowerCase();
+        customers = customers.filter(
+          (c) => c.email.toLowerCase().includes(needle) || (c.firstName ?? "").toLowerCase().includes(needle) || (c.lastName ?? "").toLowerCase().includes(needle)
+        );
+      }
+      return customers;
+    } catch (error) {
+      this.logger.error("getCustomers failed", { options, error });
+      throw this.wrapError("getCustomers", error);
+    }
+  }
+  async updateCustomer(customerId, data) {
+    this.logger.debug("updateCustomer", { customerId, data });
+    try {
+      const stelPayload = {};
+      if (data.firstName || data.lastName) {
+        stelPayload.name = [data.firstName, data.lastName].filter(Boolean).join(" ");
+      }
+      if (data.email) {
+        stelPayload.email = data.email;
+      }
+      if (data.phone) {
+        stelPayload.phone = data.phone;
+      }
+      const raw = await this.client.update("clients", customerId, stelPayload);
+      return transformStelClient(raw);
+    } catch (error) {
+      this.logger.error("updateCustomer failed", { customerId, error });
+      throw this.wrapError("updateCustomer", error);
+    }
+  }
+  // ============================================
+  // Order Operations (optional)
+  // ============================================
+  async getOrder(orderId) {
+    this.logger.debug("getOrder", { orderId });
+    try {
+      const raw = await this.client.getOne("salesOrders", orderId);
+      return raw ? transformStelSalesOrder(raw, this.currencyCode) : void 0;
+    } catch (error) {
+      this.logger.error("getOrder failed", { orderId, error });
+      throw this.wrapError("getOrder", error);
+    }
+  }
+  async getOrders(options) {
+    this.logger.debug("getOrders", { options });
+    try {
+      if (options?.customFetcher) {
+        return options.customFetcher(options);
+      }
+      const query = {};
+      if (options?.limit) {
+        query.limit = options.limit;
+      }
+      if (options?.offset) {
+        query.start = options.offset;
+      }
+      if (options?.customerId) {
+        query["client-id"] = options.customerId;
+      }
+      const rawOrders = await this.client.list("salesOrders", query);
+      return rawOrders.filter((o) => !o.deleted).map((o) => transformStelSalesOrder(o, this.currencyCode));
+    } catch (error) {
+      this.logger.error("getOrders failed", { options, error });
+      throw this.wrapError("getOrders", error);
+    }
+  }
+  async getAdminOrders(options) {
+    this.logger.debug("getAdminOrders", { options });
+    try {
+      const query = {};
+      if (options?.limit) {
+        query.limit = options.limit;
+      }
+      if (options?.offset) {
+        query.start = options.offset;
+      }
+      const rawOrders = await this.client.list("salesOrders", query);
+      let orders = rawOrders.filter((o) => !o.deleted).map((o) => transformStelSalesOrder(o, this.currencyCode));
+      if (options?.search) {
+        const needle = options.search.toLowerCase();
+        orders = orders.filter(
+          (o) => o.orderNumber.toLowerCase().includes(needle) || o.email.toLowerCase().includes(needle)
+        );
+      }
+      if (options?.status) {
+        const statuses = Array.isArray(options.status) ? options.status : [options.status];
+        orders = orders.filter((o) => statuses.includes(o.status));
+      }
+      return { orders, count: orders.length };
+    } catch (error) {
+      this.logger.error("getAdminOrders failed", { options, error });
+      throw this.wrapError("getAdminOrders", error);
+    }
+  }
+  cancelOrder(_orderId) {
+    return this.notSupported("cancelOrder");
+  }
+  createFulfillment(_orderId, _items) {
+    return this.notSupported("createFulfillment");
+  }
+  createRefund(_orderId, _amount, _reason) {
+    return this.notSupported("createRefund");
+  }
+  // ============================================
+  // Storefront Context
+  // ============================================
+  async getStorefrontContext() {
+    return {
+      id: this.storefrontId,
+      name: this.companyName,
+      platformType: "stelorder",
+      requiresProductScoping: false,
+      currencyCode: this.currencyCode,
+      metadata: {
+        apiBaseUrl: this.client.apiBaseUrl,
+        singleCompany: true,
+        providerVersion: this.version
+      }
+    };
+  }
+  isStorefrontRequired() {
+    return false;
+  }
+  // ============================================
+  // Internal helpers
+  // ============================================
+  notSupported(operation) {
+    return Promise.reject(
+      new ProviderAPIError(
+        `Stel Order does not support \`${operation}\`. STEL is an ERP adapter without cart/checkout/auth capabilities.`,
+        "stelorder",
+        501
+      )
+    );
+  }
+  wrapError(operation, error) {
+    if (error instanceof ProviderAPIError) {
+      return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return new ProviderAPIError(
+      `Stel Order \`${operation}\` failed: ${message}`,
+      "stelorder",
+      500
+    );
+  }
+};
+
+// src/providers/mock/mock.ts
+var FIXTURE_TIMESTAMP = "2026-01-01T00:00:00.000Z";
+var DEFAULT_SITE_URL = "https://mock.thorcommerce.local";
+var regionFixtures = [
+  {
+    id: "mock-region-us",
+    name: "United States",
+    currencyCode: "USD",
+    locale: "en-US",
+    taxRate: 0.08,
+    countries: [{ code: "US", name: "United States" }]
+  },
+  {
+    id: "mock-region-eu",
+    name: "Europe",
+    currencyCode: "EUR",
+    locale: "en-ES",
+    taxRate: 0.21,
+    countries: [
+      { code: "ES", name: "Spain" },
+      { code: "FR", name: "France" },
+      { code: "DE", name: "Germany" }
+    ]
+  }
+];
+var collectionFixtures = [
+  {
+    id: "mock-collection-new-arrivals",
+    handle: "new-arrivals",
+    title: "New Arrivals",
+    description: "Fresh mock catalog items for layout and merchandising flows."
+  },
+  {
+    id: "mock-collection-best-sellers",
+    handle: "best-sellers",
+    title: "Best Sellers",
+    description: "High-performing mock products used to design hero grids and featured sections."
+  },
+  {
+    id: "mock-collection-studio-essentials",
+    handle: "studio-essentials",
+    title: "Studio Essentials",
+    description: "A balanced fixture set for mock storefront navigation and detail pages."
+  }
+];
+var categoryFixtures = [
+  {
+    id: "mock-category-jackets",
+    handle: "jackets",
+    name: "Jackets",
+    description: "Outerwear and layering pieces."
+  },
+  {
+    id: "mock-category-dresses",
+    handle: "dresses",
+    name: "Dresses",
+    description: "Editorial silhouettes for seasonal collections."
+  },
+  {
+    id: "mock-category-home",
+    handle: "home",
+    name: "Home",
+    description: "Decor and living objects for lifestyle layouts."
+  },
+  {
+    id: "mock-category-accessories",
+    handle: "accessories",
+    name: "Accessories",
+    description: "Complementary products for cart and bundle flows."
+  }
+];
+var productFixtures = [
+  {
+    id: "mock-product-aurora-jacket",
+    handle: "aurora-jacket",
+    title: "Aurora Quilted Jacket",
+    description: "Lightweight quilted outerwear with tonal hardware and a soft structured collar.",
+    imageLabel: "Aurora Jacket",
+    imageHue: 222,
+    collectionHandles: ["new-arrivals", "best-sellers"],
+    categoryHandle: "jackets",
+    productType: "outerwear",
+    vendor: "Thor Atelier",
+    tags: ["outerwear", "quilted", "winter"],
+    options: [
+      { id: "aurora-size", name: "Size", values: ["S", "M", "L"] },
+      { id: "aurora-color", name: "Color", values: ["Midnight"] }
+    ],
+    variants: [
+      {
+        id: "mock-variant-aurora-s",
+        title: "S / Midnight",
+        price: 129,
+        compareAtPrice: 159,
+        quantityAvailable: 8,
+        selectedOptions: [
+          { name: "Size", value: "S" },
+          { name: "Color", value: "Midnight" }
+        ]
+      },
+      {
+        id: "mock-variant-aurora-m",
+        title: "M / Midnight",
+        price: 129,
+        compareAtPrice: 159,
+        quantityAvailable: 12,
+        selectedOptions: [
+          { name: "Size", value: "M" },
+          { name: "Color", value: "Midnight" }
+        ]
+      }
+    ]
+  },
+  {
+    id: "mock-product-solis-dress",
+    handle: "solis-dress",
+    title: "Solis Pleated Dress",
+    description: "A fluid pleated dress with a clean neckline designed for hero storytelling.",
+    imageLabel: "Solis Dress",
+    imageHue: 18,
+    collectionHandles: ["new-arrivals", "studio-essentials"],
+    categoryHandle: "dresses",
+    productType: "dress",
+    vendor: "Thor Atelier",
+    tags: ["dress", "occasion", "pleated"],
+    options: [
+      { id: "solis-size", name: "Size", values: ["XS", "S", "M"] },
+      { id: "solis-color", name: "Color", values: ["Clay"] }
+    ],
+    variants: [
+      {
+        id: "mock-variant-solis-xs",
+        title: "XS / Clay",
+        price: 164,
+        quantityAvailable: 4,
+        selectedOptions: [
+          { name: "Size", value: "XS" },
+          { name: "Color", value: "Clay" }
+        ]
+      },
+      {
+        id: "mock-variant-solis-s",
+        title: "S / Clay",
+        price: 164,
+        quantityAvailable: 9,
+        selectedOptions: [
+          { name: "Size", value: "S" },
+          { name: "Color", value: "Clay" }
+        ]
+      }
+    ]
+  },
+  {
+    id: "mock-product-helios-lamp",
+    handle: "helios-lamp",
+    title: "Helios Table Lamp",
+    description: "Warm ambient lamp with sculptural proportions for lifestyle and home grids.",
+    imageLabel: "Helios Lamp",
+    imageHue: 45,
+    collectionHandles: ["best-sellers", "studio-essentials"],
+    categoryHandle: "home",
+    productType: "lighting",
+    vendor: "Thor Home",
+    tags: ["home", "lighting", "decor"],
+    options: [{ id: "helios-finish", name: "Finish", values: ["Brass"] }],
+    variants: [
+      {
+        id: "mock-variant-helios-brass",
+        title: "Brass",
+        price: 96,
+        quantityAvailable: 15,
+        selectedOptions: [{ name: "Finish", value: "Brass" }]
+      }
+    ]
+  },
+  {
+    id: "mock-product-luna-bag",
+    handle: "luna-bag",
+    title: "Luna Crossbody Bag",
+    description: "Compact everyday bag for accessory rails, checkout add-ons, and bundle modules.",
+    imageLabel: "Luna Bag",
+    imageHue: 306,
+    collectionHandles: ["studio-essentials"],
+    categoryHandle: "accessories",
+    productType: "bag",
+    vendor: "Thor Atelier",
+    tags: ["bag", "accessory", "everyday"],
+    options: [{ id: "luna-color", name: "Color", values: ["Berry"] }],
+    variants: [
+      {
+        id: "mock-variant-luna-berry",
+        title: "Berry",
+        price: 82,
+        quantityAvailable: 18,
+        selectedOptions: [{ name: "Color", value: "Berry" }]
+      }
+    ]
+  }
+];
+var stockLocationFixture = {
+  id: "mock-stock-primary",
+  name: "Mock Main Warehouse",
+  address: {
+    address1: "100 Mock Avenue",
+    city: "Design City",
+    countryCode: "US",
+    postalCode: "10001",
+    province: "NY"
+  },
+  metadata: {
+    timezone: "America/New_York"
+  }
+};
+var cartStore = /* @__PURE__ */ new Map();
+var orderStore = /* @__PURE__ */ new Map();
+var sequence = 0;
+function nextId(prefix) {
+  sequence += 1;
+  return `${prefix}-${sequence}`;
+}
+function createMoney(amount, currencyCode) {
+  return {
+    amount: amount.toFixed(2),
+    currencyCode
+  };
+}
+function createImage(label, hue) {
+  const svg = `
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1200 1200" role="img" aria-label="${label}">
+      <defs>
+        <linearGradient id="g" x1="0" x2="1" y1="0" y2="1">
+          <stop offset="0%" stop-color="hsl(${hue}, 72%, 72%)" />
+          <stop offset="100%" stop-color="hsl(${(hue + 48) % 360}, 62%, 42%)" />
+        </linearGradient>
+      </defs>
+      <rect width="1200" height="1200" fill="url(#g)" rx="48" />
+      <circle cx="910" cy="280" r="180" fill="rgba(255,255,255,0.22)" />
+      <text x="90" y="990" fill="white" font-family="Arial, sans-serif" font-size="96" font-weight="700">${label}</text>
+    </svg>
+  `.trim();
+  return {
+    url: `data:image/svg+xml;charset=UTF-8,${encodeURIComponent(svg)}`,
+    altText: label,
+    width: 1200,
+    height: 1200
+  };
+}
+function getRegionFixture(regionId) {
+  if (!regionId) {
+    return regionFixtures[0];
+  }
+  return regionFixtures.find((region) => region.id === regionId) ?? regionFixtures[0];
+}
+function createProductImageSet(label, hue) {
+  const featuredImage = createImage(label, hue);
+  return {
+    featuredImage,
+    images: [featuredImage, createImage(`${label} Detail`, (hue + 18) % 360)]
+  };
+}
+function buildCollections() {
+  return collectionFixtures.map((collection) => ({
+    id: collection.id,
+    handle: collection.handle,
+    title: collection.title,
+    description: collection.description,
+    path: `/collections/${collection.handle}`,
+    updatedAt: FIXTURE_TIMESTAMP
+  }));
+}
+function buildCategories() {
+  return categoryFixtures.map((category) => ({
+    id: category.id,
+    handle: category.handle,
+    name: category.name,
+    description: category.description,
+    parentCategoryId: category.parentCategoryId,
+    productCount: productFixtures.filter((product) => product.categoryHandle === category.handle).length,
+    image: createImage(category.name, 180).url
+  }));
+}
+function buildProducts(currencyCode) {
+  const collections = buildCollections();
+  return productFixtures.map((product) => {
+    const { featuredImage, images } = createProductImageSet(product.imageLabel, product.imageHue);
+    const variants = product.variants.map((variant) => ({
+      id: variant.id,
+      title: variant.title,
+      availableForSale: variant.quantityAvailable > 0,
+      selectedOptions: variant.selectedOptions,
+      price: createMoney(variant.price, currencyCode),
+      compareAtPrice: variant.compareAtPrice ? createMoney(variant.compareAtPrice, currencyCode) : void 0,
+      quantityAvailable: variant.quantityAvailable,
+      image: featuredImage
+    }));
+    const prices = product.variants.map((variant) => variant.price);
+    return {
+      id: product.id,
+      handle: product.handle,
+      title: product.title,
+      description: product.description,
+      availableForSale: variants.some((variant) => variant.availableForSale),
+      options: product.options,
+      variants,
+      featuredImage,
+      images,
+      priceRange: {
+        minVariantPrice: createMoney(Math.min(...prices), currencyCode),
+        maxVariantPrice: createMoney(Math.max(...prices), currencyCode)
+      },
+      collections: product.collectionHandles.map((handle) => collections.find((collection) => collection.handle === handle)).filter((collection) => Boolean(collection)).map((collection) => ({
+        id: collection.id,
+        title: collection.title,
+        handle: collection.handle
+      })),
+      productType: product.productType,
+      vendor: product.vendor,
+      tags: product.tags,
+      createdAt: FIXTURE_TIMESTAMP,
+      updatedAt: FIXTURE_TIMESTAMP,
+      metadata: {
+        categoryHandle: product.categoryHandle,
+        collectionHandles: product.collectionHandles
+      }
+    };
+  });
+}
+function filterProducts(products, options) {
+  const query = options.query?.trim().toLowerCase();
+  const categoryIds = new Set(options.categoryIds ?? []);
+  const collectionIds = new Set(options.collectionIds ?? []);
+  return products.filter((product) => {
+    if (query) {
+      const matchesQuery = [product.title, product.description, ...product.tags ?? []].join(" ").toLowerCase().includes(query);
+      if (!matchesQuery) {
+        return false;
+      }
+    }
+    if (categoryIds.size > 0) {
+      const categoryHandle = String(product.metadata?.categoryHandle ?? "");
+      const category = categoryFixtures.find((item) => item.handle === categoryHandle);
+      const matchesCategory = category ? categoryIds.has(category.id) || categoryIds.has(category.handle) : false;
+      if (!matchesCategory) {
+        return false;
+      }
+    }
+    if (collectionIds.size > 0) {
+      const productCollections = (product.collections ?? []).map((collection) => collection.handle);
+      const matchesCollection = (product.collections ?? []).some(
+        (collection) => collectionIds.has(collection.id) || collectionIds.has(collection.handle)
+      ) || productCollections.some((handle) => collectionIds.has(handle));
+      if (!matchesCollection) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+function sortProducts(products, sortKey, reverse) {
+  const sorted = [...products];
+  switch (sortKey) {
+    case "price":
+    case "price-asc":
+    case "price-desc":
+      sorted.sort(
+        (left, right) => Number(left.priceRange.minVariantPrice.amount) - Number(right.priceRange.minVariantPrice.amount)
+      );
+      break;
+    case "created_at":
+    case "createdAt":
+    case "newest":
+      sorted.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+      break;
+    case "title":
+    case "name":
+    default:
+      sorted.sort((left, right) => left.title.localeCompare(right.title));
+      break;
+  }
+  const shouldReverse = reverse || sortKey === "price-desc" || sortKey === "newest";
+  return shouldReverse ? sorted.reverse() : sorted;
+}
+function paginateProducts(products, skip, first) {
+  const start = Math.max(0, skip ?? 0);
+  const end = first ? start + first : void 0;
+  return products.slice(start, end);
+}
+function resolveVariant(currencyCode, merchandiseId) {
+  const products = buildProducts(currencyCode);
+  for (const product of products) {
+    const variant = product.variants.find((item) => item.id === merchandiseId);
+    if (variant) {
+      return { product, variant };
+    }
+  }
+  return void 0;
+}
+function getShippingPrice(methodId) {
+  switch (methodId) {
+    case "mock-shipping-express":
+      return 18;
+    case "mock-shipping-standard":
+      return 8;
+    default:
+      return 0;
+  }
+}
+function buildExternalCart(state, currencyCode, siteUrl) {
+  const region = getRegionFixture(state.regionId);
+  const regionCurrency = region.currencyCode || currencyCode;
+  const lines = state.lines.flatMap((line) => {
+    const resolved = resolveVariant(regionCurrency, line.merchandiseId);
+    if (!resolved || !resolved.product.featuredImage) {
+      return [];
+    }
+    const lineTotal = Number(resolved.variant.price.amount) * line.quantity;
+    const stockStatus = resolved.variant.quantityAvailable && resolved.variant.quantityAvailable > 0 ? "in_stock" : "out_of_stock";
+    return [{
+      id: line.id,
+      quantity: line.quantity,
+      stockStatus,
+      cost: {
+        totalAmount: createMoney(lineTotal, regionCurrency)
+      },
+      merchandise: {
+        id: resolved.variant.id,
+        title: resolved.variant.title,
+        selectedOptions: resolved.variant.selectedOptions,
+        product: {
+          id: resolved.product.id,
+          handle: resolved.product.handle,
+          title: resolved.product.title,
+          featuredImage: resolved.product.featuredImage
+        }
+      }
+    }];
+  });
+  const subtotal = lines.reduce(
+    (sum, line) => sum + Number(line.cost.totalAmount.amount),
+    0
+  );
+  const shipping = getShippingPrice(state.shippingMethodId);
+  const discount = state.discountCode ? subtotal * 0.1 : 0;
+  const taxableBase = Math.max(subtotal + shipping - discount, 0);
+  const totalTax = region.taxRate ? taxableBase * region.taxRate : 0;
+  const total = taxableBase + totalTax;
+  return {
+    id: state.id,
+    checkoutUrl: `${siteUrl}/checkout?cart=${state.id}`,
+    cost: {
+      subtotalAmount: createMoney(subtotal, regionCurrency),
+      totalAmount: createMoney(total, regionCurrency),
+      totalTaxAmount: createMoney(totalTax, regionCurrency)
+    },
+    lines,
+    totalQuantity: lines.reduce((sum, line) => sum + line.quantity, 0),
+    completedAt: state.completedAt
+  };
+}
+function buildOrderFromCart(state, currencyCode, siteUrl) {
+  const cart = buildExternalCart(state, currencyCode, siteUrl);
+  return {
+    id: `mock-order-${state.id}`,
+    orderNumber: `${1e3 + sequence}`,
+    email: "mock-customer@thorprovider.dev",
+    status: "completed",
+    paymentStatus: state.paymentProviderId ? "paid" : "pending",
+    fulfillmentStatus: state.shippingMethodId ? "fulfilled" : "unfulfilled",
+    items: cart.lines.map((line) => ({
+      id: line.id ?? nextId("mock-order-line"),
+      title: line.merchandise.product.title,
+      variantTitle: line.merchandise.title,
+      quantity: line.quantity,
+      price: line.merchandise.product.featuredImage ? createMoney(Number(line.cost.totalAmount.amount) / Math.max(line.quantity, 1), cart.cost.totalAmount.currencyCode) : createMoney(0, cart.cost.totalAmount.currencyCode),
+      total: line.cost.totalAmount,
+      productId: line.merchandise.product.id,
+      variantId: line.merchandise.id,
+      image: line.merchandise.product.featuredImage
+    })),
+    subtotal: cart.cost.subtotalAmount,
+    total: cart.cost.totalAmount,
+    tax: cart.cost.totalTaxAmount,
+    shipping: createMoney(getShippingPrice(state.shippingMethodId), cart.cost.totalAmount.currencyCode),
+    discount: createMoney(state.discountCode ? Number(cart.cost.subtotalAmount.amount) * 0.1 : 0, cart.cost.totalAmount.currencyCode),
+    createdAt: FIXTURE_TIMESTAMP,
+    updatedAt: FIXTURE_TIMESTAMP,
+    completedAt: state.completedAt,
+    metadata: {
+      provider: "mock",
+      checkoutUrl: cart.checkoutUrl
+    }
+  };
+}
+function getMockCollections() {
+  return buildCollections();
+}
+function getMockCategories() {
+  return buildCategories();
+}
+function getMockProducts(options) {
+  const region = getRegionFixture(options?.regionId);
+  const currencyCode = options?.currencyCode ?? region.currencyCode;
+  const products = buildProducts(currencyCode);
+  const filtered = filterProducts(products, {
+    query: options?.query,
+    categoryIds: options?.categoryIds,
+    collectionIds: options?.collectionIds
+  });
+  const sorted = sortProducts(filtered, options?.sortKey, options?.reverse);
+  return paginateProducts(sorted, options?.skip, options?.first);
+}
+function getMockProduct(handle, regionId) {
+  const region = getRegionFixture(regionId);
+  return buildProducts(region.currencyCode).find(
+    (product) => product.handle === handle || product.id === handle
+  );
+}
+function getMockProductRecommendations(productId, regionId) {
+  const product = getMockProduct(productId, regionId) ?? buildProducts(getRegionFixture(regionId).currencyCode).find((item) => item.id === productId);
+  if (!product) {
+    return [];
+  }
+  const collectionHandles = new Set((product.collections ?? []).map((collection) => collection.handle));
+  return buildProducts(getRegionFixture(regionId).currencyCode).filter((candidate) => candidate.id !== product.id).filter(
+    (candidate) => (candidate.collections ?? []).some((collection) => collectionHandles.has(collection.handle))
+  ).slice(0, 4);
+}
+function getMockCollection(handle) {
+  return buildCollections().find(
+    (collection) => collection.handle === handle || collection.id === handle
+  );
+}
+function getMockCategory(idOrHandle) {
+  return buildCategories().find(
+    (category) => category.handle === idOrHandle || category.id === idOrHandle
+  );
+}
+function getMockRegions() {
+  return regionFixtures.map((region) => ({
+    id: region.id,
+    name: region.name,
+    currency_code: region.currencyCode,
+    countries: region.countries.map((country) => ({
+      id: `country-${country.code.toLowerCase()}`,
+      iso_2: country.code.toLowerCase(),
+      name: country.name,
+      display_name: country.name
+    }))
+  }));
+}
+function getMockAdminRegions() {
+  return regionFixtures.map((region) => ({
+    id: region.id,
+    name: region.name,
+    countryCodes: region.countries.map((country) => country.code),
+    currency: region.currencyCode,
+    taxRate: region.taxRate,
+    isEnabled: true
+  }));
+}
+function getMockRegionCountries(regionId) {
+  const region = regionFixtures.find((item) => item.id === regionId);
+  return region?.countries ?? [];
+}
+function createMockCart(regionId) {
+  const cart = {
+    id: nextId("mock-cart"),
+    regionId: regionId ?? regionFixtures[0].id,
+    lines: []
+  };
+  cartStore.set(cart.id, cart);
+  return cart;
+}
+function getMockCartState(cartId) {
+  return cartStore.get(cartId);
+}
+function saveMockCartState(cart) {
+  cartStore.set(cart.id, cart);
+  return cart;
+}
+function buildMockCart(cart, currencyCode, siteUrl) {
+  return buildExternalCart(
+    cart,
+    currencyCode ?? getRegionFixture(cart.regionId).currencyCode,
+    siteUrl ?? DEFAULT_SITE_URL
+  );
+}
+function getMockShippingMethods(regionId) {
+  const currencyCode = getRegionFixture(regionId).currencyCode;
+  return [
+    {
+      id: "mock-shipping-standard",
+      name: "Standard Shipping",
+      description: "Fixture shipping option for checkout and cart layouts.",
+      price: createMoney(8, currencyCode),
+      estimatedDays: "3-5 business days"
+    },
+    {
+      id: "mock-shipping-express",
+      name: "Express Shipping",
+      description: "Faster fixture shipping option for premium checkout flows.",
+      price: createMoney(18, currencyCode),
+      estimatedDays: "1-2 business days"
+    }
+  ];
+}
+function getMockPaymentMethods(currencyCode) {
+  return [
+    {
+      id: "mock-card",
+      name: "Mock Card",
+      type: "card",
+      isEnabled: true,
+      requiresSetup: true,
+      description: `Fixture card checkout for ${currencyCode}.`
+    },
+    {
+      id: "mock-cash",
+      name: "Cash on Delivery",
+      type: "cash_on_delivery",
+      isEnabled: true,
+      requiresSetup: false,
+      description: "Mock cash payment option for checkout prototypes."
+    }
+  ];
+}
+function getMockStockLocations() {
+  return [stockLocationFixture];
+}
+function getMockInventoryLevels(variantId) {
+  for (const region of regionFixtures) {
+    const resolved = resolveVariant(region.currencyCode, variantId);
+    if (resolved) {
+      return [{
+        locationId: stockLocationFixture.id,
+        locationName: stockLocationFixture.name,
+        availableQuantity: resolved.variant.quantityAvailable ?? 0,
+        reservedQuantity: 0,
+        stockedQuantity: resolved.variant.quantityAvailable ?? 0
+      }];
+    }
+  }
+  return [];
+}
+function validateMockCartStock(cart) {
+  const currencyCode = getRegionFixture(cart.regionId).currencyCode;
+  const unavailableItems = cart.lines.flatMap((line) => {
+    const resolved = resolveVariant(currencyCode, line.merchandiseId);
+    if (!resolved) {
+      return [];
+    }
+    const availableQuantity = resolved.variant.quantityAvailable ?? 0;
+    if (line.quantity <= availableQuantity) {
+      return [];
+    }
+    return [{
+      variantId: resolved.variant.id,
+      productName: resolved.product.title,
+      requestedQuantity: line.quantity,
+      availableQuantity
+    }];
+  });
+  return {
+    allAvailable: unavailableItems.length === 0,
+    unavailableItems
+  };
+}
+function getMockFulfillmentOptions(regionId) {
+  return getMockShippingMethods(regionId).map((method) => ({
+    id: method.id,
+    providerId: "mock-fulfillment",
+    name: method.name,
+    description: method.description,
+    price: method.price,
+    estimatedDays: method.estimatedDays,
+    stockLocation: stockLocationFixture
+  }));
+}
+function completeMockCheckout(cart, currencyCode, siteUrl) {
+  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const nextCart = {
+    ...cart,
+    completedAt
+  };
+  cartStore.set(nextCart.id, nextCart);
+  const order = buildOrderFromCart(
+    nextCart,
+    currencyCode ?? getRegionFixture(nextCart.regionId).currencyCode,
+    siteUrl ?? DEFAULT_SITE_URL
+  );
+  orderStore.set(order.id, order);
+  return order;
+}
+function getMockAdminOrders() {
+  const orders = Array.from(orderStore.values()).sort(
+    (left, right) => right.createdAt.localeCompare(left.createdAt)
+  );
+  return {
+    orders,
+    count: orders.length
+  };
+}
+function getMockOrder(orderId) {
+  return orderStore.get(orderId);
+}
+function saveMockOrder(order) {
+  orderStore.set(order.id, order);
+  return order;
+}
+
+// src/providers/mock/index.ts
+var MockProvider = class {
+  name = "mock";
+  version = "1.0.0";
+  capabilities = MOCK_CAPABILITIES;
+  isMock = true;
+  currencyCode;
+  siteUrl;
+  constructor(config = {}) {
+    this.currencyCode = config.currencyCode ?? "USD";
+    this.siteUrl = config.siteUrl ?? "https://mock.thorcommerce.local";
+  }
+  hasVariant(merchandiseId, regionId) {
+    return getMockProducts({
+      currencyCode: this.currencyCode,
+      regionId
+    }).some(
+      (product) => product.variants.some((variant) => variant.id === merchandiseId)
+    );
+  }
+  async getProduct(handle, options) {
+    return getMockProduct(handle, options?.regionId);
+  }
+  async getProducts(options) {
+    return getMockProducts({
+      currencyCode: this.currencyCode,
+      query: options?.query,
+      sortKey: options?.sortKey,
+      reverse: options?.reverse,
+      first: options?.first,
+      skip: options?.skip,
+      categoryIds: options?.categoryIds,
+      collectionIds: options?.collectionIds,
+      regionId: options?.regionId
+    });
+  }
+  async getProductRecommendations(productId) {
+    return getMockProductRecommendations(productId);
+  }
+  async getCollection(handle) {
+    return getMockCollection(handle);
+  }
+  async getCollections(options) {
+    const collections = getMockCollections();
+    const query = options?.query?.trim().toLowerCase();
+    const filtered = query ? collections.filter(
+      (collection) => [collection.title, collection.description, collection.handle].join(" ").toLowerCase().includes(query)
+    ) : collections;
+    return filtered.slice(0, options?.limit ?? filtered.length);
+  }
+  async getCollectionProducts(handle, options) {
+    const collection = getMockCollection(handle);
+    if (!collection) {
+      return [];
+    }
+    return getMockProducts({
+      currencyCode: this.currencyCode,
+      collectionIds: [collection.id],
+      sortKey: options?.sortKey,
+      reverse: options?.reverse,
+      first: options?.first
+    });
+  }
+  async getCategory(idOrHandle) {
+    return getMockCategory(idOrHandle);
+  }
+  async getCategories(options) {
+    const categories = getMockCategories();
+    const query = options?.query?.trim().toLowerCase();
+    let filtered = query ? categories.filter(
+      (category) => [category.name, category.description ?? "", category.handle].join(" ").toLowerCase().includes(query)
+    ) : categories;
+    if (options?.parentCategoryId) {
+      filtered = filtered.filter((category) => category.parentCategoryId === options.parentCategoryId);
+    }
+    return filtered.slice(0, options?.limit ?? filtered.length);
+  }
+  async getCategoryProducts(handle, options) {
+    const category = getMockCategory(handle);
+    if (!category) {
+      return [];
+    }
+    return getMockProducts({
+      currencyCode: this.currencyCode,
+      categoryIds: [category.id],
+      sortKey: options?.sortKey,
+      reverse: options?.reverse,
+      first: options?.first
+    });
+  }
+  async createCart(options) {
+    const cart = createMockCart(options?.regionId);
+    return buildMockCart(cart, this.currencyCode, this.siteUrl);
+  }
+  async getCart(cartId) {
+    const cart = getMockCartState(cartId);
+    return cart ? buildMockCart(cart, this.currencyCode, this.siteUrl) : void 0;
+  }
+  async addToCart(cartId, lines) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    for (const line of lines) {
+      if (!this.hasVariant(line.merchandiseId, cart.regionId)) {
+        throw new ResourceNotFoundError("variant", line.merchandiseId);
+      }
+    }
+    const nextLines = [...cart.lines];
+    for (const line of lines) {
+      const existing = nextLines.find((item) => item.merchandiseId === line.merchandiseId);
+      if (existing) {
+        existing.quantity += line.quantity;
+      } else {
+        nextLines.push({
+          id: `mock-line-${line.merchandiseId}`,
+          merchandiseId: line.merchandiseId,
+          quantity: line.quantity
+        });
+      }
+    }
+    const saved = saveMockCartState({ ...cart, lines: nextLines });
+    return buildMockCart(saved, this.currencyCode, this.siteUrl);
+  }
+  async removeFromCart(cartId, lineIds) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    const saved = saveMockCartState({
+      ...cart,
+      lines: cart.lines.filter((line) => !lineIds.includes(line.id))
+    });
+    return buildMockCart(saved, this.currencyCode, this.siteUrl);
+  }
+  async updateCart(cartId, lines) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    for (const line of lines) {
+      if (!this.hasVariant(line.merchandiseId, cart.regionId)) {
+        throw new ResourceNotFoundError("variant", line.merchandiseId);
+      }
+    }
+    const updates = new Map(lines.map((line) => [line.id, line]));
+    const nextLines = cart.lines.map((line) => {
+      const update = updates.get(line.id);
+      if (!update) {
+        return line;
+      }
+      return {
+        ...line,
+        merchandiseId: update.merchandiseId,
+        quantity: update.quantity
+      };
+    }).filter((line) => line.quantity > 0);
+    const saved = saveMockCartState({ ...cart, lines: nextLines });
+    return buildMockCart(saved, this.currencyCode, this.siteUrl);
+  }
+  async getRegions() {
+    return getMockRegions();
+  }
+  async completeCheckout(cartId) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    const order = completeMockCheckout(cart, this.currencyCode, this.siteUrl);
+    return order;
+  }
+  async getShippingMethods(cartId) {
+    const cart = getMockCartState(cartId);
+    return getMockShippingMethods(cart?.regionId);
+  }
+  async getRegionCountries(regionId) {
+    return getMockRegionCountries(regionId);
+  }
+  async addShippingMethod(cartId, methodId) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    const allowed = getMockShippingMethods(cart.regionId).some((method) => method.id === methodId);
+    if (!allowed) {
+      throw new ProviderAPIError(`Unknown mock shipping method: ${methodId}`, "mock", 400);
+    }
+    const saved = saveMockCartState({ ...cart, shippingMethodId: methodId });
+    return buildMockCart(saved, this.currencyCode, this.siteUrl);
+  }
+  async initiatePaymentSession(cartId, providerId) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    const allowed = getMockPaymentMethods(this.currencyCode).some((method) => method.id === providerId);
+    if (!allowed) {
+      throw new ProviderAPIError(`Unknown mock payment method: ${providerId}`, "mock", 400);
+    }
+    saveMockCartState({ ...cart, paymentProviderId: providerId });
+  }
+  async applyDiscountCode(cartId, code) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    const normalized = code.trim();
+    if (!normalized) {
+      throw new ProviderAPIError("Discount code is required.", "mock", 400);
+    }
+    const saved = saveMockCartState({ ...cart, discountCode: normalized });
+    return buildMockCart(saved, this.currencyCode, this.siteUrl);
+  }
+  async removeDiscountCode(cartId, _code) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    const saved = saveMockCartState({ ...cart, discountCode: void 0 });
+    return buildMockCart(saved, this.currencyCode, this.siteUrl);
+  }
+  async getOrders(_options) {
+    return getMockAdminOrders().orders;
+  }
+  async getPaymentMethods(options) {
+    return getMockPaymentMethods(options.currencyCode ?? this.currencyCode);
+  }
+  async getStockLocations() {
+    return getMockStockLocations();
+  }
+  async checkInventoryLevels(variantId) {
+    return getMockInventoryLevels(variantId);
+  }
+  async validateCartStock(cartId) {
+    const cart = getMockCartState(cartId);
+    if (!cart) {
+      throw new ResourceNotFoundError("cart", cartId);
+    }
+    return validateMockCartStock(cart);
+  }
+  async getFulfillmentOptions(cartId, _salesChannelId) {
+    const cart = getMockCartState(cartId);
+    return getMockFulfillmentOptions(cart?.regionId);
+  }
+  async cancelOrder(orderId) {
+    const order = getMockOrder(orderId);
+    if (!order) {
+      throw new ResourceNotFoundError("order", orderId);
+    }
+    return saveMockOrder({
+      ...order,
+      status: "cancelled",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      cancelledAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async createFulfillment(_orderId, _items) {
+    return;
+  }
+  async createRefund(orderId, _amount, _reason) {
+    const order = getMockOrder(orderId);
+    if (!order) {
+      throw new ResourceNotFoundError("order", orderId);
+    }
+    saveMockOrder({
+      ...order,
+      status: "refunded",
+      paymentStatus: "refunded",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async getAdminOrders() {
+    return getMockAdminOrders();
+  }
+  async getAdminRegions() {
+    return getMockAdminRegions();
+  }
+  async getStorefrontContext() {
+    return {
+      id: "mock-storefront",
+      name: "Mock Storefront",
+      platformType: "mock",
+      requiresProductScoping: false,
+      currencyCode: this.currencyCode,
+      locale: "en-US",
+      metadata: {
+        mode: "design"
+      }
+    };
+  }
+  isStorefrontRequired() {
+    return false;
+  }
+};
+
 // src/factory/index.ts
 function createProvider(options) {
   if (!options || !options.provider) {
@@ -8052,8 +10146,12 @@ function createProvider(options) {
   }
   const config = options.config;
   switch (options.provider) {
+    case "mock":
+      return new MockProvider(config);
     case "medusa":
       return new MedusaProvider(config);
+    case "stelorder":
+      return new StelOrderProvider(config);
     case "shopify":
       return new ShopifyProvider(config);
     case "bigcommerce":
@@ -8087,17 +10185,21 @@ function isProviderType(provider, type) {
   ConfigurationError,
   MAGENTO_CAPABILITIES,
   MEDUSA_CAPABILITIES,
+  MOCK_CAPABILITIES,
   MagentoProvider,
   MedusaMetadataAdapter,
   MedusaProvider,
   MetricsService,
+  MockProvider,
   ProviderAPIError,
   ProviderNotFoundError,
   ResourceNotFoundError,
   SHOPIFY_CAPABILITIES,
   SPREE_CAPABILITIES,
+  STELORDER_CAPABILITIES,
   ShopifyProvider,
   SpreeProvider,
+  StelOrderProvider,
   StorefrontConfigError,
   WOOCOMMERCE_CAPABILITIES,
   WooCommerceProvider,