arky-sdk 0.9.6 → 0.9.12

package/dist/storefront-store.js

@@ -1,2807 +0,0 @@
-import { atom, computed, map } from 'nanostores';
-
-// src/storefrontStore/createArkyStore.ts
-
-// src/utils/blocks.ts
-function getBlockLabel(block) {
-  if (!block) return "";
-  return block.key?.replace(/_/g, " ").replace(/\b\w/g, (l) => l.toUpperCase()) ?? "";
-}
-function formatBlockValue(block) {
-  if (!block || block.value === null || block.value === void 0) return "";
-  const value = block.value;
-  switch (block.type) {
-    case "boolean":
-      return value ? "Yes" : "No";
-    case "number":
-      if (block.properties?.variant === "DATE" || block.properties?.variant === "DATE_TIME") {
-        return new Date(value).toLocaleDateString();
-      }
-      return String(value);
-    case "relationship_entry":
-    case "relationship_media":
-      if (value && typeof value === "object") {
-        return value.mime_type ? value.name || value.id : value.title || value.name || value.id;
-      }
-      return String(value);
-    default:
-      return String(value);
-  }
-}
-function prepareBlocksForSubmission(formData, blockTypes) {
-  return Object.keys(formData).filter((key) => formData[key] !== null && formData[key] !== void 0).map((key) => ({
-    key,
-    value: blockTypes?.[key] === "list" && !Array.isArray(formData[key]) ? [formData[key]] : formData[key]
-  }));
-}
-function extractBlockValues(blocks) {
-  const values = {};
-  blocks.forEach((block) => {
-    values[block.key] = block.value ?? null;
-  });
-  return values;
-}
-var getBlockValue = (entry, blockKey) => {
-  const block = entry?.blocks?.find((f) => f.key === blockKey);
-  return block?.value ?? null;
-};
-var getBlockTextValue = (block, locale = "en") => {
-  if (!block || block.value === null || block.value === void 0) return "";
-  if (block.type === "localized_text" || block.type === "markdown") {
-    if (typeof block.value === "object" && block.value !== null) {
-      return block.value[locale] ?? block.value["en"] ?? "";
-    }
-  }
-  if (typeof block.value === "string") return block.value;
-  return String(block.value ?? "");
-};
-var getBlockValues = (entry, blockKey) => {
-  const block = entry?.blocks?.find((f) => f.key === blockKey);
-  if (!block) return [];
-  if (block.type === "list" && Array.isArray(block.value)) {
-    return block.value;
-  }
-  return [];
-};
-function unwrapBlock(block, locale) {
-  if (!block?.type || block.value === void 0) return block;
-  if (block.type === "list") {
-    return block.value.map((obj) => {
-      const parsed = {};
-      for (const [k, v] of Object.entries(obj)) {
-        parsed[k] = unwrapBlock(v, locale);
-      }
-      return parsed;
-    });
-  }
-  if (block.type === "map") {
-    const parsed = {};
-    for (const [k, v] of Object.entries(block.value || {})) {
-      parsed[k] = unwrapBlock(v, locale);
-    }
-    return parsed;
-  }
-  if (block.type === "localized_text" || block.type === "markdown") {
-    return block.value?.[locale];
-  }
-  return block.value;
-}
-var getBlockObjectValues = (entry, blockKey, locale = "en") => {
-  const block = entry?.blocks?.find((f) => f.key === blockKey);
-  if (!block || block.type !== "list" || !Array.isArray(block.value)) return [];
-  return block.value.map((obj) => {
-    if (!obj?.value || !Array.isArray(obj.value)) return {};
-    return obj.value.reduce((acc, current) => {
-      acc[current.key] = unwrapBlock(current, locale);
-      return acc;
-    }, {});
-  });
-};
-var getBlockFromArray = (entry, blockKey, locale = "en") => {
-  const block = entry?.blocks?.find((f) => f.key === blockKey);
-  if (!block) return {};
-  if (block.type === "list" && Array.isArray(block.value)) {
-    return block.value.reduce((acc, current) => {
-      acc[current.key] = unwrapBlock(current, locale);
-      return acc;
-    }, {});
-  }
-  if (block.type === "map" && block.value && typeof block.value === "object") {
-    const result = {};
-    for (const [k, v] of Object.entries(block.value)) {
-      result[k] = unwrapBlock(v, locale);
-    }
-    return result;
-  }
-  return { [block.key]: unwrapBlock(block, locale) };
-};
-var getImageUrl = (imageBlock, isBlock = true) => {
-  if (!imageBlock) return null;
-  if (imageBlock.type === "relationship_media") {
-    const mediaValue = imageBlock.value;
-    return mediaValue?.resolutions?.original?.url || mediaValue?.url || null;
-  }
-  if (isBlock) {
-    if (typeof imageBlock === "string") return imageBlock;
-    if (imageBlock.url) return imageBlock.url;
-  }
-  return imageBlock.resolutions?.original?.url || null;
-};
-
-// src/utils/orderItems.ts
-function normalizeOrderCheckoutItems(items) {
-  return items.map((item) => {
-    if ("type" in item) {
-      return item;
-    }
-    if ("product_id" in item) {
-      return { type: "product", ...item };
-    }
-    return { type: "service", ...item };
-  });
-}
-function normalizePublicCheckoutItems(items) {
-  return normalizeOrderCheckoutItems(items).map((item) => {
-    const { price: _price, ...publicItem } = item;
-    return publicItem;
-  });
-}
-
-// src/api/storefront.ts
-var COMMON_ACTIVITY_TYPES = [
-  "page_view",
-  "product_view",
-  "service_view",
-  "provider_view",
-  "cart_added",
-  "cart_removed",
-  "checkout_started",
-  "purchase",
-  "order_created",
-  "signin",
-  "signup",
-  "verified_email",
-  "search",
-  "share",
-  "wishlist_added"
-];
-var createActivityApi = (apiConfig) => ({
-  COMMON_ACTIVITY_TYPES,
-  async track(params) {
-    try {
-      await apiConfig.httpClient.post(
-        `/v1/storefront/${apiConfig.storeId}/activities/track`,
-        { type: params.type, payload: params.payload }
-      );
-    } catch {
-    }
-  }
-});
-var createStorefrontApi = (apiConfig, updateProfileSession) => {
-  const base = (storeId = apiConfig.storeId) => `/v1/storefront/${storeId}`;
-  return {
-    store: {
-      getStore(options) {
-        return apiConfig.httpClient.get(base(), options);
-      },
-      location: {
-        getCountries(options) {
-          return apiConfig.httpClient.get(`/v1/platform/countries`, options);
-        },
-        getCountry(countryCode, options) {
-          return apiConfig.httpClient.get(
-            `/v1/platform/countries/${countryCode}`,
-            options
-          );
-        },
-        list(options) {
-          return apiConfig.httpClient.get(`${base()}/locations`, options);
-        },
-        get(id, options) {
-          return apiConfig.httpClient.get(`${base()}/locations/${id}`, options);
-        }
-      },
-      market: {
-        list(options) {
-          return apiConfig.httpClient.get(`${base()}/markets`, options);
-        },
-        get(id, options) {
-          return apiConfig.httpClient.get(`${base()}/markets/${id}`, options);
-        }
-      }
-    },
-    cms: {
-      node: {
-        async get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          let identifier;
-          if (params.id) {
-            identifier = params.id;
-          } else if (params.slug) {
-            identifier = `${store_id}:${apiConfig.locale}:${params.slug}`;
-          } else if (params.key) {
-            identifier = `${store_id}:${params.key}`;
-          } else {
-            throw new Error("GetNodeParams requires id, slug, or key");
-          }
-          const response = await apiConfig.httpClient.get(
-            `${base(store_id)}/nodes/${identifier}`,
-            options
-          );
-          return {
-            ...response,
-            getBlock(key) {
-              return getBlockFromArray(response, key, apiConfig.locale);
-            },
-            getBlockValues(key) {
-              return getBlockObjectValues(response, key, apiConfig.locale);
-            },
-            getImage(key) {
-              const block = getBlockFromArray(response, key, apiConfig.locale);
-              return getImageUrl(block, true);
-            }
-          };
-        },
-        find(params, options) {
-          const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/nodes`, {
-            ...options,
-            params: queryParams
-          });
-        },
-        getChildren(params, options) {
-          const { id, store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/nodes/${id}/children`, {
-            ...options,
-            params: queryParams
-          });
-        }
-      },
-      form: {
-        get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          let identifier;
-          if (params.id) {
-            identifier = params.id;
-          } else if (params.key) {
-            identifier = `${store_id}:${params.key}`;
-          } else {
-            throw new Error("GetFormParams requires id or key");
-          }
-          return apiConfig.httpClient.get(
-            `${base(store_id)}/forms/${identifier}`,
-            options
-          );
-        },
-        submit(params, options) {
-          const { store_id, form_id, ...payload } = params;
-          const target_store_id = store_id || apiConfig.storeId;
-          if (!form_id) {
-            throw new Error("SubmitFormParams requires form_id");
-          }
-          return apiConfig.httpClient.post(
-            `${base(target_store_id)}/forms/${form_id}/submissions`,
-            { ...payload, form_id, store_id: target_store_id },
-            options
-          );
-        }
-      },
-      taxonomy: {
-        get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          let identifier;
-          if (params.id) {
-            identifier = params.id;
-          } else if (params.key) {
-            identifier = `${store_id}:${params.key}`;
-          } else {
-            throw new Error("GetTaxonomyParams requires id or key");
-          }
-          return apiConfig.httpClient.get(
-            `${base(store_id)}/taxonomies/${identifier}`,
-            options
-          );
-        },
-        getChildren(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          return apiConfig.httpClient.get(
-            `${base(store_id)}/taxonomies/${params.id}/children`,
-            options
-          );
-        }
-      }
-    },
-    eshop: {
-      product: {
-        get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          let identifier;
-          if (params.id) {
-            identifier = params.id;
-          } else if (params.slug) {
-            identifier = `${store_id}:${apiConfig.locale}:${params.slug}`;
-          } else {
-            throw new Error("GetProductParams requires id or slug");
-          }
-          return apiConfig.httpClient.get(
-            `${base(store_id)}/products/${identifier}`,
-            options
-          );
-        },
-        find(params, options) {
-          const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/products`, {
-            ...options,
-            params: queryParams
-          });
-        }
-      },
-      cart: {
-        current(params = {}, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          const { store_id: _store_id, ...payload } = params;
-          return apiConfig.httpClient.post(
-            `${base(store_id)}/carts/current`,
-            { ...payload, store_id, market: payload.market || apiConfig.market },
-            options
-          );
-        },
-        get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          return apiConfig.httpClient.get(`${base(store_id)}/carts/${params.id}`, {
-            ...options,
-            params: params.token ? { token: params.token } : options?.params
-          });
-        },
-        update(params, options) {
-          const { store_id, items, ...payload } = params;
-          const target = store_id || apiConfig.storeId;
-          return apiConfig.httpClient.put(
-            `${base(target)}/carts/${params.id}`,
-            {
-              ...payload,
-              store_id: target,
-              ...items ? { items: normalizePublicCheckoutItems(items) } : {}
-            },
-            options
-          );
-        },
-        addItem(params, options) {
-          const { store_id, item, ...payload } = params;
-          const target = store_id || apiConfig.storeId;
-          return apiConfig.httpClient.post(
-            `${base(target)}/carts/${params.id}/items`,
-            {
-              ...payload,
-              store_id: target,
-              item: normalizePublicCheckoutItems([item])[0]
-            },
-            options
-          );
-        },
-        removeItem(params, options) {
-          const { store_id, ...payload } = params;
-          const target = store_id || apiConfig.storeId;
-          return apiConfig.httpClient.post(
-            `${base(target)}/carts/${params.id}/items/remove`,
-            { ...payload, store_id: target },
-            options
-          );
-        },
-        clear(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          return apiConfig.httpClient.post(
-            `${base(store_id)}/carts/${params.id}/clear`,
-            { id: params.id, store_id },
-            options
-          );
-        },
-        quote(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          return apiConfig.httpClient.post(
-            `${base(store_id)}/carts/${params.id}/quote`,
-            { id: params.id, store_id },
-            options
-          );
-        },
-        checkout(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          return apiConfig.httpClient.post(
-            `${base(store_id)}/carts/${params.id}/checkout`,
-            {
-              id: params.id,
-              store_id,
-              payment_method_id: params.payment_method_id
-            },
-            options
-          );
-        }
-      },
-      order: {
-        get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          return apiConfig.httpClient.get(
-            `${base(store_id)}/orders/${params.id}`,
-            options
-          );
-        },
-        find(params, options) {
-          const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/orders`, {
-            ...options,
-            params: queryParams
-          });
-        }
-      },
-      service: {
-        get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          let identifier;
-          if (params.id) {
-            identifier = params.id;
-          } else if (params.slug) {
-            identifier = `${store_id}:${apiConfig.locale}:${params.slug}`;
-          } else {
-            throw new Error("GetServiceParams requires id or slug");
-          }
-          return apiConfig.httpClient.get(
-            `${base(store_id)}/services/${identifier}`,
-            options
-          );
-        },
-        find(params, options) {
-          const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/services`, {
-            ...options,
-            params: queryParams
-          });
-        },
-        findProviders(params, options) {
-          const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/service-providers`, {
-            ...options,
-            params: queryParams
-          });
-        },
-        getAvailability(params, options) {
-          const { store_id, ...queryParams } = params;
-          const target_store_id = store_id || apiConfig.storeId;
-          return apiConfig.httpClient.get(
-            `${base(target_store_id)}/services/availability`,
-            { ...options, params: queryParams }
-          );
-        }
-      },
-      provider: {
-        get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          let identifier;
-          if (params.id) {
-            identifier = params.id;
-          } else if (params.slug) {
-            identifier = `${store_id}:${apiConfig.locale}:${params.slug}`;
-          } else {
-            throw new Error("GetProviderParams requires id or slug");
-          }
-          return apiConfig.httpClient.get(
-            `${base(store_id)}/providers/${identifier}`,
-            options
-          );
-        },
-        find(params, options) {
-          const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/providers`, {
-            ...options,
-            params: queryParams
-          });
-        }
-      }
-    },
-    crm: {
-      profile: {
-        async identify(params, options) {
-          const store_id = apiConfig.storeId;
-          const result = await apiConfig.httpClient.post(
-            `${base(store_id)}/profiles/identify`,
-            {
-              store_id,
-              market: params?.market || apiConfig.market || null,
-              email: params?.email,
-              verify: params?.verify ?? false
-            },
-            options
-          );
-          if (result?.token?.token) {
-            updateProfileSession(() => ({
-              access_token: result.token.token,
-              profile: result.profile,
-              store: result.store,
-              market: result.market
-            }));
-          }
-          return result;
-        },
-        async verify(params, options) {
-          const store_id = apiConfig.storeId;
-          const result = await apiConfig.httpClient.post(
-            `${base(store_id)}/profiles/verify`,
-            { store_id, code: params.code },
-            options
-          );
-          if (result?.token) {
-            updateProfileSession(
-              (prev) => prev ? { ...prev, access_token: result.token } : null
-            );
-          }
-          return result;
-        },
-        async logout(options) {
-          const store_id = apiConfig.storeId;
-          try {
-            await apiConfig.httpClient.post(
-              `${base(store_id)}/profiles/logout`,
-              {},
-              options
-            );
-          } finally {
-            updateProfileSession(() => null);
-          }
-        },
-        getMe(options) {
-          return apiConfig.httpClient.get(`${base()}/profiles/me`, options);
-        }
-      },
-      profileList: {
-        get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          return apiConfig.httpClient.get(
-            `${base(store_id)}/profile-lists/${params.id}`,
-            options
-          );
-        },
-        find(params, options) {
-          const { store_id, ...queryParams } = params || {};
-          return apiConfig.httpClient.get(`${base(store_id)}/profile-lists`, {
-            ...options,
-            params: queryParams
-          });
-        },
-        subscribe(params, options) {
-          const { store_id, id, ...payload } = params;
-          return apiConfig.httpClient.post(
-            `${base(store_id)}/profile-lists/${id}/subscribe`,
-            payload,
-            options
-          );
-        },
-        checkAccess(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          return apiConfig.httpClient.get(
-            `${base(store_id)}/profile-lists/${params.id}/access`,
-            options
-          );
-        },
-        unsubscribe(token, options) {
-          return apiConfig.httpClient.get(`${base()}/profile-lists/unsubscribe`, {
-            ...options,
-            params: { token }
-          });
-        },
-        confirm(token, options) {
-          return apiConfig.httpClient.get(`${base()}/profile-lists/confirm`, {
-            ...options,
-            params: { token }
-          });
-        }
-      }
-    },
-    activity: createActivityApi(apiConfig)
-  };
-};
-
-// src/cartController.ts
-function hasCartId(params) {
-  return "id" in params && typeof params.id === "string" && params.id.length > 0;
-}
-function createCartController(cartApi) {
-  const listeners = /* @__PURE__ */ new Set();
-  let state = {
-    cart: null,
-    quote: null,
-    checkoutResult: null,
-    loading: false,
-    initialized: false,
-    error: null
-  };
-  function emit() {
-    for (const listener of listeners) {
-      Promise.resolve().then(() => listener(state)).catch(() => {
-      });
-    }
-  }
-  function setState(patch) {
-    state = { ...state, ...patch };
-    emit();
-    return state;
-  }
-  function currentCartId(id) {
-    const cartId = id || state.cart?.id;
-    if (!cartId) {
-      throw new Error("Cart has not been initialized and no cart id was provided");
-    }
-    return cartId;
-  }
-  async function runCartMutation(operation) {
-    setState({ loading: true, error: null });
-    try {
-      const cart = await operation();
-      setState({
-        cart,
-        quote: null,
-        checkoutResult: null,
-        loading: false,
-        initialized: true,
-        error: null
-      });
-      return cart;
-    } catch (error) {
-      setState({ loading: false, error });
-      throw error;
-    }
-  }
-  return {
-    subscribe(listener) {
-      listeners.add(listener);
-      Promise.resolve().then(() => listener(state)).catch(() => {
-      });
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    getState() {
-      return state;
-    },
-    init(params = {}, options) {
-      if (state.initialized && state.cart) {
-        return Promise.resolve(state.cart);
-      }
-      return this.refresh(params, options);
-    },
-    refresh(params = {}, options) {
-      return runCartMutation(
-        () => hasCartId(params) ? cartApi.get(params, options) : cartApi.current(params, options)
-      );
-    },
-    addItem(params, options) {
-      return runCartMutation(
-        () => cartApi.addItem({ ...params, id: currentCartId(params.id) }, options)
-      );
-    },
-    update(params, options) {
-      return runCartMutation(
-        () => cartApi.update({ ...params, id: currentCartId(params.id) }, options)
-      );
-    },
-    removeItem(params, options) {
-      return runCartMutation(
-        () => cartApi.removeItem({ ...params, id: currentCartId(params.id) }, options)
-      );
-    },
-    clear(params = {}, options) {
-      return runCartMutation(
-        () => cartApi.clear({ ...params, id: currentCartId(params.id) }, options)
-      );
-    },
-    async quote(params = {}, options) {
-      setState({ loading: true, error: null });
-      try {
-        const quote = await cartApi.quote(
-          { ...params, id: currentCartId(params.id) },
-          options
-        );
-        setState({ quote, loading: false, error: null });
-        return quote;
-      } catch (error) {
-        setState({ loading: false, error });
-        throw error;
-      }
-    },
-    async checkout(params = {}, options) {
-      setState({ loading: true, error: null });
-      try {
-        const checkoutResult = await cartApi.checkout(
-          { ...params, id: currentCartId(params.id) },
-          options
-        );
-        setState({ checkoutResult, loading: false, error: null });
-        return checkoutResult;
-      } catch (error) {
-        setState({ loading: false, error });
-        throw error;
-      }
-    }
-  };
-}
-
-// src/utils/errors.ts
-var convertServerErrorToRequestError = (serverError, renameRules) => {
-  const validationErrors = serverError?.validationErrors ?? [];
-  return {
-    ...serverError,
-    validationErrors: validationErrors.map((validationError) => {
-      const field = validationError.field;
-      return {
-        field,
-        error: validationError.error || "GENERAL.VALIDATION_ERROR"
-      };
-    })
-  };
-};
-
-// src/utils/queryParams.ts
-function buildQueryString(params) {
-  const queryParts = [];
-  Object.entries(params).forEach(([key, value]) => {
-    if (value === null || value === void 0) {
-      return;
-    }
-    if (Array.isArray(value)) {
-      const jsonString = JSON.stringify(value);
-      queryParts.push(`${key}=${encodeURIComponent(jsonString)}`);
-    } else if (typeof value === "string") {
-      queryParts.push(`${key}=${encodeURIComponent(value)}`);
-    } else if (typeof value === "number" || typeof value === "boolean") {
-      queryParts.push(`${key}=${value}`);
-    } else if (typeof value === "object") {
-      const jsonString = JSON.stringify(value);
-      queryParts.push(`${key}=${encodeURIComponent(jsonString)}`);
-    }
-  });
-  return queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
-}
-
-// src/services/createHttpClient.ts
-function createHttpClient(cfg) {
-  const { authStorage } = cfg;
-  let refreshPromise = null;
-  function getRefreshEndpoint() {
-    const refreshPath = typeof cfg.refreshPath === "function" ? cfg.refreshPath() : cfg.refreshPath || "/v1/auth/refresh";
-    return `${cfg.baseUrl}${refreshPath}`;
-  }
-  async function ensureFreshToken() {
-    if (refreshPromise) {
-      return refreshPromise;
-    }
-    refreshPromise = (async () => {
-      const tokens = authStorage.getTokens();
-      const refresh_token = tokens?.refresh_token;
-      if (!refresh_token) {
-        authStorage.onForcedLogout();
-        const err = new Error("No refresh token available");
-        err.name = "ApiError";
-        err.statusCode = 401;
-        throw err;
-      }
-      const refRes = await fetch(getRefreshEndpoint(), {
-        method: "POST",
-        headers: { Accept: "application/json", "Content-Type": "application/json" },
-        body: JSON.stringify({ refresh_token })
-      });
-      if (!refRes.ok) {
-        authStorage.onForcedLogout();
-        const err = new Error("Token refresh failed");
-        err.name = "ApiError";
-        err.statusCode = 401;
-        throw err;
-      }
-      const data = await refRes.json();
-      authStorage.onTokensRefreshed(data);
-    })().finally(() => {
-      refreshPromise = null;
-    });
-    return refreshPromise;
-  }
-  async function request(method, path, body, options) {
-    if (options?.transformRequest) {
-      body = options.transformRequest(body);
-    }
-    const headers = {
-      Accept: "application/json",
-      "Content-Type": "application/json",
-      ...options?.headers || {}
-    };
-    let tokens = authStorage.getTokens();
-    const nowSec = Date.now() / 1e3;
-    if (tokens?.access_expires_at && nowSec > tokens.access_expires_at) {
-      await ensureFreshToken();
-      tokens = authStorage.getTokens();
-    }
-    if (tokens?.access_token) {
-      headers["Authorization"] = `Bearer ${tokens.access_token}`;
-    }
-    const finalPath = options?.params ? path + buildQueryString(options.params) : path;
-    const fetchOpts = { method, headers };
-    if (!["GET", "DELETE"].includes(method) && body !== void 0) {
-      fetchOpts.body = JSON.stringify(body);
-    }
-    const fullUrl = `${cfg.baseUrl}${finalPath}`;
-    let res;
-    let data;
-    const startedAt = Date.now();
-    try {
-      res = await fetch(fullUrl, fetchOpts);
-    } catch (error) {
-      const err = new Error(error instanceof Error ? error.message : "Network request failed");
-      err.name = "NetworkError";
-      err.method = method;
-      err.url = fullUrl;
-      if (options?.onError && method !== "GET") {
-        Promise.resolve(
-          options.onError({ error: err, method, url: fullUrl, aborted: false })
-        ).catch(() => {
-        });
-      }
-      throw err;
-    }
-    if (res.status === 401 && !options?.["_retried"]) {
-      try {
-        await ensureFreshToken();
-        const refreshed = authStorage.getTokens();
-        if (refreshed?.access_token) {
-          headers["Authorization"] = `Bearer ${refreshed.access_token}`;
-          fetchOpts.headers = headers;
-        }
-        return request(method, path, body, { ...options, _retried: true });
-      } catch (refreshError) {
-        throw refreshError;
-      }
-    }
-    try {
-      const contentLength = res.headers.get("content-length");
-      const contentType = res.headers.get("content-type");
-      if (res.status === 204 || contentLength === "0" || !contentType?.includes("application/json")) {
-        data = {};
-      } else {
-        data = await res.json();
-      }
-    } catch (error) {
-      const err = new Error("Failed to parse response");
-      err.name = "ParseError";
-      err.method = method;
-      err.url = fullUrl;
-      err.status = res.status;
-      if (options?.onError && method !== "GET") {
-        Promise.resolve(
-          options.onError({ error: err, method, url: fullUrl, status: res.status })
-        ).catch(() => {
-        });
-      }
-      throw err;
-    }
-    if (!res.ok) {
-      const serverErr = data;
-      const reqErr = convertServerErrorToRequestError(serverErr);
-      const err = new Error(serverErr.message || "Request failed");
-      err.name = "ApiError";
-      err.statusCode = serverErr.statusCode || res.status;
-      err.validationErrors = reqErr.validationErrors;
-      err.method = method;
-      err.url = fullUrl;
-      const requestId = res.headers.get("x-request-id") || res.headers.get("request-id");
-      if (requestId) err.requestId = requestId;
-      if (options?.onError && method !== "GET") {
-        Promise.resolve(
-          options.onError({
-            error: err,
-            method,
-            url: fullUrl,
-            status: res.status,
-            response: serverErr,
-            request_id: requestId || null,
-            duration_ms: Date.now() - startedAt
-          })
-        ).catch(() => {
-        });
-      }
-      throw err;
-    }
-    if (options?.onSuccess && method !== "GET") {
-      const requestId = res.headers.get("x-request-id") || res.headers.get("request-id");
-      Promise.resolve(
-        options.onSuccess({
-          data,
-          method,
-          url: fullUrl,
-          status: res.status,
-          request_id: requestId || null,
-          duration_ms: Date.now() - startedAt
-        })
-      ).catch(() => {
-      });
-    }
-    return data;
-  }
-  return {
-    get: (path, opts) => request("GET", path, void 0, opts),
-    post: (path, body, opts) => request("POST", path, body, opts),
-    put: (path, body, opts) => request("PUT", path, body, opts),
-    patch: (path, body, opts) => request("PATCH", path, body, opts),
-    delete: (path, opts) => request("DELETE", path, void 0, opts)
-  };
-}
-
-// src/api/support.ts
-function supportConversationQuery(params) {
-  const qs = new URLSearchParams({ store_id: params.store_id });
-  if (params.message_limit) qs.set("message_limit", String(params.message_limit));
-  if (typeof params.after_created_at === "number") qs.set("after_created_at", String(params.after_created_at));
-  if (params.after_id) qs.set("after_id", params.after_id);
-  return qs.toString();
-}
-function createStorefrontSupportApi(config) {
-  const { httpClient, storeId } = config;
-  return {
-    async startConversation(params = {}, opts) {
-      return httpClient.post(
-        `/v1/storefront/${storeId}/support/conversations`,
-        { store_id: storeId, ...params },
-        opts
-      );
-    },
-    async sendMessage(params, opts) {
-      return httpClient.post(
-        `/v1/storefront/${storeId}/support/conversations/${params.conversation_id}/messages`,
-        { store_id: storeId, ...params },
-        opts
-      );
-    },
-    async getConversation(params, opts) {
-      const qs = supportConversationQuery({ store_id: storeId, ...params });
-      return httpClient.get(
-        `/v1/storefront/${storeId}/support/conversations/${params.conversation_id}?${qs}`,
-        opts
-      );
-    }
-  };
-}
-
-// src/utils/price.ts
-function formatCurrency(amount, currencyCode, locale = "en") {
-  if (!currencyCode) return "";
-  return new Intl.NumberFormat(locale, {
-    style: "currency",
-    currency: currencyCode.toUpperCase()
-  }).format(amount);
-}
-function getMinorUnits(currency) {
-  try {
-    const formatter = new Intl.NumberFormat("en", {
-      style: "currency",
-      currency: currency.toUpperCase()
-    });
-    const parts = formatter.formatToParts(1.11);
-    const fractionPart = parts.find((p) => p.type === "fraction");
-    return fractionPart?.value.length ?? 2;
-  } catch {
-    return 2;
-  }
-}
-function convertToMajor(minorAmount, currency) {
-  const units = getMinorUnits(currency);
-  return minorAmount / Math.pow(10, units);
-}
-function getCurrencySymbol(currency) {
-  try {
-    return new Intl.NumberFormat("en", {
-      style: "currency",
-      currency: currency.toUpperCase(),
-      currencyDisplay: "narrowSymbol"
-    }).formatToParts(0).find((p) => p.type === "currency")?.value || currency.toUpperCase();
-  } catch {
-    return currency.toUpperCase();
-  }
-}
-function getCurrencyName(currency) {
-  try {
-    return new Intl.DisplayNames(["en"], { type: "currency" }).of(currency.toUpperCase()) || currency.toUpperCase();
-  } catch {
-    return currency.toUpperCase();
-  }
-}
-function formatMinor(amountMinor, currency) {
-  if (!currency) return "";
-  return formatCurrency(convertToMajor(amountMinor, currency), currency);
-}
-function formatPayment(payment) {
-  return formatMinor(payment.total, payment.currency);
-}
-function formatPrice(prices, marketId) {
-  if (!prices || prices.length === 0) return "";
-  const price = marketId ? prices.find((p) => p.market === marketId) || prices[0] : prices[0];
-  if (!price) return "";
-  return formatMinor(price.amount, price.currency);
-}
-function getPriceAmount(prices, marketId) {
-  if (!prices || prices.length === 0) return 0;
-  const price = prices.find((p) => p.market === marketId) || prices[0];
-  return price?.amount || 0;
-}
-
-// src/utils/validation.ts
-function validatePhoneNumber(phone) {
-  if (!phone) {
-    return { isValid: false, error: "Phone number is required" };
-  }
-  const cleaned = phone.replace(/\D/g, "");
-  if (cleaned.length < 8) {
-    return { isValid: false, error: "Phone number is too short" };
-  }
-  if (cleaned.length > 15) {
-    return { isValid: false, error: "Phone number is too long" };
-  }
-  return { isValid: true };
-}
-
-// src/utils/timezone.ts
-var tzGroups = [
-  {
-    label: "US",
-    zones: [
-      { label: "Eastern Time", value: "America/New_York" },
-      { label: "Central Time", value: "America/Chicago" },
-      { label: "Mountain Time", value: "America/Denver" },
-      { label: "Pacific Time", value: "America/Los_Angeles" }
-    ]
-  },
-  {
-    label: "Europe",
-    zones: [
-      { label: "London", value: "Europe/London" },
-      { label: "Paris", value: "Europe/Paris" },
-      { label: "Berlin", value: "Europe/Berlin" },
-      { label: "Rome", value: "Europe/Rome" }
-    ]
-  },
-  {
-    label: "Asia",
-    zones: [
-      { label: "Tokyo", value: "Asia/Tokyo" },
-      { label: "Shanghai", value: "Asia/Shanghai" },
-      { label: "Mumbai", value: "Asia/Kolkata" },
-      { label: "Dubai", value: "Asia/Dubai" }
-    ]
-  }
-];
-function findTimeZone(groups) {
-  try {
-    const detected = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    for (const group of groups) {
-      for (const zone of group.zones) {
-        if (zone.value === detected) {
-          return detected;
-        }
-      }
-    }
-    return "UTC";
-  } catch (e) {
-    return "UTC";
-  }
-}
-
-// src/utils/text.ts
-var locales = ["en", "sr-latn"];
-var localeMap = {
-  "en": "en-US",
-  "sr-latn": "sr-RS"
-};
-function slugify(text) {
-  return text.toString().toLowerCase().replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/--+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
-}
-function humanize(text) {
-  const slugifiedText = slugify(text);
-  return slugifiedText.replace(/-/g, " ").replace(
-    /\w\S*/g,
-    (w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()
-  );
-}
-function categorify(text) {
-  const slugifiedText = slugify(text);
-  return slugifiedText.replace(/-/g, " ").toUpperCase();
-}
-function formatDate(date, locale) {
-  let localeString = "en-US";
-  if (locales.includes(locale)) {
-    localeString = localeMap[locale];
-  }
-  return new Date(date).toLocaleDateString(localeString, {
-    timeZone: "UTC",
-    year: "numeric",
-    month: "short",
-    day: "numeric"
-  });
-}
-
-// src/utils/svg.ts
-async function fetchSvgContent(mediaObject) {
-  if (!mediaObject) return null;
-  const svgUrl = getImageUrl(mediaObject, false);
-  try {
-    const response = await fetch(svgUrl);
-    if (!response.ok) {
-      console.error(`Failed to fetch SVG: ${response.status} ${response.statusText}`);
-      return null;
-    }
-    const svgContent = await response.text();
-    return svgContent;
-  } catch (error) {
-    console.error("Error fetching SVG:", error);
-    return null;
-  }
-}
-async function getSvgContentForAstro(mediaObject) {
-  try {
-    const svgContent = await fetchSvgContent(mediaObject);
-    return svgContent || "";
-  } catch (error) {
-    console.error("Error getting SVG content for Astro:", error);
-    return "";
-  }
-}
-async function injectSvgIntoElement(mediaObject, targetElement, className) {
-  if (!targetElement) return;
-  try {
-    const svgContent = await fetchSvgContent(mediaObject);
-    if (svgContent) {
-      targetElement.innerHTML = svgContent;
-      if (className) {
-        const svgElement = targetElement.querySelector("svg");
-        if (svgElement) {
-          svgElement.classList.add(...className.split(" "));
-        }
-      }
-    }
-  } catch (error) {
-    console.error("Error injecting SVG:", error);
-  }
-}
-
-// src/utils/keyValidation.ts
-var KEY_PATTERN = /^[a-zA-Z0-9_-]+$/;
-function isValidKey(key) {
-  if (!key || key.length === 0) return false;
-  return KEY_PATTERN.test(key);
-}
-function validateKey(key) {
-  if (!key || key.length === 0) {
-    return { valid: false, error: "Key is required" };
-  }
-  if (key.length > 255) {
-    return { valid: false, error: "Key must be 255 characters or less" };
-  }
-  if (!KEY_PATTERN.test(key)) {
-    return {
-      valid: false,
-      error: "Key can only contain letters, numbers, underscores (_) and hyphens (-)"
-    };
-  }
-  return { valid: true };
-}
-function toKey(input) {
-  if (!input) return "";
-  return input.toLowerCase().trim().replace(/\s+/g, "_").replace(/[^a-z0-9_-]/g, "").replace(/^[-_]+|[-_]+$/g, "").replace(/[-_]{2,}/g, "_");
-}
-function nameToKey(name) {
-  return toKey(name);
-}
-
-// src/utils/inventory.ts
-function getAvailableStock(variant) {
-  if (!variant?.inventory) return 0;
-  return variant.inventory.reduce((sum, inv) => sum + inv.available, 0);
-}
-function getReservedStock(variant) {
-  if (!variant?.inventory) return 0;
-  return variant.inventory.reduce((sum, inv) => sum + inv.reserved, 0);
-}
-function hasStock(variant, quantity = 1) {
-  return getAvailableStock(variant) >= quantity;
-}
-function getInventoryAt(variant, locationId) {
-  return variant?.inventory?.find((inv) => inv.location_id === locationId);
-}
-function getFirstAvailableFCId(variant, quantity = 1) {
-  const inv = variant?.inventory?.find((i) => i.available >= quantity);
-  return inv?.location_id;
-}
-
-// src/index.ts
-function createUtilitySurface(apiConfig) {
-  return {
-    getImageUrl: (imageBlock, isBlock = true) => getImageUrl(imageBlock, isBlock),
-    getBlockValue,
-    getBlockTextValue,
-    getBlockValues,
-    getBlockLabel,
-    getBlockObjectValues,
-    getBlockFromArray,
-    formatBlockValue,
-    prepareBlocksForSubmission,
-    extractBlockValues,
-    formatPrice: (prices) => formatPrice(prices, apiConfig.market),
-    getPriceAmount: (prices) => getPriceAmount(prices, apiConfig.market),
-    formatPayment,
-    formatMinor,
-    getCurrencySymbol,
-    getCurrencyName,
-    validatePhoneNumber,
-    tzGroups,
-    findTimeZone,
-    slugify,
-    humanize,
-    categorify,
-    formatDate,
-    getSvgContentForAstro,
-    fetchSvgContent,
-    injectSvgIntoElement,
-    isValidKey,
-    validateKey,
-    toKey,
-    nameToKey,
-    getAvailableStock,
-    getReservedStock,
-    hasStock,
-    getInventoryAt,
-    getFirstAvailableFCId
-  };
-}
-var PROFILE_STORAGE_KEY = "arky_profile_session";
-function readProfileSession() {
-  if (typeof window === "undefined") return null;
-  try {
-    const raw = localStorage.getItem(PROFILE_STORAGE_KEY);
-    return raw ? JSON.parse(raw) : null;
-  } catch {
-    return null;
-  }
-}
-function writeProfileSession(s) {
-  if (typeof window === "undefined") return;
-  if (s) {
-    localStorage.setItem(PROFILE_STORAGE_KEY, JSON.stringify(s));
-  } else {
-    localStorage.removeItem(PROFILE_STORAGE_KEY);
-  }
-}
-function createStorefront(config) {
-  const locale = config.locale || "en";
-  const initialMarket = config.market || "";
-  const listeners = /* @__PURE__ */ new Set();
-  let bareIdentifyPromise = null;
-  function toPublic(s) {
-    return s ? { profile: s.profile, store: s.store, market: s.market } : null;
-  }
-  function emit() {
-    const pub = toPublic(readProfileSession());
-    for (const l of listeners) {
-      Promise.resolve().then(() => l(pub)).catch(() => {
-      });
-    }
-  }
-  const updateSession = (updater) => {
-    if (config.apiToken) return;
-    const prev = readProfileSession();
-    const next = updater(prev);
-    writeProfileSession(next);
-    emit();
-  };
-  const authStorage = config.apiToken ? {
-    getTokens: () => ({ access_token: config.apiToken }),
-    onTokensRefreshed: () => {
-    },
-    onForcedLogout: () => {
-    }
-  } : {
-    getTokens() {
-      const s = readProfileSession();
-      return s ? { access_token: s.access_token } : null;
-    },
-    onTokensRefreshed() {
-    },
-    onForcedLogout() {
-      bareIdentifyPromise = null;
-      updateSession(() => null);
-    }
-  };
-  const httpClient = createHttpClient({
-    baseUrl: config.baseUrl,
-    storeId: config.storeId,
-    refreshPath: config.refreshPath,
-    navigate: config.navigate,
-    loginFallbackPath: config.loginFallbackPath,
-    authStorage
-  });
-  const apiConfig = {
-    httpClient,
-    storeId: config.storeId,
-    baseUrl: config.baseUrl,
-    market: initialMarket,
-    locale,
-    authStorage
-  };
-  const storefrontApi = createStorefrontApi(apiConfig, updateSession);
-  const profileApi = storefrontApi.crm.profile;
-  function identify(params) {
-    if (params?.market !== void 0) apiConfig.market = params.market;
-    const isBareCall = !params?.email && !params?.verify;
-    if (isBareCall && bareIdentifyPromise) return bareIdentifyPromise;
-    const promise = (async () => {
-      try {
-        const result = await profileApi.identify({
-          market: apiConfig.market,
-          email: params?.email,
-          verify: params?.verify
-        });
-        return {
-          profile: result.profile,
-          store: result.store,
-          market: result.market
-        };
-      } catch (err) {
-        const e = err;
-        const status = e?.statusCode || e?.status || e?.response?.status;
-        if (isBareCall && status === 401) {
-          updateSession(() => null);
-          const result = await profileApi.identify({ market: apiConfig.market });
-          return {
-            profile: result.profile,
-            store: result.store,
-            market: result.market
-          };
-        }
-        throw err;
-      }
-    })().catch((err) => {
-      if (isBareCall) bareIdentifyPromise = null;
-      throw err;
-    });
-    if (isBareCall) bareIdentifyPromise = promise;
-    return promise;
-  }
-  async function verify(params) {
-    const result = await profileApi.verify(params);
-    bareIdentifyPromise = null;
-    return result;
-  }
-  async function logout() {
-    if (config.apiToken) return;
-    bareIdentifyPromise = null;
-    try {
-      await profileApi.logout();
-    } catch {
-      updateSession(() => null);
-    }
-  }
-  return {
-    identify,
-    verify,
-    logout,
-    me: () => profileApi.getMe(),
-    get session() {
-      if (config.apiToken) return null;
-      return toPublic(readProfileSession());
-    },
-    get isAuthenticated() {
-      if (config.apiToken) return true;
-      const s = readProfileSession();
-      return s !== null && !!s.access_token;
-    },
-    onAuthStateChanged(listener) {
-      listeners.add(listener);
-      const current = toPublic(readProfileSession());
-      if (current) {
-        Promise.resolve().then(() => listener(current)).catch(() => {
-        });
-      }
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    store: storefrontApi.store,
-    cart: createCartController(storefrontApi.eshop.cart),
-    cms: storefrontApi.cms,
-    eshop: storefrontApi.eshop,
-    crm: storefrontApi.crm,
-    activity: storefrontApi.activity,
-    support: createStorefrontSupportApi(apiConfig),
-    setStoreId: (storeId) => {
-      apiConfig.storeId = storeId;
-      bareIdentifyPromise = null;
-    },
-    getStoreId: () => apiConfig.storeId,
-    setMarket: (key) => {
-      apiConfig.market = key;
-      bareIdentifyPromise = null;
-    },
-    getMarket: () => apiConfig.market,
-    setLocale: (l) => {
-      apiConfig.locale = l;
-    },
-    getLocale: () => apiConfig.locale,
-    extractBlockValues,
-    utils: createUtilitySurface(apiConfig)
-  };
-}
-
-// src/storefrontStore/utils.ts
-function readErrorMessage(error, fallback) {
-  if (error instanceof Error && error.message) return error.message;
-  if (typeof error === "string" && error.length > 0) return error;
-  return fallback;
-}
-function createId(prefix) {
-  const cryptoValue = globalThis.crypto;
-  if (cryptoValue && "randomUUID" in cryptoValue) return cryptoValue.randomUUID();
-  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-}
-function firstLocalized(value, locale) {
-  if (typeof value === "string") return value;
-  if (!value || typeof value !== "object" || Array.isArray(value)) return "";
-  const record = value;
-  const localeValue = record[locale];
-  if (typeof localeValue === "string") return localeValue;
-  const englishValue = record.en;
-  if (typeof englishValue === "string") return englishValue;
-  for (const entry of Object.values(record)) {
-    if (typeof entry === "string") return entry;
-  }
-  return "";
-}
-function findBlock(blocks, keys) {
-  return (blocks || []).find((block) => keys.includes(block.key)) || null;
-}
-function blockText(blocks, keys, locale) {
-  const block = findBlock(blocks, keys);
-  if (!block) return "";
-  return firstLocalized(block.value, locale);
-}
-function productName(product, locale) {
-  return blockText(product.blocks, ["name", "title"], locale) || product.key || product.id;
-}
-function serviceName(service, locale) {
-  return blockText(service.blocks, ["name", "title"], locale) || service.key || service.id;
-}
-function providerName(provider, locale) {
-  return blockText(provider.blocks, ["name", "title"], locale) || provider.key || provider.id;
-}
-function entitySlug(entity, locale) {
-  return entity.slug?.[locale] || entity.slug?.en || Object.values(entity.slug || {})[0] || entity.id;
-}
-function priceForMarket(prices, market, fallbackCurrency) {
-  const price = prices.find((candidate) => candidate.market === market) || prices[0];
-  return {
-    amount: price?.amount || 0,
-    market: price?.market || market,
-    currency: price?.currency || fallbackCurrency || "",
-    compare_at: price?.compare_at,
-    profile_list_id: price?.profile_list_id
-  };
-}
-function availableStock(client, variant) {
-  const fromUtility = client.utils.getAvailableStock(variant);
-  if (Number.isFinite(fromUtility)) return fromUtility;
-  const stock = (variant.inventory || []).reduce((total, row) => total + (row.available || 0), 0);
-  return stock > 0 ? stock : void 0;
-}
-function locationToAddress(location) {
-  return {
-    country: location.country || "",
-    state: location.state || "",
-    city: location.city || "",
-    postal_code: location.postal_code || "",
-    name: "",
-    street1: "",
-    street2: null
-  };
-}
-function normalizeForms(forms) {
-  return forms;
-}
-function toProductCheckoutItems(items) {
-  return items.map((item) => ({
-    type: "product",
-    id: item.id,
-    product_id: item.product_id,
-    variant_id: item.variant_id,
-    quantity: item.quantity
-  }));
-}
-function toServiceCheckoutItems(items) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const key = `${item.service_id}:${item.provider_id}`;
-    const slot = { from: item.from, to: item.to };
-    const existing = groups.get(key);
-    if (existing) {
-      existing.slots.push(slot);
-      continue;
-    }
-    groups.set(key, {
-      type: "service",
-      id: item.id,
-      service_id: item.service_id,
-      provider_id: item.provider_id,
-      slots: [slot],
-      forms: item.forms || []
-    });
-  }
-  return [...groups.values()].map((item) => ({
-    ...item,
-    slots: [...item.slots].sort((a, b) => a.from - b.from)
-  }));
-}
-function formFieldsFromBlocks(blocks) {
-  return blocks.map((block) => ({
-    id: block.id,
-    key: block.key,
-    type: block.type,
-    value: block.value
-  }));
-}
-function getFormBlockType(field) {
-  if (field.key === "email") return "email";
-  if (field.key === "phone") return "phone";
-  if (field.type === "geo_location") return "address";
-  return field.type;
-}
-function getFormBlockValue(field) {
-  if (field.type === "boolean") return false;
-  if (field.type === "number") return field.min ?? 0;
-  if (field.type === "geo_location") return {};
-  return "";
-}
-function formSchemaToBlock(field) {
-  return {
-    id: field.id,
-    key: field.key,
-    type: getFormBlockType(field),
-    properties: {
-      isRequired: field.required,
-      minValues: field.required ? 1 : 0,
-      min: field.min,
-      max: field.max,
-      options: field.options,
-      pattern: field.key === "email" ? "^.+@.+\\..+$" : field.key === "phone" ? "^.{6,20}$" : void 0
-    },
-    value: getFormBlockValue(field)
-  };
-}
-function formatServiceTime(ts, tz) {
-  return new Date(ts * 1e3).toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    timeZone: tz
-  });
-}
-function formatServiceSlotTime(from, to, tz) {
-  return `${formatServiceTime(from, tz)} - ${formatServiceTime(to, tz)}`;
-}
-function getSlotsForDate(availability, dateStr, providerId) {
-  if (!availability) return [];
-  const slots = [];
-  for (const provider of availability.providers) {
-    if (providerId && provider.provider_id !== providerId) continue;
-    const day = provider.days.find((candidate) => candidate.date === dateStr);
-    if (!day) continue;
-    for (const slot of day.slots) {
-      if (slot.spots > 0) slots.push({ from: slot.from, to: slot.to, providerId: provider.provider_id });
-    }
-  }
-  return slots.sort((a, b) => a.from - b.from);
-}
-function hasAvailableSlotsForDate(availability, dateStr, providerId) {
-  if (!availability) return false;
-  return availability.providers.some((provider) => {
-    if (providerId && provider.provider_id !== providerId) return false;
-    const day = provider.days.find((candidate) => candidate.date === dateStr);
-    return !!day?.slots.some((slot) => slot.spots > 0);
-  });
-}
-var SERVICE_WEEKDAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
-function createServiceInitialState() {
-  return {
-    service: null,
-    availability: null,
-    providers: [],
-    selectedProviderId: null,
-    currentMonth: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), 1),
-    calendar: [],
-    selectedDate: null,
-    startDate: null,
-    endDate: null,
-    slots: [],
-    selectedSlot: null,
-    cart: [],
-    timezone: typeof window !== "undefined" ? Intl.DateTimeFormat().resolvedOptions().timeZone : "UTC",
-    tzGroups: {},
-    loading: false,
-    weekdays: SERVICE_WEEKDAYS,
-    quote: null,
-    fetchingQuote: false,
-    quoteError: null,
-    currency: null,
-    dateTimeConfirmed: false,
-    isMultiDay: false,
-    availablePaymentMethods: [],
-    cartId: null,
-    promoCode: null
-  };
-}
-function normalizeTimezoneGroups(groups) {
-  const normalized = {};
-  for (const group of groups) {
-    normalized[group.label] = group.zones.map((zone) => ({
-      zone: zone.value,
-      name: zone.label
-    }));
-  }
-  return normalized;
-}
-
-// src/storefrontStore/createArkyStore.ts
-function createArkyStore(config) {
-  const client = createStorefront(config);
-  const session = atom(client.session);
-  const locale = atom(config.locale || client.getLocale());
-  const market_key = atom(config.market || client.getMarket());
-  const market = computed(session, (value) => value?.market || null);
-  const currency = computed(market, (value) => value?.currency || null);
-  const allowed_payment_methods = computed(market, (value) => value?.payment_methods || []);
-  const payment_config = computed(session, (value) => {
-    const store = value?.store;
-    const methods = value?.market?.payment_methods || [];
-    const hasCreditCard = methods.some((method) => method.id === "credit_card");
-    return { provider: store?.payment || null, enabled: hasCreditCard && !!store?.payment };
-  });
-  const cart = atom(null);
-  const product_items = atom([]);
-  const service_items = atom([]);
-  const quote = atom(null);
-  const promo_code = atom(null);
-  const last_order = atom(null);
-  const cart_status = map({
-    loading: false,
-    syncing: false,
-    fetching_quote: false,
-    processing_checkout: false,
-    error: null,
-    quote_error: null,
-    selected_shipping_method_id: null,
-    user_token: null
-  });
-  function rawProductItemCount(value) {
-    return (value?.items || []).reduce((total, item) => {
-      if (item.type !== "product") return total;
-      return total + (item.quantity || 0);
-    }, 0);
-  }
-  function rawServiceItemCount(value) {
-    return (value?.items || []).reduce((total, item) => {
-      if (item.type !== "service") return total;
-      return total + Math.max(1, item.slots?.length || 0);
-    }, 0);
-  }
-  const product_item_count = computed(
-    [cart, product_items],
-    (cartValue, items) => Math.max(
-      rawProductItemCount(cartValue),
-      items.reduce((total, item) => total + (item.quantity || 0), 0)
-    )
-  );
-  const service_item_count = computed(
-    [cart, service_items],
-    (cartValue, items) => Math.max(rawServiceItemCount(cartValue), items.length)
-  );
-  const item_count = computed(
-    [cart, product_item_count, service_item_count],
-    (cartValue, products, services) => Math.max(cartValue?.item_count || 0, products + services)
-  );
-  const snapshot = computed([cart, product_items, service_items, item_count], (cartValue, products, services, count) => ({
-    cart: cartValue,
-    product_items: products,
-    service_items: services,
-    item_count: count
-  }));
-  let cartWriteRevision = 0;
-  let sessionRequest = null;
-  let cartRequest = null;
-  function nextCartWriteRevision() {
-    cartWriteRevision += 1;
-    return cartWriteRevision;
-  }
-  const cms_state = map({
-    nodes: {},
-    forms: {},
-    loading: false,
-    error: null
-  });
-  const eshop_state = map({
-    products: [],
-    services: [],
-    providers: [],
-    product_cursor: null,
-    service_cursor: null,
-    provider_cursor: null,
-    availability: null,
-    loading_products: false,
-    loading_services: false,
-    loading_providers: false,
-    loading_availability: false,
-    error: null
-  });
-  const service_state = map(createServiceInitialState());
-  const service_form_node = atom(null);
-  const service_form_blocks = computed(service_form_node, (node) => node?.blocks || []);
-  client.onAuthStateChanged((value) => session.set(value));
-  currency.subscribe((value) => service_state.setKey("currency", value));
-  session.subscribe((value) => {
-    const methods = value?.market?.payment_methods || [];
-    if (methods.length && service_state.get().availablePaymentMethods.length === 0) {
-      service_state.setKey("availablePaymentMethods", methods);
-    }
-  });
-  function currentMarketKey() {
-    return market_key.get() || client.getMarket() || market.get()?.key || "";
-  }
-  function currentLocale() {
-    return locale.get() || client.getLocale() || "en";
-  }
-  function currentCurrency() {
-    return currency.get() || market.get()?.currency || null;
-  }
-  function marketForLocale(value) {
-    return config.marketForLocale?.(value) || null;
-  }
-  async function ensureSession() {
-    const current = session.get();
-    const marketKey = currentMarketKey();
-    if (current && (!marketKey || current.market?.key === marketKey)) return current;
-    if (!sessionRequest) {
-      sessionRequest = identify({ market: marketKey }).finally(() => {
-        sessionRequest = null;
-      });
-    }
-    return sessionRequest;
-  }
-  async function identify(params = {}) {
-    if (params.market) setMarket(params.market);
-    const result = await client.identify({ ...params, market: params.market || currentMarketKey() });
-    session.set(result);
-    return result;
-  }
-  function setMarket(key) {
-    market_key.set(key);
-    client.setMarket(key);
-  }
-  function setLocale(value, options = {}) {
-    locale.set(value);
-    client.setLocale(value);
-    const nextMarket = options.market || marketForLocale(value);
-    if (nextMarket) setMarket(nextMarket);
-  }
-  function setContext(context) {
-    if (context.locale) {
-      setLocale(context.locale, { market: context.market });
-      return;
-    }
-    if (context.market) setMarket(context.market);
-  }
-  async function ensureCart() {
-    if (cartRequest) return cartRequest;
-    cart_status.setKey("loading", true);
-    cart_status.setKey("error", null);
-    const refreshRevision = cartWriteRevision;
-    cartRequest = (async () => {
-      await ensureSession();
-      const response = await client.cart.refresh({ market: currentMarketKey() });
-      await hydrateCart(response, { ifRevision: refreshRevision });
-      return response;
-    })();
-    try {
-      return await cartRequest;
-    } catch (error) {
-      cart_status.setKey("error", readErrorMessage(error, "Failed to load cart."));
-      throw error;
-    } finally {
-      cartRequest = null;
-      cart_status.setKey("loading", false);
-    }
-  }
-  async function hydrateProductItem(item, source) {
-    try {
-      const product = await client.eshop.product.get({ id: item.product_id });
-      const variant = product.variants.find((candidate) => candidate.id === item.variant_id);
-      if (!variant) return null;
-      return {
-        id: item.id || createId("product"),
-        product_id: product.id,
-        variant_id: variant.id,
-        product_name: productName(product, currentLocale()),
-        product_slug: entitySlug(product, currentLocale()),
-        variant_attributes: variant.attributes,
-        price: priceForMarket(variant.prices, currentMarketKey(), currentCurrency()),
-        quantity: item.quantity,
-        added_at: source.created_at ? source.created_at * 1e3 : Date.now(),
-        max_stock: availableStock(client, variant)
-      };
-    } catch {
-      return null;
-    }
-  }
-  async function hydrateServiceItems(items) {
-    const rows = [];
-    for (const item of items) {
-      let service = null;
-      let provider = null;
-      try {
-        service = await client.eshop.service.get({ id: item.service_id });
-      } catch {
-      }
-      try {
-        provider = await client.eshop.provider.get({ id: item.provider_id });
-      } catch {
-      }
-      for (const [index, slot] of item.slots.entries()) {
-        rows.push({
-          id: item.id || createId(`service_${index}`),
-          service_id: item.service_id,
-          provider_id: item.provider_id,
-          from: slot.from,
-          to: slot.to,
-          forms: item.forms || [],
-          service_name: service ? serviceName(service, currentLocale()) : item.service_id,
-          provider_name: provider ? providerName(provider, currentLocale()) : item.provider_id
-        });
-      }
-    }
-    return rows;
-  }
-  async function hydrateCart(response, options = {}) {
-    if (options.ifRevision !== void 0 && options.ifRevision !== cartWriteRevision) {
-      return cart.get() || response;
-    }
-    cart.set(response);
-    cart_status.setKey("user_token", response.token || null);
-    cart_status.setKey("selected_shipping_method_id", response.shipping_method_id || null);
-    promo_code.set(response.promo_code || null);
-    quote.set(response.quote_snapshot || null);
-    const items = response.items || [];
-    const products = await Promise.all(
-      items.filter((item) => item.type === "product").map((item) => hydrateProductItem(item, response))
-    );
-    const services = await hydrateServiceItems(
-      items.filter((item) => item.type === "service")
-    );
-    product_items.set(products.filter((item) => item !== null));
-    service_items.set(services);
-    return response;
-  }
-  function checkoutItems(input = {}) {
-    return [
-      ...toProductCheckoutItems(input.product_items || product_items.get()),
-      ...toServiceCheckoutItems(input.service_items || service_items.get())
-    ];
-  }
-  async function syncCart(input = {}, writeRevision = nextCartWriteRevision()) {
-    cart_status.setKey("syncing", true);
-    cart_status.setKey("error", null);
-    try {
-      const current = cart.get() || await ensureCart();
-      const response = await client.cart.update({
-        id: current.id,
-        market: currentMarketKey(),
-        items: checkoutItems(input),
-        shipping_address: input.shipping_address || void 0,
-        billing_address: input.billing_address || void 0,
-        forms: normalizeForms(input.forms),
-        promo_code: input.promo_code === void 0 ? promo_code.get() || void 0 : input.promo_code || void 0,
-        payment_method_id: input.payment_method_id || void 0,
-        shipping_method_id: input.shipping_method_id || cart_status.get().selected_shipping_method_id || void 0
-      });
-      if (input.promo_code !== void 0) promo_code.set(input.promo_code);
-      if (input.shipping_method_id !== void 0) {
-        cart_status.setKey("selected_shipping_method_id", input.shipping_method_id);
-      }
-      await hydrateCart(response, { ifRevision: writeRevision });
-      return response;
-    } catch (error) {
-      cart_status.setKey("error", readErrorMessage(error, "Failed to sync cart."));
-      throw error;
-    } finally {
-      cart_status.setKey("syncing", false);
-    }
-  }
-  async function addProduct(product, variant, quantity = 1) {
-    cart_status.setKey("error", null);
-    const writeRevision = nextCartWriteRevision();
-    try {
-      const current = cart.get() || await ensureCart();
-      const response = await client.cart.addItem({
-        id: current.id,
-        item: {
-          type: "product",
-          product_id: product.id,
-          variant_id: variant.id,
-          quantity
-        }
-      });
-      await hydrateCart(response, { ifRevision: writeRevision });
-      await client.activity.track({ type: "cart_added", payload: { product_id: product.id, variant_id: variant.id, quantity } });
-      return response;
-    } catch (error) {
-      cart_status.setKey("error", readErrorMessage(error, "Failed to add product to cart."));
-      throw error;
-    }
-  }
-  async function setProductQuantity(itemId, quantity) {
-    const writeRevision = nextCartWriteRevision();
-    const next = product_items.get().map((item) => {
-      if (item.id !== itemId) return item;
-      const bounded = item.max_stock ? Math.min(Math.max(1, quantity), item.max_stock) : Math.max(1, quantity);
-      return { ...item, quantity: bounded };
-    });
-    product_items.set(next);
-    return syncCart({ product_items: next }, writeRevision);
-  }
-  async function removeProduct(itemId) {
-    const writeRevision = nextCartWriteRevision();
-    const item = product_items.get().find((candidate) => candidate.id === itemId);
-    product_items.set(product_items.get().filter((candidate) => candidate.id !== itemId));
-    const current = cart.get();
-    if (!current || !item) return null;
-    const response = await client.cart.removeItem({
-      id: current.id,
-      item_id: item.id,
-      product_id: item.product_id,
-      variant_id: item.variant_id
-    });
-    await hydrateCart(response, { ifRevision: writeRevision });
-    await client.activity.track({ type: "cart_removed", payload: { product_id: item.product_id, variant_id: item.variant_id } });
-    return response;
-  }
-  async function addServiceItem(item) {
-    const writeRevision = nextCartWriteRevision();
-    const next = [...service_items.get(), item];
-    service_items.set(next);
-    return syncCart({ service_items: next }, writeRevision);
-  }
-  async function removeServiceItem(itemId) {
-    const writeRevision = nextCartWriteRevision();
-    const next = service_items.get().filter((item) => item.id !== itemId);
-    service_items.set(next);
-    return syncCart({ service_items: next }, writeRevision);
-  }
-  async function clearCart() {
-    const writeRevision = nextCartWriteRevision();
-    product_items.set([]);
-    service_items.set([]);
-    quote.set(null);
-    promo_code.set(null);
-    cart_status.setKey("selected_shipping_method_id", null);
-    const current = cart.get();
-    if (!current) return null;
-    const response = await client.cart.clear({ id: current.id });
-    await hydrateCart(response, { ifRevision: writeRevision });
-    return response;
-  }
-  async function fetchQuote(input = {}) {
-    if (checkoutItems(input).length === 0) {
-      quote.set(null);
-      return null;
-    }
-    cart_status.setKey("fetching_quote", true);
-    cart_status.setKey("quote_error", null);
-    try {
-      const current = await syncCart(input);
-      const response = await client.cart.quote({ id: current.id });
-      quote.set(response);
-      return response;
-    } catch (error) {
-      quote.set(null);
-      cart_status.setKey("quote_error", readErrorMessage(error, "Failed to fetch quote."));
-      throw error;
-    } finally {
-      cart_status.setKey("fetching_quote", false);
-    }
-  }
-  async function checkout(input = {}) {
-    if (checkoutItems(input).length === 0) throw new Error("Cart is empty");
-    cart_status.setKey("processing_checkout", true);
-    cart_status.setKey("error", null);
-    try {
-      const current = await syncCart(input);
-      await client.activity.track({ type: "checkout_started", payload: { cart_id: current.id } });
-      const response = await client.cart.checkout({
-        id: current.id,
-        payment_method_id: input.payment_method_id || void 0
-      });
-      const quoteValue = quote.get();
-      const stored = {
-        order_id: response.order_id,
-        number: response.number,
-        client_secret: response.client_secret,
-        payment: response.payment,
-        product_items: input.product_items || product_items.get(),
-        service_items: input.service_items || service_items.get(),
-        shipping_address: input.shipping_address || null,
-        billing_address: input.billing_address || null,
-        total: quoteValue?.payment?.total || quoteValue?.total || response.payment?.total,
-        currency: quoteValue?.payment?.currency || currentCurrency(),
-        payment_method_id: input.payment_method_id || null,
-        created_at: Date.now()
-      };
-      last_order.set(stored);
-      product_items.set([]);
-      service_items.set([]);
-      cart.set(null);
-      quote.set(null);
-      promo_code.set(null);
-      cart_status.setKey("selected_shipping_method_id", null);
-      await client.activity.track({ type: "purchase", payload: { order_id: response.order_id, number: response.number } });
-      return response;
-    } catch (error) {
-      cart_status.setKey("error", readErrorMessage(error, "Checkout failed."));
-      throw error;
-    } finally {
-      cart_status.setKey("processing_checkout", false);
-    }
-  }
-  function serviceCalendar() {
-    const state = service_state.get();
-    const { currentMonth, selectedDate, startDate, endDate, availability, selectedProviderId } = state;
-    const year = currentMonth.getFullYear();
-    const monthIndex = currentMonth.getMonth();
-    const first = new Date(year, monthIndex, 1);
-    const last = new Date(year, monthIndex + 1, 0);
-    const today = /* @__PURE__ */ new Date();
-    today.setHours(0, 0, 0, 0);
-    const cells = [];
-    const pad = (first.getDay() + 6) % 7;
-    for (let i = 0; i < pad; i++) {
-      cells.push({
-        date: /* @__PURE__ */ new Date(0),
-        iso: "",
-        available: false,
-        isSelected: false,
-        isInRange: false,
-        isToday: false,
-        blank: true
-      });
-    }
-    for (let day = 1; day <= last.getDate(); day++) {
-      const date = new Date(year, monthIndex, day);
-      const iso = `${year}-${String(monthIndex + 1).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
-      const isSelected = iso === selectedDate || iso === startDate || iso === endDate;
-      let isInRange = false;
-      if (startDate && endDate) {
-        const time = date.getTime();
-        isInRange = time > new Date(startDate).getTime() && time < new Date(endDate).getTime();
-      }
-      cells.push({
-        date,
-        iso,
-        available: hasAvailableSlotsForDate(availability, iso, selectedProviderId),
-        isSelected,
-        isInRange,
-        isToday: date.getTime() === today.getTime(),
-        blank: false
-      });
-    }
-    const suffix = (7 - cells.length % 7) % 7;
-    for (let i = 0; i < suffix; i++) {
-      cells.push({
-        date: /* @__PURE__ */ new Date(0),
-        iso: "",
-        available: false,
-        isSelected: false,
-        isInRange: false,
-        isToday: false,
-        blank: true
-      });
-    }
-    return cells;
-  }
-  function computeServiceSlots(dateStr) {
-    const state = service_state.get();
-    const { availability, selectedProviderId, timezone, service } = state;
-    return getSlotsForDate(availability, dateStr, selectedProviderId).map((slot, index) => ({
-      id: `${service?.id || "service"}-${slot.from}-${index}`,
-      serviceId: service?.id || "",
-      providerId: slot.providerId,
-      from: slot.from,
-      to: slot.to,
-      timeText: formatServiceSlotTime(slot.from, slot.to, timezone),
-      dateText: new Date(slot.from * 1e3).toLocaleDateString([], {
-        weekday: "short",
-        month: "short",
-        day: "numeric",
-        timeZone: timezone
-      })
-    }));
-  }
-  function toServiceCartItem(slot) {
-    return {
-      id: slot.id,
-      service_id: slot.serviceId,
-      provider_id: slot.providerId,
-      from: slot.from,
-      to: slot.to,
-      forms: [],
-      service_name: slot.serviceName,
-      date_text: slot.dateText,
-      time_text: slot.timeText,
-      is_multi_day: slot.isMultiDay
-    };
-  }
-  function fromServiceCartItem(item) {
-    return {
-      id: item.id,
-      serviceId: item.service_id,
-      providerId: item.provider_id,
-      from: item.from,
-      to: item.to,
-      serviceName: item.service_name || "",
-      date: item.date_text || "",
-      dateText: item.date_text || "",
-      timeText: item.time_text || formatServiceSlotTime(item.from, item.to, service_state.get().timezone),
-      isMultiDay: item.is_multi_day
-    };
-  }
-  function setServiceCartFromServiceItems(items) {
-    const next = items.map(fromServiceCartItem);
-    const current = service_state.get().cart;
-    if (JSON.stringify(current) !== JSON.stringify(next)) {
-      service_state.setKey("cart", next);
-    }
-  }
-  async function syncServiceCart(slots) {
-    try {
-      return await syncCart({
-        product_items: product_items.get(),
-        service_items: slots.map(toServiceCartItem)
-      });
-    } catch (error) {
-      service_state.setKey("quoteError", readErrorMessage(error, "Failed to sync service cart."));
-      throw error;
-    }
-  }
-  function serviceCurrentStepName() {
-    const state = service_state.get();
-    if (!state.service) return "";
-    if (!state.selectedSlot || !state.dateTimeConfirmed) return "datetime";
-    return "review";
-  }
-  const service_current_step_name = computed(service_state, serviceCurrentStepName);
-  const service_can_proceed = computed(service_state, (state) => {
-    const step = serviceCurrentStepName();
-    if (step === "datetime") {
-      return state.isMultiDay ? !!(state.startDate && state.endDate && state.selectedSlot) : !!(state.selectedDate && state.selectedSlot);
-    }
-    if (step === "review") return true;
-    return false;
-  });
-  const service_month_year = computed(
-    service_state,
-    (state) => state.currentMonth.toLocaleString(void 0, { month: "long", year: "numeric" })
-  );
-  const service_chain_start = computed(service_state, (state) => {
-    if (!state.cart.length) return null;
-    return Math.max(...state.cart.map((slot) => slot.to));
-  });
-  const service_total_steps = computed(service_state, (state) => state.service ? 2 : 0);
-  const service_steps = computed(service_state, () => ({
-    1: { name: "datetime" },
-    2: { name: "review" }
-  }));
-  const service_current_step = computed([service_current_step_name, service_steps], (name, steps) => {
-    for (const [idx, step] of Object.entries(steps)) {
-      if (step.name === name) return Number(idx);
-    }
-    return 1;
-  });
-  function formatServiceDateDisplay(value) {
-    if (!value) return "";
-    return new Date(value).toLocaleDateString(void 0, { month: "short", day: "numeric" });
-  }
-  function serviceProviderId(provider) {
-    return "provider_id" in provider ? provider.provider_id : provider.id;
-  }
-  function getFirstServiceProviderEntry(state) {
-    const serviceWithProviders = state.service;
-    const providers = serviceWithProviders?.providers;
-    if (!providers?.length) return null;
-    if (state.selectedProviderId) {
-      const match = providers.find((provider) => provider.provider_id === state.selectedProviderId);
-      if (match) return match;
-    }
-    return providers[0];
-  }
-  async function loadServiceForm() {
-    try {
-      const form = await loadForm({ key: "order-form" });
-      const blocks = (form.schema || []).map(formSchemaToBlock);
-      service_form_node.set({ blocks });
-      return blocks;
-    } catch {
-      service_form_node.set({ blocks: [] });
-      return [];
-    }
-  }
-  const service_controller = {
-    async initialize() {
-      service_state.setKey("tzGroups", normalizeTimezoneGroups(client.utils.tzGroups));
-      await ensureCart();
-      setServiceCartFromServiceItems(service_items.get());
-      const methods = session.get()?.market?.payment_methods || [];
-      if (methods.length) service_state.setKey("availablePaymentMethods", methods);
-      await loadServiceForm();
-    },
-    setTimezone(tz) {
-      service_state.setKey("timezone", tz);
-      service_state.setKey("calendar", serviceCalendar());
-      const state = service_state.get();
-      if (state.selectedDate) {
-        service_state.setKey("slots", computeServiceSlots(state.selectedDate));
-        service_state.setKey("selectedSlot", null);
-      }
-    },
-    async select(service) {
-      service_state.setKey("loading", true);
-      try {
-        const isMultiDayBlock = service.blocks?.find((block) => block.key === "isMultiDay");
-        const blockValue = isMultiDayBlock?.value;
-        const isMultiDay = Array.isArray(blockValue) ? blockValue[0] === true : blockValue === true;
-        const [fullService, serviceProviders] = await Promise.all([
-          client.eshop.service.get({ id: service.id }),
-          client.eshop.service.findProviders({ service_id: service.id })
-        ]);
-        const providerIds = [...new Set(serviceProviders.map(serviceProviderId))];
-        const providerResults = await Promise.all(
-          providerIds.map((id) => client.eshop.provider.get({ id }).catch(() => null))
-        );
-        service_state.set({
-          ...service_state.get(),
-          service: fullService,
-          providers: providerResults.filter((provider) => provider !== null),
-          selectedProviderId: null,
-          availability: null,
-          selectedDate: null,
-          startDate: null,
-          endDate: null,
-          slots: [],
-          selectedSlot: null,
-          currentMonth: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), 1),
-          loading: false,
-          isMultiDay
-        });
-        await service_controller.loadMonth();
-      } catch (error) {
-        service_state.setKey("loading", false);
-        throw error;
-      }
-    },
-    async loadMonth() {
-      const state = service_state.get();
-      if (!state.service) return;
-      service_state.setKey("loading", true);
-      try {
-        const chainedStart = service_chain_start.get();
-        let from;
-        let to;
-        if (chainedStart) {
-          from = chainedStart;
-          to = chainedStart;
-        } else {
-          const month = state.currentMonth;
-          from = Math.floor(Date.UTC(month.getFullYear(), month.getMonth(), 1) / 1e3);
-          to = Math.floor(Date.UTC(month.getFullYear(), month.getMonth() + 1, 1) / 1e3);
-        }
-        const availability = await loadAvailability({
-          service_id: state.service.id,
-          from,
-          to
-        });
-        service_state.setKey("availability", availability);
-        service_state.setKey("calendar", serviceCalendar());
-      } finally {
-        service_state.setKey("loading", false);
-      }
-    },
-    prevMonth() {
-      const { currentMonth } = service_state.get();
-      service_state.setKey("currentMonth", new Date(currentMonth.getFullYear(), currentMonth.getMonth() - 1, 1));
-      void service_controller.loadMonth();
-    },
-    nextMonth() {
-      const { currentMonth } = service_state.get();
-      service_state.setKey("currentMonth", new Date(currentMonth.getFullYear(), currentMonth.getMonth() + 1, 1));
-      void service_controller.loadMonth();
-    },
-    selectProvider(providerId) {
-      service_state.set({
-        ...service_state.get(),
-        selectedProviderId: providerId,
-        selectedDate: null,
-        startDate: null,
-        endDate: null,
-        slots: [],
-        selectedSlot: null
-      });
-      void service_controller.loadMonth();
-    },
-    selectDate(cell) {
-      if (cell.blank || !cell.available) return;
-      service_state.setKey("dateTimeConfirmed", false);
-      const state = service_state.get();
-      if (state.isMultiDay) {
-        if (!state.startDate) {
-          service_state.setKey("startDate", cell.iso);
-          service_state.setKey("selectedDate", cell.iso);
-          service_state.setKey("endDate", null);
-          service_state.setKey("selectedSlot", null);
-        } else if (!state.endDate) {
-          if (cell.date.getTime() < new Date(state.startDate).getTime()) {
-            service_state.setKey("startDate", cell.iso);
-            service_state.setKey("endDate", state.startDate);
-          } else {
-            service_state.setKey("endDate", cell.iso);
-          }
-          service_controller.createMultiDaySlots();
-        } else {
-          service_state.setKey("startDate", cell.iso);
-          service_state.setKey("selectedDate", cell.iso);
-          service_state.setKey("endDate", null);
-          service_state.setKey("selectedSlot", null);
-        }
-        service_controller.updateCalendar();
-      } else {
-        service_state.set({
-          ...state,
-          selectedDate: cell.iso,
-          slots: computeServiceSlots(cell.iso),
-          selectedSlot: null
-        });
-        service_state.setKey("calendar", serviceCalendar());
-      }
-    },
-    createMultiDaySlots() {
-      const state = service_state.get();
-      if (!state.startDate || !state.endDate || !state.availability) return;
-      const slots = [];
-      for (let day = new Date(state.startDate); day <= new Date(state.endDate); day.setDate(day.getDate() + 1)) {
-        const iso = day.toISOString().slice(0, 10);
-        for (const slot of getSlotsForDate(state.availability, iso, state.selectedProviderId)) {
-          slots.push({
-            id: `${state.service?.id || "service"}-${slot.from}-${slots.length}`,
-            serviceId: state.service?.id || "",
-            providerId: slot.providerId,
-            from: slot.from,
-            to: slot.to,
-            timeText: formatServiceSlotTime(slot.from, slot.to, state.timezone),
-            dateText: new Date(slot.from * 1e3).toLocaleDateString([], {
-              weekday: "short",
-              month: "short",
-              day: "numeric",
-              timeZone: state.timezone
-            }),
-            isMultiDay: true
-          });
-        }
-      }
-      service_state.setKey("slots", slots);
-      service_state.setKey("selectedSlot", slots.length === 1 ? slots[0] : null);
-    },
-    selectTimeSlot(slot) {
-      service_state.setKey("dateTimeConfirmed", false);
-      service_state.setKey("selectedSlot", slot);
-    },
-    resetDateSelection() {
-      service_state.setKey("selectedDate", null);
-      service_state.setKey("startDate", null);
-      service_state.setKey("endDate", null);
-      service_state.setKey("slots", []);
-      service_state.setKey("selectedSlot", null);
-      service_state.setKey("dateTimeConfirmed", false);
-    },
-    updateCalendar() {
-      service_state.setKey("calendar", serviceCalendar());
-    },
-    findFirstAvailable() {
-      for (const day of service_state.get().calendar) {
-        if (!day.blank && day.available) {
-          service_controller.selectDate(day);
-          return;
-        }
-      }
-    },
-    async addToCart() {
-      const state = service_state.get();
-      const serviceBlocks = state.service?.forms || [];
-      const enrich = (slot) => ({
-        ...slot,
-        serviceName: state.service ? serviceName(state.service, currentLocale()) : "",
-        date: slot.dateText,
-        serviceBlocks
-      });
-      const selected = state.isMultiDay && state.slots.length > 0 ? state.slots.map(enrich) : state.selectedSlot ? [enrich(state.selectedSlot)] : [];
-      if (!selected.length) return;
-      const nextCart = [...state.cart, ...selected];
-      service_state.set({
-        ...state,
-        cart: nextCart,
-        selectedDate: null,
-        startDate: null,
-        endDate: null,
-        slots: [],
-        selectedSlot: null
-      });
-      await syncServiceCart(nextCart);
-      service_state.setKey("calendar", serviceCalendar());
-    },
-    async removeFromCart(slotId) {
-      const nextCart = service_state.get().cart.filter((slot) => slot.id !== slotId);
-      service_state.setKey("cart", nextCart);
-      await syncServiceCart(nextCart);
-    },
-    async clearCart() {
-      service_state.setKey("cart", []);
-      await syncServiceCart([]);
-    },
-    async checkout(paymentMethodId, forms = []) {
-      const state = service_state.get();
-      if (!state.cart.length) return { success: false, error: "Cart is empty" };
-      service_state.setKey("loading", true);
-      try {
-        const result = await checkout({
-          service_items: state.cart.map((slot) => ({
-            ...toServiceCartItem(slot),
-            forms: []
-          })),
-          payment_method_id: paymentMethodId,
-          promo_code: state.promoCode || void 0,
-          forms
-        });
-        service_state.setKey("cartId", cart.get()?.id || null);
-        return { success: true, data: result };
-      } catch (error) {
-        return { success: false, error: readErrorMessage(error, "Checkout failed.") };
-      } finally {
-        service_state.setKey("loading", false);
-      }
-    },
-    async fetchQuote(paymentMethodId, promoCode) {
-      const state = service_state.get();
-      if (!state.cart.length) return null;
-      service_state.setKey("fetchingQuote", true);
-      service_state.setKey("quoteError", null);
-      try {
-        service_state.setKey("promoCode", promoCode || null);
-        const response = await fetchQuote({
-          service_items: state.cart.map(toServiceCartItem),
-          payment_method_id: paymentMethodId,
-          promo_code: promoCode || void 0
-        });
-        service_state.setKey("cartId", cart.get()?.id || null);
-        service_state.setKey("quote", response);
-        const methods = response?.payment_methods || session.get()?.market?.payment_methods || [];
-        if (methods.length) service_state.setKey("availablePaymentMethods", methods);
-        return response;
-      } catch (error) {
-        service_state.setKey("quoteError", readErrorMessage(error, "Failed to fetch quote."));
-        return null;
-      } finally {
-        service_state.setKey("fetchingQuote", false);
-      }
-    },
-    getProvidersList() {
-      return service_state.get().providers;
-    },
-    prevStep() {
-      const current = serviceCurrentStepName();
-      if (current === "review") {
-        service_state.setKey("dateTimeConfirmed", false);
-        return;
-      }
-      if (current === "datetime") {
-        service_state.setKey("selectedSlot", null);
-        service_state.setKey("dateTimeConfirmed", false);
-      }
-    },
-    nextStep() {
-      if (serviceCurrentStepName() === "datetime" && service_can_proceed.get()) {
-        service_state.setKey("dateTimeConfirmed", true);
-      }
-    },
-    getServicePrice() {
-      const state = service_state.get();
-      if (state.quote?.total !== void 0) return String(state.quote.total);
-      const provider = getFirstServiceProviderEntry(state);
-      if (!provider?.prices) return "";
-      return client.utils.formatPrice(provider.prices) || "0";
-    },
-    formatDateDisplay: formatServiceDateDisplay,
-    serviceItemsFromSlots(slots) {
-      return slots.map(toServiceCartItem);
-    }
-  };
-  service_items.subscribe((items) => setServiceCartFromServiceItems(items));
-  async function loadNode(params, options) {
-    cms_state.setKey("loading", true);
-    cms_state.setKey("error", null);
-    try {
-      const { locale: nextLocale, market: nextMarket, ...nodeParams } = params;
-      setContext({ locale: nextLocale, market: nextMarket });
-      const node = await client.cms.node.get(nodeParams, options);
-      const key = nodeParams.key || nodeParams.id || nodeParams.slug || node.id;
-      cms_state.setKey("nodes", { ...cms_state.get().nodes, [key]: node });
-      return node;
-    } catch (error) {
-      cms_state.setKey("error", readErrorMessage(error, "Failed to load CMS node."));
-      throw error;
-    } finally {
-      cms_state.setKey("loading", false);
-    }
-  }
-  async function loadForm(params, options) {
-    cms_state.setKey("loading", true);
-    cms_state.setKey("error", null);
-    try {
-      const form = await client.cms.form.get(params, options);
-      const key = params.key || params.id || form.key || form.id;
-      cms_state.setKey("forms", { ...cms_state.get().forms, [key]: form });
-      return form;
-    } catch (error) {
-      cms_state.setKey("error", readErrorMessage(error, "Failed to load CMS form."));
-      throw error;
-    } finally {
-      cms_state.setKey("loading", false);
-    }
-  }
-  async function submitFormByKey(key, fieldsOrBlocks, options) {
-    const forms = cms_state.get().forms;
-    const form = forms[key] || await loadForm({ key });
-    const fields = fieldsOrBlocks.length > 0 && "properties" in fieldsOrBlocks[0] ? formFieldsFromBlocks(fieldsOrBlocks) : fieldsOrBlocks;
-    const payload = { form_id: form.id, fields };
-    return client.cms.form.submit(payload, options);
-  }
-  async function loadProducts(params = {}, options) {
-    eshop_state.setKey("loading_products", true);
-    eshop_state.setKey("error", null);
-    try {
-      const response = await client.eshop.product.find(params, options);
-      eshop_state.setKey("products", response.items || []);
-      eshop_state.setKey("product_cursor", response.cursor || null);
-      return response;
-    } catch (error) {
-      eshop_state.setKey("error", readErrorMessage(error, "Failed to load products."));
-      throw error;
-    } finally {
-      eshop_state.setKey("loading_products", false);
-    }
-  }
-  async function loadServices(params = {}, options) {
-    eshop_state.setKey("loading_services", true);
-    eshop_state.setKey("error", null);
-    try {
-      const response = await client.eshop.service.find(params, options);
-      eshop_state.setKey("services", response.items || []);
-      eshop_state.setKey("service_cursor", response.cursor || null);
-      return response;
-    } catch (error) {
-      eshop_state.setKey("error", readErrorMessage(error, "Failed to load services."));
-      throw error;
-    } finally {
-      eshop_state.setKey("loading_services", false);
-    }
-  }
-  async function loadProviders(params = {}, options) {
-    eshop_state.setKey("loading_providers", true);
-    eshop_state.setKey("error", null);
-    try {
-      const response = await client.eshop.provider.find(params, options);
-      eshop_state.setKey("providers", response.items || []);
-      eshop_state.setKey("provider_cursor", response.cursor || null);
-      return response;
-    } catch (error) {
-      eshop_state.setKey("error", readErrorMessage(error, "Failed to load providers."));
-      throw error;
-    } finally {
-      eshop_state.setKey("loading_providers", false);
-    }
-  }
-  async function loadAvailability(params, options) {
-    eshop_state.setKey("loading_availability", true);
-    eshop_state.setKey("error", null);
-    try {
-      const response = await client.eshop.service.getAvailability(params, options);
-      eshop_state.setKey("availability", response);
-      return response;
-    } catch (error) {
-      eshop_state.setKey("error", readErrorMessage(error, "Failed to load availability."));
-      throw error;
-    } finally {
-      eshop_state.setKey("loading_availability", false);
-    }
-  }
-  async function setup(options = {}) {
-    setContext(options);
-    const shouldIdentify = options.identify === true || !!options.hydrateCart || !!options.track;
-    const results = {
-      session: session.get()
-    };
-    if (shouldIdentify) results.session = await ensureSession();
-    if (options.hydrateCart) results.cart = await ensureCart();
-    if (options.track) await client.activity.track(options.track);
-    return results;
-  }
-  async function initialize(options = {}) {
-    return setup(options);
-  }
-  const cart_store = {
-    cart,
-    product_items,
-    service_items,
-    quote_result: quote,
-    promo_code,
-    last_order,
-    status: cart_status,
-    product_item_count,
-    service_item_count,
-    item_count,
-    snapshot,
-    ensure: ensureCart,
-    hydrate: hydrateCart,
-    sync: syncCart,
-    addProduct,
-    setProductQuantity,
-    removeProduct,
-    addServiceItem,
-    removeServiceItem,
-    clear: clearCart,
-    quote: fetchQuote,
-    checkout,
-    applyPromoCode(code, input = {}) {
-      promo_code.set(code);
-      return fetchQuote({ ...input, promo_code: code });
-    },
-    removePromoCode(input = {}) {
-      promo_code.set(null);
-      return fetchQuote({ ...input, promo_code: null });
-    },
-    selectShippingMethod(id) {
-      cart_status.setKey("selected_shipping_method_id", id);
-    },
-    locationToAddress,
-    buildItems: checkoutItems,
-    buildProductItems: toProductCheckoutItems,
-    buildServiceItems: toServiceCheckoutItems
-  };
-  const product_store = {
-    get: (params, options) => client.eshop.product.get(params, options),
-    find: loadProducts,
-    list: loadProducts,
-    loadListing: loadProducts,
-    loadDetail: (params, options) => client.eshop.product.get(params, options)
-  };
-  const service_store = {
-    get: (params, options) => client.eshop.service.get(params, options),
-    find: loadServices,
-    list: loadServices,
-    loadListing: loadServices,
-    loadDetail: (params, options) => client.eshop.service.get(params, options),
-    listProviders: (params, options) => client.eshop.service.findProviders(params, options),
-    findProviders: (params, options) => client.eshop.service.findProviders(params, options),
-    getAvailability: loadAvailability,
-    state: service_state,
-    form_blocks: service_form_blocks,
-    current_step_name: service_current_step_name,
-    can_proceed: service_can_proceed,
-    month_year: service_month_year,
-    chain_start: service_chain_start,
-    total_steps: service_total_steps,
-    steps: service_steps,
-    current_step: service_current_step,
-    initialize: service_controller.initialize,
-    select: service_controller.select,
-    setTimezone: service_controller.setTimezone,
-    loadMonth: service_controller.loadMonth,
-    prevMonth: service_controller.prevMonth,
-    nextMonth: service_controller.nextMonth,
-    selectProvider: service_controller.selectProvider,
-    selectDate: service_controller.selectDate,
-    createMultiDaySlots: service_controller.createMultiDaySlots,
-    selectTimeSlot: service_controller.selectTimeSlot,
-    resetDateSelection: service_controller.resetDateSelection,
-    updateCalendar: service_controller.updateCalendar,
-    findFirstAvailable: service_controller.findFirstAvailable,
-    addToCart: service_controller.addToCart,
-    removeFromCart: service_controller.removeFromCart,
-    clearCart: service_controller.clearCart,
-    getProvidersList: service_controller.getProvidersList,
-    prevStep: service_controller.prevStep,
-    nextStep: service_controller.nextStep,
-    getServicePrice: service_controller.getServicePrice,
-    formatDateDisplay: service_controller.formatDateDisplay,
-    serviceItemsFromSlots: service_controller.serviceItemsFromSlots
-  };
-  return {
-    client,
-    session,
-    market,
-    market_key,
-    locale,
-    currency,
-    allowed_payment_methods,
-    payment_config,
-    setup,
-    initialize,
-    identify,
-    verify: client.verify,
-    me: client.me,
-    logout: client.logout,
-    onAuthStateChanged: client.onAuthStateChanged,
-    get currentSession() {
-      return session.get();
-    },
-    get isAuthenticated() {
-      return client.isAuthenticated;
-    },
-    setMarket,
-    setLocale,
-    setContext,
-    getStoreId: client.getStoreId,
-    getMarket: currentMarketKey,
-    getLocale: currentLocale,
-    cms: {
-      state: cms_state,
-      node: {
-        get: loadNode,
-        find: (params, options) => client.cms.node.find(params, options),
-        getChildren: (params, options) => client.cms.node.getChildren(params, options)
-      },
-      form: {
-        get: loadForm,
-        submit: (params, options) => client.cms.form.submit(params, options),
-        submitByKey: submitFormByKey
-      },
-      taxonomy: client.cms.taxonomy
-    },
-    eshop: {
-      state: eshop_state,
-      product: product_store,
-      service: service_store,
-      provider: {
-        get: (params, options) => client.eshop.provider.get(params, options),
-        find: loadProviders
-      },
-      order: client.eshop.order,
-      cart: cart_store
-    },
-    crm: client.crm,
-    activity: {
-      track(params) {
-        return client.activity.track(params);
-      },
-      pageView(payload = {}) {
-        return client.activity.track({ type: "page_view", payload });
-      },
-      state: atom(null)
-    },
-    support: client.support,
-    store: client.store,
-    utils: client.utils
-  };
-}
-
-export { createArkyStore };
-//# sourceMappingURL=storefront-store.js.map
-//# sourceMappingURL=storefront-store.js.map