arky-sdk 0.9.13 → 0.9.17

package/dist/storefront.cjs

@@ -3,21 +3,25 @@
 var nanostores = require('nanostores');
 
 // src/utils/orderItems.ts
-function normalizeOrderCheckoutItems(items) {
+function sanitizePublicCheckoutItems(items) {
   return items.map((item) => {
-    if ("type" in item) {
-      return item;
-    }
-    if ("product_id" in item) {
-      return { type: "product", ...item };
+    if (item.type === "product") {
+      return {
+        type: "product",
+        ...item.id ? { id: item.id } : {},
+        product_id: item.product_id,
+        variant_id: item.variant_id,
+        quantity: item.quantity
+      };
     }
-    return { type: "service", ...item };
-  });
-}
-function normalizePublicCheckoutItems(items) {
-  return normalizeOrderCheckoutItems(items).map((item) => {
-    const { price: _price, ...publicItem } = item;
-    return publicItem;
+    return {
+      type: "service",
+      ...item.id ? { id: item.id } : {},
+      service_id: item.service_id,
+      provider_id: item.provider_id,
+      slots: item.slots,
+      ...item.forms ? { forms: item.forms } : {}
+    };
   });
 }
 
@@ -42,10 +46,9 @@ var createActionApi = (apiConfig) => ({
   COMMON_ACTION_KEYS,
   async track(params) {
     try {
-      const key = "key" in params && params.key ? params.key : params.type;
       await apiConfig.httpClient.post(
         `/v1/storefront/${apiConfig.storeId}/actions/track`,
-        { key, payload: params.payload }
+        { key: params.key, payload: params.payload }
       );
     } catch {
     }
@@ -53,6 +56,47 @@ var createActionApi = (apiConfig) => ({
 });
 var createStorefrontApi = (apiConfig, updateContactSession) => {
   const base = (storeId = apiConfig.storeId) => `/v1/storefront/${storeId}`;
+  const pendingVerifications = /* @__PURE__ */ new Map();
+  function persistIdentification(result) {
+    const issued = result.token;
+    if (issued?.token) {
+      updateContactSession(() => ({
+        access_token: issued.token,
+        contact: result.contact,
+        store: result.store,
+        market: result.market
+      }));
+    } else {
+      if (result.verification_challenge) {
+        pendingVerifications.set(result.verification_challenge.challenge_id, {
+          store: result.store,
+          market: result.market
+        });
+      }
+      updateContactSession(
+        (current) => current ? {
+          ...current,
+          contact: result.contact,
+          store: result.store,
+          market: result.market
+        } : null
+      );
+    }
+    return result;
+  }
+  async function submitIdentification(path, params, options) {
+    const store_id = apiConfig.storeId;
+    const result = await apiConfig.httpClient.post(
+      `${base(store_id)}/account/${path}`,
+      {
+        store_id,
+        market: params?.market || apiConfig.market || null,
+        email: params?.email
+      },
+      options
+    );
+    return persistIdentification(result);
+  }
   return {
     store: {
       getStore(options) {
@@ -60,7 +104,10 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
       },
       location: {
         getCountries(options) {
-          return apiConfig.httpClient.get(`/v1/platform/countries`, options);
+          return apiConfig.httpClient.get(
+            `/v1/platform/countries`,
+            options
+          );
         },
         getCountry(countryCode, options) {
           return apiConfig.httpClient.get(
@@ -69,18 +116,30 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
           );
         },
         list(options) {
-          return apiConfig.httpClient.get(`${base()}/locations`, options);
+          return apiConfig.httpClient.get(
+            `${base()}/locations`,
+            options
+          );
         },
         get(id, options) {
-          return apiConfig.httpClient.get(`${base()}/locations/${id}`, options);
+          return apiConfig.httpClient.get(
+            `${base()}/locations/${id}`,
+            options
+          );
         }
       },
       market: {
         list(options) {
-          return apiConfig.httpClient.get(`${base()}/markets`, options);
+          return apiConfig.httpClient.get(
+            `${base()}/markets`,
+            options
+          );
         },
         get(id, options) {
-          return apiConfig.httpClient.get(`${base()}/markets/${id}`, options);
+          return apiConfig.httpClient.get(
+            `${base()}/markets/${id}`,
+            options
+          );
         }
       }
     },
@@ -88,11 +147,9 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
       collection: {
         get(params, options) {
           const store_id = params.store_id || apiConfig.storeId;
-          if (!params.id) {
-            throw new Error("GetCollectionParams requires id");
-          }
+          const identifier = params.id !== void 0 ? params.id : `${store_id}:${params.key}`;
           return apiConfig.httpClient.get(
-            `${base(store_id)}/collections/${params.id}`,
+            `${base(store_id)}/collections/${identifier}`,
             options
           );
         }
@@ -110,10 +167,13 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
         },
         find(params, options) {
           const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/entries`, {
-            ...options,
-            params: queryParams
-          });
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/entries`,
+            {
+              ...options,
+              params: queryParams
+            }
+          );
         }
       },
       form: {
@@ -189,10 +249,13 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
         },
         find(params, options) {
           const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/products`, {
-            ...options,
-            params: queryParams
-          });
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/products`,
+            {
+              ...options,
+              params: queryParams
+            }
+          );
         }
       },
       cart: {
@@ -201,16 +264,23 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
           const { store_id: _store_id, ...payload } = params;
           return apiConfig.httpClient.post(
             `${base(store_id)}/carts/current`,
-            { ...payload, store_id, market: payload.market || apiConfig.market },
+            {
+              ...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
-          });
+          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;
@@ -220,7 +290,7 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
             {
               ...payload,
               store_id: target,
-              ...items ? { items: normalizePublicCheckoutItems(items) } : {}
+              ...items ? { items: sanitizePublicCheckoutItems(items) } : {}
             },
             options
           );
@@ -233,7 +303,7 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
             {
               ...payload,
               store_id: target,
-              item: normalizePublicCheckoutItems([item])[0]
+              item: sanitizePublicCheckoutItems([item])[0]
             },
             options
           );
@@ -288,18 +358,35 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
         },
         find(params, options) {
           const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/orders`, {
-            ...options,
-            params: queryParams
-          });
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/orders`,
+            {
+              ...options,
+              params: queryParams
+            }
+          );
         },
         downloadDigitalAccess(params, options) {
           const store_id = params.store_id || apiConfig.storeId;
           return apiConfig.httpClient.post(
-            `${base(store_id)}/orders/${params.id}/digital-access/${params.grant_id}/download`,
+            `${base(store_id)}/orders/${params.order_id}/digital-access/${params.grant_id}/download`,
             {},
             options
           );
+        },
+        findDigitalAccess(params, options) {
+          const { order_id, store_id, ...queryParams } = params;
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/orders/${order_id}/digital-access`,
+            { ...options, params: queryParams }
+          );
+        },
+        getDigitalAccess(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/orders/${params.order_id}/digital-access/${params.grant_id}`,
+            options
+          );
         }
       },
       service: {
@@ -320,17 +407,23 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
         },
         find(params, options) {
           const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/services`, {
-            ...options,
-            params: queryParams
-          });
+          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
-          });
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/service-providers`,
+            {
+              ...options,
+              params: queryParams
+            }
+          );
         },
         getAvailability(params, options) {
           const { store_id, ...queryParams } = params;
@@ -359,48 +452,47 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
         },
         find(params, options) {
           const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/providers`, {
-            ...options,
-            params: queryParams
-          });
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/providers`,
+            {
+              ...options,
+              params: queryParams
+            }
+          );
         }
       }
     },
     crm: {
       contact: {
-        async identify(params, options) {
-          const store_id = apiConfig.storeId;
-          const result = await apiConfig.httpClient.post(
-            `${base(store_id)}/account/identify`,
-            {
-              store_id,
-              market: params?.market || apiConfig.market || null,
-              email: params?.email,
-              verify: params?.verify ?? false
-            },
-            options
-          );
-          if (result?.token?.token) {
-            updateContactSession(() => ({
-              access_token: result.token.token,
-              contact: result.contact,
-              store: result.store,
-              market: result.market
-            }));
-          }
-          return result;
+        identify(params, options) {
+          return submitIdentification("identify", params, options);
+        },
+        requestCode(params, options) {
+          return submitIdentification("code", params, options);
         },
         async verify(params, options) {
           const store_id = apiConfig.storeId;
           const result = await apiConfig.httpClient.post(
             `${base(store_id)}/account/verify`,
-            { store_id, code: params.code },
+            { store_id, challenge_id: params.challenge_id, code: params.code },
             options
           );
-          if (result?.token) {
+          if (result?.token?.token) {
+            const pending = pendingVerifications.get(params.challenge_id);
+            const identifiedStore = pending?.store || await apiConfig.httpClient.get(base(store_id), options);
             updateContactSession(
-              (prev) => prev ? { ...prev, access_token: result.token } : null
+              (prev) => prev ? {
+                ...prev,
+                access_token: result.token.token,
+                contact: result.contact
+              } : {
+                access_token: result.token.token,
+                contact: result.contact,
+                store: identifiedStore,
+                market: pending?.market || null
+              }
             );
+            pendingVerifications.delete(params.challenge_id);
           }
           return result;
         },
@@ -417,7 +509,10 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
           }
         },
         getMe(options) {
-          return apiConfig.httpClient.get(`${base()}/account/me`, options);
+          return apiConfig.httpClient.get(
+            `${base()}/account/me`,
+            options
+          );
         }
       },
       contactList: {
@@ -430,10 +525,31 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
         },
         find(params, options) {
           const { store_id, ...queryParams } = params || {};
-          return apiConfig.httpClient.get(`${base(store_id)}/contact-lists`, {
-            ...options,
-            params: queryParams
-          });
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/contact-lists`,
+            {
+              ...options,
+              params: queryParams
+            }
+          );
+        },
+        plans: {
+          find(params, options) {
+            const { store_id, contact_list_id, ...queryParams } = params;
+            return apiConfig.httpClient.get(
+              `${base(store_id)}/contact-lists/${contact_list_id}/plans`,
+              { ...options, params: queryParams }
+            );
+          }
+        },
+        memberships: {
+          find(params, options) {
+            const { store_id, ...queryParams } = params || {};
+            return apiConfig.httpClient.get(`${base(store_id)}/contact-lists/memberships`, {
+              ...options,
+              params: queryParams
+            });
+          }
         },
         subscribe(params, options) {
           const { store_id, id, ...payload } = params;
@@ -458,13 +574,31 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
             options
           );
         },
-        unsubscribe(token, options) {
+        manage(token, options) {
           return apiConfig.httpClient.post(
-            `${base()}/contact-lists/unsubscribe`,
+            `${base()}/contact-lists/manage`,
             { token },
             options
           );
         },
+        unsubscribe(token, options) {
+          const headers = { ...options?.headers };
+          for (const name of Object.keys(headers)) {
+            if (name.toLowerCase() === "content-type") delete headers[name];
+          }
+          return apiConfig.httpClient.post(
+            `${base()}/contact-lists/unsubscribe`,
+            new URLSearchParams({ "List-Unsubscribe": "One-Click" }),
+            {
+              ...options,
+              params: { ...options?.params || {}, token },
+              headers: {
+                ...headers,
+                "Content-Type": "application/x-www-form-urlencoded"
+              }
+            }
+          );
+        },
         confirm(token, options) {
           return apiConfig.httpClient.post(
             `${base()}/contact-lists/confirm`,
@@ -629,27 +763,47 @@ var convertServerErrorToRequestError = (serverError, renameRules) => {
 
 // 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)}`);
+  const queryParts = Object.entries(params).flatMap(
+    ([key, value]) => {
+      if (value === null || value === void 0) return [];
+      if (typeof value === "string") {
+        return [`${key}=${encodeURIComponent(value)}`];
+      }
+      if (typeof value === "number" || typeof value === "boolean") {
+        return [`${key}=${value}`];
+      }
+      if (Array.isArray(value) || typeof value === "object") {
+        return [`${key}=${encodeURIComponent(JSON.stringify(value))}`];
+      }
+      return [];
     }
-  });
+  );
   return queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
 }
 
 // src/services/createHttpClient.ts
+function requestError(name, message, details = {}) {
+  return Object.assign(new Error(message), { name }, details);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isTokenSet(value) {
+  return isRecord(value) && typeof value.access_token === "string" && (value.refresh_token === void 0 || typeof value.refresh_token === "string") && (value.access_expires_at === void 0 || typeof value.access_expires_at === "number");
+}
+function isValidationError(value) {
+  return isRecord(value) && typeof value.field === "string" && typeof value.error === "string";
+}
+function toServerError(value, statusCode) {
+  const payload = isRecord(value) ? value : {};
+  const validationErrors = Array.isArray(payload.validationErrors) ? payload.validationErrors.filter(isValidationError) : [];
+  return {
+    message: typeof payload.message === "string" ? payload.message : "Request failed",
+    error: typeof payload.error === "string" ? payload.error : "REQUEST_FAILED",
+    statusCode: typeof payload.statusCode === "number" ? payload.statusCode : statusCode,
+    validationErrors
+  };
+}
 function createHttpClient(cfg) {
   const { authStorage } = cfg;
   let refreshPromise = null;
@@ -666,32 +820,41 @@ function createHttpClient(cfg) {
       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;
+        throw requestError("ApiError", "No refresh token available", {
+          statusCode: 401
+        });
       }
       const refRes = await fetch(getRefreshEndpoint(), {
         method: "POST",
-        headers: { Accept: "application/json", "Content-Type": "application/json" },
+        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;
+        throw requestError("ApiError", "Token refresh failed", {
+          statusCode: 401
+        });
       }
       const data = await refRes.json();
+      if (!isTokenSet(data)) {
+        authStorage.onForcedLogout();
+        throw requestError(
+          "ParseError",
+          "Token refresh returned an invalid response",
+          { statusCode: refRes.status }
+        );
+      }
       authStorage.onTokensRefreshed(data);
     })().finally(() => {
       refreshPromise = null;
     });
     return refreshPromise;
   }
-  async function request(method, path, body, options) {
-    if (options?.transformRequest) {
+  async function request(method, path, body, options, retried = false) {
+    if (!retried && options?.transformRequest) {
       body = options.transformRequest(body);
     }
     const headers = {
@@ -709,23 +872,27 @@ function createHttpClient(cfg) {
       headers["Authorization"] = `Bearer ${tokens.access_token}`;
     }
     const finalPath = options?.params ? path + buildQueryString(options.params) : path;
-    const fetchOpts = { method, headers, signal: options?.signal };
+    const fetchOptions = {
+      method,
+      headers,
+      signal: options?.signal
+    };
     if (!["GET", "DELETE"].includes(method) && body !== void 0) {
-      fetchOpts.body = JSON.stringify(body);
+      fetchOptions.body = body instanceof URLSearchParams ? body.toString() : JSON.stringify(body);
     }
     const fullUrl = `${cfg.baseUrl}${finalPath}`;
     let res;
     let data;
     const startedAt = Date.now();
     try {
-      res = await fetch(fullUrl, fetchOpts);
+      res = await fetch(fullUrl, fetchOptions);
     } catch (error) {
       const aborted = options?.signal?.aborted || error instanceof Error && error.name === "AbortError";
-      const err = new Error(error instanceof Error ? error.message : "Network request failed");
-      err.name = aborted ? "AbortError" : "NetworkError";
-      err.method = method;
-      err.url = fullUrl;
-      err.aborted = aborted;
+      const err = requestError(
+        aborted ? "AbortError" : "NetworkError",
+        error instanceof Error ? error.message : "Network request failed",
+        { method, url: fullUrl, aborted }
+      );
       if (options?.onError && method !== "GET") {
         Promise.resolve(
           options.onError({ error: err, method, url: fullUrl, aborted })
@@ -734,18 +901,9 @@ function createHttpClient(cfg) {
       }
       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;
-      }
+    if (res.status === 401 && !retried) {
+      await ensureFreshToken();
+      return request(method, path, body, options, true);
     }
     try {
       const contentLength = res.headers.get("content-length");
@@ -756,30 +914,35 @@ function createHttpClient(cfg) {
         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;
+      const err = requestError("ParseError", "Failed to parse response", {
+        method,
+        url: fullUrl,
+        statusCode: res.status
+      });
       if (options?.onError && method !== "GET") {
         Promise.resolve(
-          options.onError({ error: err, method, url: fullUrl, status: res.status })
+          options.onError({
+            error: err,
+            method,
+            url: fullUrl,
+            status: res.status
+          })
         ).catch(() => {
         });
       }
       throw err;
     }
     if (!res.ok) {
-      const serverErr = data;
+      const serverErr = toServerError(data, res.status);
       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;
+      const err = requestError("ApiError", serverErr.message, {
+        statusCode: serverErr.statusCode,
+        validationErrors: reqErr.validationErrors,
+        method,
+        url: fullUrl,
+        requestId: requestId || void 0
+      });
       if (options?.onError && method !== "GET") {
         Promise.resolve(
           options.onError({
@@ -829,183 +992,279 @@ function supportConversationQuery(params) {
   if (params.after_id) qs.set("after_id", params.after_id);
   return qs.toString();
 }
+function storefrontSupportOptions(supportToken, options) {
+  if (!/^[0-9a-f]{64}$/.test(supportToken)) {
+    throw new Error("support_token must be a 64-character lowercase hexadecimal token");
+  }
+  const headers = { ...options?.headers };
+  for (const name of Object.keys(headers)) {
+    if (name.toLowerCase() === "x-arky-support-token") delete headers[name];
+  }
+  return {
+    ...options,
+    headers: {
+      ...headers,
+      "X-Arky-Support-Token": supportToken
+    }
+  };
+}
 function createStorefrontSupportApi(config) {
-  const { httpClient, storeId } = config;
+  const { httpClient } = config;
   return {
     async startConversation(params = {}, opts) {
+      const storeId = config.storeId;
       return httpClient.post(
         `/v1/storefront/${storeId}/support/conversations`,
-        { store_id: storeId, ...params },
+        { ...params, store_id: storeId },
         opts
       );
     },
     async sendMessage(params, opts) {
+      const { support_token, ...request } = params;
+      const storeId = config.storeId;
       return httpClient.post(
-        `/v1/storefront/${storeId}/support/conversations/${params.conversation_id}/messages`,
-        { store_id: storeId, ...params },
-        opts
+        `/v1/storefront/${storeId}/support/conversations/${request.conversation_id}/messages`,
+        { ...request, store_id: storeId },
+        storefrontSupportOptions(support_token, opts)
       );
     },
     async getConversation(params, opts) {
-      const qs = supportConversationQuery({ store_id: storeId, ...params });
+      const { support_token, ...request } = params;
+      const storeId = config.storeId;
+      const qs = supportConversationQuery({ ...request, store_id: storeId });
       return httpClient.get(
-        `/v1/storefront/${storeId}/support/conversations/${params.conversation_id}?${qs}`,
-        opts
+        `/v1/storefront/${storeId}/support/conversations/${request.conversation_id}?${qs}`,
+        storefrontSupportOptions(support_token, opts)
       );
     }
   };
 }
 
 // src/utils/blocks.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isBlock(value) {
+  return isRecord2(value) && typeof value.key === "string" && typeof value.type === "string";
+}
+function recordFromBlocks(values, locale) {
+  const result = {};
+  for (const value of values) {
+    if (!isBlock(value)) continue;
+    result[value.key] = unwrapBlock(value, locale);
+  }
+  return result;
+}
+function localizedValue(value, locale) {
+  if (typeof value === "string") return value;
+  if (!isRecord2(value)) return "";
+  const selected = value[locale] ?? value.en;
+  return typeof selected === "string" ? selected : "";
+}
+function unwrapBlock(value, locale) {
+  if (!isBlock(value)) return value;
+  if (value.type === "localized_text" || value.type === "markdown") {
+    return localizedValue(value.value, locale);
+  }
+  if (value.type === "array") {
+    if (!Array.isArray(value.value)) return [];
+    return value.value.map((item) => {
+      if (isBlock(item)) return unwrapBlock(item, locale);
+      if (isRecord2(item) && Array.isArray(item.value)) {
+        return recordFromBlocks(item.value, locale);
+      }
+      if (!isRecord2(item)) return item;
+      return Object.fromEntries(
+        Object.entries(item).map(([key, nested]) => [key, unwrapBlock(nested, locale)])
+      );
+    });
+  }
+  if (value.type === "object") {
+    if (Array.isArray(value.value)) return recordFromBlocks(value.value, locale);
+    if (!isRecord2(value.value)) return {};
+    return Object.fromEntries(
+      Object.entries(value.value).map(([key, nested]) => [key, unwrapBlock(nested, locale)])
+    );
+  }
+  return value.value;
+}
+function blockContentArray(values, locale) {
+  const blocks = values.filter(isBlock);
+  if (blocks.length === 0) return [];
+  if (blocks.every((block) => block.key === blocks[0].key)) {
+    return blocks.map((block) => blockContentValue(block, locale));
+  }
+  return Object.fromEntries(
+    blocks.map((block) => [block.key, blockContentValue(block, locale)])
+  );
+}
+function blockContentValue(block, locale) {
+  if (block.type === "localized_text" || block.type === "markdown") {
+    return localizedValue(block.value, locale);
+  }
+  if (block.type === "media") return block.value ?? null;
+  if (block.type === "array") {
+    return Array.isArray(block.value) ? blockContentArray(block.value, locale) : [];
+  }
+  if (block.type === "object") {
+    if (Array.isArray(block.value)) return blockContentArray(block.value, locale);
+    if (!isRecord2(block.value)) return {};
+    return Object.fromEntries(
+      Object.entries(block.value).map(([key, value]) => [
+        key,
+        isBlock(value) ? blockContentValue(value, locale) : value
+      ])
+    );
+  }
+  return block.value;
+}
+function findBlock(entry, key) {
+  return entry?.blocks?.find((block) => block.key === key);
+}
 function getBlockLabel(block) {
-  if (!block) return "";
-  return block.key?.replace(/_/g, " ").replace(/\b\w/g, (l) => l.toUpperCase()) ?? "";
+  return block?.key.replace(/_/g, " ").replace(/\b\w/g, (letter) => letter.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 "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);
+  if (block?.value === null || block?.value === void 0) return "";
+  if (block.type === "boolean") return block.value ? "Yes" : "No";
+  if (block.type === "number") {
+    const properties = isRecord2(block.properties) ? block.properties : {};
+    if (properties.variant === "DATE" || properties.variant === "DATE_TIME") {
+      return new Date(Number(block.value)).toLocaleDateString();
+    }
   }
+  if (block.type === "media" && isRecord2(block.value)) {
+    const label = block.value.name ?? block.value.title ?? block.value.id;
+    return typeof label === "string" ? label : "";
+  }
+  return String(block.value);
 }
-function prepareBlocksForSubmission(formData, blockTypes) {
-  return Object.keys(formData).filter((key) => formData[key] !== null && formData[key] !== void 0).map((key) => ({
+function prepareBlocksForSubmission(formData, blockTypes = {}) {
+  return Object.entries(formData).filter(([, value]) => value !== null && value !== void 0).map(([key, value]) => ({
     key,
-    value: (blockTypes?.[key] || "text") === "array" && !Array.isArray(formData[key]) ? [formData[key]] : formData[key]
+    value: blockTypes[key] === "array" && !Array.isArray(value) ? [value] : value
   }));
 }
 function extractBlockValues(blocks) {
-  const values = {};
-  blocks.forEach((block) => {
-    values[block.key] = block.value ?? null;
-  });
-  return values;
+  return Object.fromEntries(blocks.map((block) => [block.key, block.value ?? null]));
 }
-var getBlockValue = (entry, blockKey) => {
-  const block = entry?.blocks?.find((f) => f.key === blockKey);
-  return block?.value ?? null;
-};
-var getBlockTextValue = (block, locale = "en") => {
+function getBlockValue(entry, key) {
+  return findBlock(entry, key)?.value ?? null;
+}
+function getBlockTextValue(block, locale = "en") {
   if (!block || block.value === null || block.value === void 0) return "";
-  const blockType = block.type;
-  if (blockType === "localized_text" || blockType === "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 === "array" && Array.isArray(block.value)) {
-    return block.value;
-  }
-  return [];
-};
-function unwrapBlock(block, locale) {
-  if (!block?.type || block.value === void 0) return block;
-  const blockType = block.type;
-  if (blockType === "array") {
-    return block.value.map((obj) => {
-      const parsed = {};
-      for (const [k, v] of Object.entries(obj)) {
-        parsed[k] = unwrapBlock(v, locale);
-      }
-      return parsed;
-    });
-  }
-  if (blockType === "object") {
-    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 localizedValue(block.value, locale);
   }
-  if (blockType === "localized_text" || blockType === "markdown") {
-    return block.value?.[locale];
-  }
-  return block.value;
+  return typeof block.value === "string" ? block.value : String(block.value);
+}
+function getBlockContentValue(entry, key, locale = "en") {
+  const block = findBlock(entry, key);
+  return block ? blockContentValue(block, locale) : null;
 }
-var getBlockObjectValues = (entry, blockKey, locale = "en") => {
-  const block = entry?.blocks?.find((f) => f.key === blockKey);
-  if (!block || block.type !== "array" || !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;
-    }, {});
+function getBlockValues(entry, key) {
+  const block = findBlock(entry, key);
+  return block?.type === "array" && Array.isArray(block.value) ? block.value : [];
+}
+function getBlockObjectValues(entry, key, locale = "en") {
+  return getBlockValues(entry, key).map((value) => {
+    if (isRecord2(value) && Array.isArray(value.value)) {
+      return recordFromBlocks(value.value, locale);
+    }
+    return isRecord2(value) ? Object.fromEntries(
+      Object.entries(value).map(([field, nested]) => [field, unwrapBlock(nested, locale)])
+    ) : {};
   });
-};
-var getBlockFromArray = (entry, blockKey, locale = "en") => {
-  const block = entry?.blocks?.find((f) => f.key === blockKey);
+}
+function getBlockFromArray(entry, key, locale = "en") {
+  const block = findBlock(entry, key);
   if (!block) return {};
-  if (block.type === "array" && Array.isArray(block.value)) {
-    return block.value.reduce((acc, current) => {
-      acc[current.key] = unwrapBlock(current, locale);
-      return acc;
-    }, {});
-  }
-  if (block.type === "object" && 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 === "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;
-};
+  const value = unwrapBlock(block, locale);
+  if (isRecord2(value)) return value;
+  if (Array.isArray(block.value)) return recordFromBlocks(block.value, locale);
+  return { [block.key]: value };
+}
+function nestedUrl(value) {
+  const resolutions = isRecord2(value.resolutions) ? value.resolutions : null;
+  const original = resolutions && isRecord2(resolutions.original) ? resolutions.original : null;
+  if (typeof original?.url === "string") return original.url;
+  return typeof value.url === "string" ? value.url : null;
+}
+function getImageUrl(value, isBlock2 = true) {
+  if (typeof value === "string") return value;
+  if (!isRecord2(value)) return null;
+  if (value.type === "media" && isRecord2(value.value)) return nestedUrl(value.value);
+  if (isBlock2 && typeof value.url === "string") return value.url;
+  return nestedUrl(value);
+}
 
 // src/utils/price.ts
+var SUPPORTED_STORE_CURRENCIES = Object.freeze([
+  "USD",
+  "EUR",
+  "GBP",
+  "JPY",
+  "CNY",
+  "CHF",
+  "AUD",
+  "CAD",
+  "HKD",
+  "SGD",
+  "NZD",
+  "KRW",
+  "SEK",
+  "NOK",
+  "DKK",
+  "INR",
+  "MXN",
+  "BRL",
+  "ZAR",
+  "RUB",
+  "TRY",
+  "PLN",
+  "THB",
+  "IDR",
+  "MYR",
+  "PHP",
+  "CZK",
+  "ILS",
+  "AED",
+  "SAR",
+  "HUF",
+  "RON",
+  "BGN",
+  "HRK",
+  "BAM",
+  "RSD",
+  "MKD",
+  "ALL"
+]);
+var SUPPORTED_STORE_CURRENCY_SET = Object.freeze(
+  new Set(SUPPORTED_STORE_CURRENCIES)
+);
+var ZERO_MINOR_UNIT_STORE_CURRENCIES = Object.freeze(
+  /* @__PURE__ */ new Set(["JPY", "KRW"])
+);
 function formatCurrency(amount, currencyCode, locale = "en") {
-  if (!currencyCode) return "";
+  const normalized = currencyCode.trim().toUpperCase();
+  if (!normalized) return "";
+  const minorUnits = getCurrencyMinorUnits(normalized);
   return new Intl.NumberFormat(locale, {
     style: "currency",
-    currency: currencyCode.toUpperCase()
+    currency: normalized,
+    minimumFractionDigits: minorUnits,
+    maximumFractionDigits: minorUnits
   }).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 getCurrencyMinorUnits(currency) {
+  const normalized = currency.trim().toUpperCase();
+  if (!SUPPORTED_STORE_CURRENCY_SET.has(normalized)) {
+    throw new RangeError(`Unsupported currency '${currency}'`);
   }
+  return ZERO_MINOR_UNIT_STORE_CURRENCIES.has(normalized) ? 0 : 2;
 }
 function convertToMajor(minorAmount, currency) {
-  const units = getMinorUnits(currency);
+  const units = getCurrencyMinorUnits(currency);
   return minorAmount / Math.pow(10, units);
 }
 function getCurrencySymbol(currency) {
@@ -1027,22 +1286,24 @@ function getCurrencyName(currency) {
   }
 }
 function formatMinor(amountMinor, currency) {
-  if (!currency) return "";
+  if (!Number.isSafeInteger(amountMinor)) {
+    throw new RangeError("Minor-unit amount must be a safe integer");
+  }
   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 "";
+  if (!prices || prices.length === 0 || !marketId) return "";
+  const price = prices.find((p) => p.market === marketId);
+  if (!price || !Number.isSafeInteger(price.amount) || price.amount < 0 || !price.currency) 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;
+  if (!prices || prices.length === 0 || !marketId) return null;
+  const price = prices.find((p) => p.market === marketId);
+  return price && Number.isSafeInteger(price.amount) && price.amount >= 0 ? price.amount : null;
 }
 
 // src/utils/validation.ts
@@ -1143,6 +1404,7 @@ function formatDate(date, locale) {
 async function fetchSvgContent(mediaObject) {
   if (!mediaObject) return null;
   const svgUrl = getImageUrl(mediaObject, false);
+  if (!svgUrl) return null;
   try {
     const response = await fetch(svgUrl);
     if (!response.ok) {
@@ -1235,9 +1497,10 @@ function getFirstAvailableFCId(variant, quantity = 1) {
 // src/index.ts
 function createUtilitySurface(apiConfig) {
   return {
-    getImageUrl: (imageBlock, isBlock = true) => getImageUrl(imageBlock, isBlock),
+    getImageUrl: (imageBlock, isBlock2 = true) => getImageUrl(imageBlock, isBlock2),
     getBlockValue,
     getBlockTextValue,
+    getBlockContentValue,
     getBlockValues,
     getBlockLabel,
     getBlockObjectValues,
@@ -1272,29 +1535,50 @@ function createUtilitySurface(apiConfig) {
     getFirstAvailableFCId
   };
 }
-var CONTACT_STORAGE_KEY = "arky_contact_session";
-function readContactSession() {
+function defaultStorefrontSessionStorage() {
   if (typeof window === "undefined") return null;
   try {
-    const raw = localStorage.getItem(CONTACT_STORAGE_KEY);
-    return raw ? JSON.parse(raw) : null;
+    return window.localStorage;
   } catch {
     return null;
   }
 }
-function writeContactSession(s) {
-  if (typeof window === "undefined") return;
-  if (s) {
-    localStorage.setItem(CONTACT_STORAGE_KEY, JSON.stringify(s));
-  } else {
-    localStorage.removeItem(CONTACT_STORAGE_KEY);
-  }
+function storefrontSessionStorageKey(baseUrl, storeId) {
+  const normalizedBaseUrl = baseUrl.trim().replace(/\/+$/, "").toLowerCase();
+  return `arky_contact_session:${encodeURIComponent(normalizedBaseUrl)}:${encodeURIComponent(storeId)}`;
 }
-function createStorefront(config) {
+function createStorefrontClient(config) {
   const locale = config.locale || "en";
   const initialMarket = config.market || "";
   const listeners = /* @__PURE__ */ new Set();
   let bareIdentifyPromise = null;
+  let identityTail = Promise.resolve();
+  const sessionStorage = config.sessionStorage || defaultStorefrontSessionStorage();
+  let memorySession = null;
+  function readContactSession() {
+    if (!sessionStorage) return memorySession;
+    try {
+      const raw = sessionStorage.getItem(
+        storefrontSessionStorageKey(config.baseUrl, config.storeId)
+      );
+      return raw ? JSON.parse(raw) : null;
+    } catch {
+      return memorySession;
+    }
+  }
+  function writeContactSession(session) {
+    memorySession = session;
+    if (!sessionStorage) return;
+    const key = storefrontSessionStorageKey(config.baseUrl, config.storeId);
+    try {
+      if (session) {
+        sessionStorage.setItem(key, JSON.stringify(session));
+      } else {
+        sessionStorage.removeItem(key);
+      }
+    } catch {
+    }
+  }
   function toPublic(s) {
     return s ? { contact: s.contact, store: s.store, market: s.market } : null;
   }
@@ -1350,19 +1634,23 @@ function createStorefront(config) {
   const contactApi = storefrontApi.crm.contact;
   function identify(params) {
     if (params?.market !== void 0) apiConfig.market = params.market;
+    const market = apiConfig.market;
     const isBareCall = !params?.email && !params?.verify;
     if (isBareCall && bareIdentifyPromise) return bareIdentifyPromise;
-    const promise = (async () => {
+    const run = async () => {
       try {
-        const result = await contactApi.identify({
-          market: apiConfig.market,
-          email: params?.email,
-          verify: params?.verify
-        });
+        const result = await (params?.verify ? contactApi.requestCode({
+          market,
+          email: params.email
+        }) : contactApi.identify({
+          market,
+          email: params?.email
+        }));
         return {
           contact: result.contact,
           store: result.store,
-          market: result.market
+          market: result.market,
+          verification_challenge: result.verification_challenge
         };
       } catch (err) {
         const e = err;
@@ -1370,21 +1658,34 @@ function createStorefront(config) {
         if (isBareCall && status === 401) {
           updateSession(() => null);
           const result = await contactApi.identify({
-            market: apiConfig.market
+            market
           });
           return {
             contact: result.contact,
             store: result.store,
-            market: result.market
+            market: result.market,
+            verification_challenge: result.verification_challenge
           };
         }
         throw err;
       }
-    })().catch((err) => {
-      if (isBareCall) bareIdentifyPromise = null;
-      throw err;
-    });
-    if (isBareCall) bareIdentifyPromise = promise;
+    };
+    const promise = identityTail.then(run);
+    identityTail = promise.then(
+      () => void 0,
+      () => void 0
+    );
+    if (isBareCall) {
+      bareIdentifyPromise = promise;
+      void promise.then(
+        () => {
+          if (bareIdentifyPromise === promise) bareIdentifyPromise = null;
+        },
+        () => {
+          if (bareIdentifyPromise === promise) bareIdentifyPromise = null;
+        }
+      );
+    }
     return promise;
   }
   async function verify(params) {
@@ -1427,17 +1728,12 @@ function createStorefront(config) {
       };
     },
     store: storefrontApi.store,
-    cart: createCartController(storefrontApi.eshop.cart),
     cms: storefrontApi.cms,
     eshop: storefrontApi.eshop,
     crm: storefrontApi.crm,
     action: storefrontApi.action,
     experiments: storefrontApi.experiments,
     support: createStorefrontSupportApi(apiConfig),
-    setStoreId: (storeId) => {
-      apiConfig.storeId = storeId;
-      bareIdentifyPromise = null;
-    },
     getStoreId: () => apiConfig.storeId,
     setMarket: (key) => {
       apiConfig.market = key;
@@ -1451,14 +1747,40 @@ function createStorefront(config) {
     utils: createUtilitySurface(apiConfig)
   };
 }
+function createStorefront(config) {
+  const sessionStorage = config.sessionStorage || defaultStorefrontSessionStorage() || void 0;
+  const scopedConfig = {
+    ...config,
+    sessionStorage
+  };
+  const client = createStorefrontClient(scopedConfig);
+  Object.defineProperty(client, "forStore", {
+    enumerable: true,
+    configurable: false,
+    writable: false,
+    value: (storeId) => createStorefront({
+      ...scopedConfig,
+      storeId,
+      market: client.getMarket(),
+      locale: client.getLocale()
+    })
+  });
+  return client;
+}
 
 // src/payments/stripe.ts
+async function defaultStripeLoader(publishableKey, options) {
+  const { loadStripe } = await import('@stripe/stripe-js');
+  return loadStripe(publishableKey, options);
+}
 function normalizeCurrency(currency) {
   return currency.trim().toLowerCase();
 }
-async function createStripeConfirmationTokenController(config) {
-  const { loadStripe } = await import('@stripe/stripe-js');
-  const stripe = await loadStripe(config.publishableKey);
+async function createStripeConfirmationTokenController(config, stripeLoader = defaultStripeLoader) {
+  const stripe = await stripeLoader(
+    config.publishableKey,
+    config.connectedAccountId ? { stripeAccount: config.connectedAccountId } : void 0
+  );
   if (!stripe) throw new Error("Stripe failed to initialize");
   let elements = createElements(stripe, config);
   let paymentElement = elements.create("payment", {
@@ -1547,11 +1869,11 @@ function firstLocalized(value, locale) {
   }
   return "";
 }
-function findBlock(blocks, keys) {
+function findBlock2(blocks, keys) {
   return (blocks || []).find((block) => keys.includes(block.key)) || null;
 }
 function blockText(blocks, keys, locale) {
-  const block = findBlock(blocks, keys);
+  const block = findBlock2(blocks, keys);
   if (!block) return "";
   return firstLocalized(block.value, locale);
 }
@@ -1567,15 +1889,32 @@ function providerName(provider, locale) {
 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,
-    contact_list_id: price?.contact_list_id
-  };
+function priceForMarket(prices, market, marketCurrency) {
+  const marketKey = market.trim();
+  if (!marketKey) throw new Error("A market is required to select a product price");
+  const currency = marketCurrency?.trim().toUpperCase();
+  if (!currency) throw new Error(`Market ${marketKey} does not have an authoritative currency`);
+  const marketPrices = prices.filter((candidate) => candidate.market === marketKey);
+  if (marketPrices.length === 0) {
+    throw new Error(`Product is not priced for market ${marketKey}`);
+  }
+  if (marketPrices.some(
+    (candidate) => !Number.isSafeInteger(candidate.amount) || candidate.amount < 0 || candidate.currency.trim().toUpperCase() !== currency
+  )) {
+    throw new Error(`Product has an invalid price for market ${marketKey}`);
+  }
+  const authorizedPrices = marketPrices.filter((candidate) => candidate.contact_list_id);
+  if (authorizedPrices.length > 0) {
+    return authorizedPrices.reduce(
+      (lowest, candidate) => candidate.amount < lowest.amount ? candidate : lowest
+    );
+  }
+  const basePrices = marketPrices.filter((candidate) => !candidate.contact_list_id);
+  if (basePrices.length !== 1) {
+    throw new Error(`Product does not have one base price for market ${marketKey}`);
+  }
+  const price = basePrices[0];
+  return price;
 }
 function availableStock(client, variant) {
   const fromUtility = client.utils.getAvailableStock(variant);
@@ -1594,8 +1933,9 @@ function locationToAddress(location) {
     street2: null
   };
 }
-function normalizeForms(forms) {
-  return forms;
+function createFormEntry(formId, fields) {
+  if (!formId.trim()) throw new Error("formId is required");
+  return { form_id: formId, fields };
 }
 function toProductCheckoutItems(items) {
   return items.map((item) => ({
@@ -1607,36 +1947,97 @@ function toProductCheckoutItems(items) {
   }));
 }
 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);
+  return items.map((item) => ({
+    type: "service",
+    id: item.id,
+    service_id: item.service_id,
+    provider_id: item.provider_id,
+    slots: [...item.slots].sort((a, b) => a.from - b.from),
+    forms: item.forms
+  }));
+}
+function formValueError(field, message) {
+  return new Error(`Invalid value for form field '${field.key}': ${message}`);
+}
+function isValidGeoLocation(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const location = value;
+  if (location.label !== void 0 && location.label !== null && typeof location.label !== "string") {
+    return false;
+  }
+  const coordinates = location.coordinates;
+  if (!coordinates || typeof coordinates !== "object") return false;
+  return Number.isFinite(coordinates.lat) && Number.isFinite(coordinates.lon) && coordinates.lat >= -90 && coordinates.lat <= 90 && coordinates.lon >= -180 && coordinates.lon <= 180;
+}
+function buildFormField(field, value) {
+  const common = { id: field.id, key: field.key };
+  switch (field.type) {
+    case "text":
+      if (typeof value !== "string") throw formValueError(field, "expected text");
+      if (field.required && value.trim().length === 0) throw formValueError(field, "required text is blank");
+      return { ...common, type: "text", value };
+    case "number":
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw formValueError(field, "expected a finite number");
+      }
+      if (field.min !== null && field.min !== void 0 && value < field.min) {
+        throw formValueError(field, `must be at least ${field.min}`);
+      }
+      if (field.max !== null && field.max !== void 0 && value > field.max) {
+        throw formValueError(field, `must be at most ${field.max}`);
+      }
+      return { ...common, type: "number", value };
+    case "boolean":
+      if (typeof value !== "boolean") throw formValueError(field, "expected a boolean");
+      return { ...common, type: "boolean", value };
+    case "date":
+      if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+        throw formValueError(field, "expected an integer timestamp");
+      }
+      return { ...common, type: "date", value };
+    case "geo_location":
+      if (!isValidGeoLocation(value)) throw formValueError(field, "expected valid coordinates");
+      return { ...common, type: "geo_location", value };
+    case "select": {
+      if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw formValueError(field, "expected a list of options");
+      }
+      const selected = value;
+      if (field.required && selected.length === 0) throw formValueError(field, "at least one option is required");
+      if (new Set(selected).size !== selected.length || selected.some((item) => !field.options.includes(item))) {
+        throw formValueError(field, "contains an unknown or duplicate option");
+      }
+      return { ...common, type: "select", value: selected };
+    }
+  }
+}
+function isEmptyOptionalValue(field, value) {
+  if (field.required) return false;
+  if (field.type === "text") return value === "";
+  if (field.type === "select") return Array.isArray(value) && value.length === 0;
+  if (field.type === "geo_location") {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0);
+  }
+  return false;
+}
+function buildFormFields(schema, values) {
+  const knownKeys = new Set(schema.map((field) => field.key));
+  const unknownKey = Object.keys(values).find((key) => !knownKeys.has(key));
+  if (unknownKey) throw new Error(`Form field '${unknownKey}' is not defined by the form schema`);
+  const fields = [];
+  for (const field of schema) {
+    const value = values[field.key];
+    if (value === void 0) {
+      if (field.required) throw formValueError(field, "required value is missing");
       continue;
     }
-    groups.set(key, {
-      type: "service",
-      id: item.id,
-      service_id: item.service_id,
-      provider_id: item.provider_id,
-      slots: [slot],
-      forms: item.forms || []
-    });
+    if (isEmptyOptionalValue(field, value)) continue;
+    fields.push(buildFormField(field, value));
   }
-  return [...groups.values()].map((item) => ({
-    ...item,
-    slots: [...item.slots].sort((a, b) => a.from - b.from)
-  }));
+  return fields;
 }
-function formFieldsFromBlocks(blocks) {
-  return blocks.map((block) => ({
-    id: block.id,
-    key: block.key,
-    type: block.type,
-    value: block.value
-  }));
+function createFormEntryFromValues(form, values) {
+  return createFormEntry(form.id, buildFormFields(form.schema, values));
 }
 function getFormBlockType(field) {
   if (field.key === "email") return "email";
@@ -1646,11 +2047,15 @@ function getFormBlockType(field) {
 }
 function getFormBlockValue(field) {
   if (field.type === "boolean") return false;
-  if (field.type === "number") return field.min ?? 0;
+  if (field.type === "select") return [];
   if (field.type === "geo_location") return {};
+  if (field.type === "number" || field.type === "date") return void 0;
   return "";
 }
 function formSchemaToBlock(field) {
+  const min = field.type === "number" ? field.min : void 0;
+  const max = field.type === "number" ? field.max : void 0;
+  const options = field.type === "select" ? field.options : void 0;
   return {
     id: field.id,
     key: field.key,
@@ -1658,9 +2063,9 @@ function formSchemaToBlock(field) {
     properties: {
       isRequired: field.required,
       minValues: field.required ? 1 : 0,
-      min: field.min,
-      max: field.max,
-      options: field.options,
+      min,
+      max,
+      options,
       pattern: field.key === "email" ? "^.+@.+\\..+$" : field.key === "phone" ? "^.{6,20}$" : void 0
     },
     value: getFormBlockValue(field)
@@ -1703,15 +2108,13 @@ function createServiceInitialState() {
     service: null,
     availability: null,
     providers: [],
+    serviceProviders: [],
     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,
@@ -1721,7 +2124,6 @@ function createServiceInitialState() {
     quoteError: null,
     currency: null,
     dateTimeConfirmed: false,
-    isMultiDay: false,
     availablePaymentMethods: [],
     cartId: null,
     promoCode: null
@@ -1742,8 +2144,9 @@ function normalizeTimezoneGroups(groups) {
 function firstFiniteNumber(...values) {
   return values.find((value) => typeof value === "number" && Number.isFinite(value));
 }
-function initialize(config) {
+function initializeStore(config) {
   const client = createStorefront(config);
+  const formClients = /* @__PURE__ */ new Map([[client.getStoreId(), client]]);
   const session = nanostores.atom(client.session);
   const locale = nanostores.atom(config.locale || client.getLocale());
   const market_key = nanostores.atom(config.market || client.getMarket());
@@ -1754,7 +2157,10 @@ function initialize(config) {
     const store = value?.store;
     const methods = value?.market?.payment_methods || [];
     const hasCreditCard = methods.some((method) => method.type === "credit_card");
-    return { provider: store?.payment || null, enabled: hasCreditCard && !!store?.payment };
+    return {
+      provider: store?.payment || null,
+      enabled: hasCreditCard && !!store?.payment
+    };
   });
   const cart = nanostores.atom(null);
   const product_items = nanostores.atom([]);
@@ -1795,7 +2201,10 @@ function initialize(config) {
   );
   const service_item_count = nanostores.computed(
     [cart, service_items],
-    (cartValue, items) => Math.max(rawServiceItemCount(cartValue), items.length)
+    (cartValue, items) => Math.max(
+      rawServiceItemCount(cartValue),
+      items.reduce((total, item) => total + Math.max(1, item.slots.length), 0)
+    )
   );
   const item_count = nanostores.computed(
     [cart, product_item_count, service_item_count],
@@ -1835,8 +2244,15 @@ function initialize(config) {
     error: null
   });
   const service_state = nanostores.map(createServiceInitialState());
-  const service_form_node = nanostores.atom(null);
-  const service_form_blocks = nanostores.computed(service_form_node, (node) => node?.blocks || []);
+  const service_form_definitions = /* @__PURE__ */ new Map();
+  const service_form_state = nanostores.map({
+    provider_id: null,
+    groups: [],
+    loading: false,
+    error: null
+  });
+  const service_form_groups = nanostores.computed(service_form_state, (state) => state.groups);
+  const service_form_blocks = nanostores.computed(service_form_groups, (groups) => groups.flatMap((group) => group.blocks));
   client.onAuthStateChanged((value) => session.set(value));
   currency.subscribe((value) => service_state.setKey("currency", value));
   session.subscribe((value) => {
@@ -1851,25 +2267,30 @@ function initialize(config) {
   function currentLocale() {
     return locale.get() || client.getLocale() || "en";
   }
-  function currentCurrency() {
-    return currency.get() || market.get()?.currency || null;
+  function clientForStore(storeId) {
+    const existing = formClients.get(storeId);
+    if (existing) return existing;
+    const scoped = client.forStore(storeId);
+    formClients.set(storeId, scoped);
+    return scoped;
   }
   function currentStripePublishableKey() {
     const provider = payment_config.get()?.provider;
-    return provider?.publishable_key || provider?.publishableKey || provider?.publicKey || null;
+    return provider?.publishable_key || null;
+  }
+  function currentStripeConnectedAccountId() {
+    const provider = payment_config.get()?.provider;
+    return provider?.connected_account_id || null;
   }
   function currentPaymentAmount() {
     return Math.max(
       0,
-      firstFiniteNumber(
-        quote.get()?.charge_amount,
-        quote.get()?.payment?.total,
-        cart.get()?.quote_snapshot?.charge_amount,
-        cart.get()?.quote_snapshot?.payment?.total,
-        cart.get()?.quote_snapshot?.total
-      ) ?? 0
+      firstFiniteNumber(quote.get()?.charge_amount, cart.get()?.quote_snapshot?.charge_amount, cart.get()?.quote_snapshot?.total) ?? 0
     );
   }
+  function currentPaymentCurrency() {
+    return quote.get()?.money?.currency?.trim() || cart.get()?.quote_snapshot?.money?.currency?.trim() || null;
+  }
   function setPaymentController(controller) {
     const current = payment_controller.get();
     if (current && current !== controller) {
@@ -1886,10 +2307,24 @@ function initialize(config) {
     if (!publishableKey) {
       throw new Error("Stripe publishable key is required to mount card payment");
     }
+    const hasExplicitAmount = options.amount !== void 0;
+    const hasExplicitCurrency = Boolean(options.currency?.trim());
+    if (hasExplicitAmount !== hasExplicitCurrency) {
+      throw new Error("Stripe amount and currency must be supplied together");
+    }
+    const amount = hasExplicitAmount ? options.amount : currentPaymentAmount();
+    if (!Number.isSafeInteger(amount) || amount <= 0) {
+      throw new Error("A positive minor-unit payment amount is required to mount card payment");
+    }
+    const paymentCurrency = hasExplicitCurrency ? options.currency.trim() : currentPaymentCurrency();
+    if (!paymentCurrency || !/^[a-z]{3}$/i.test(paymentCurrency)) {
+      throw new Error("An explicit three-letter payment currency is required to mount card payment");
+    }
     const controller = await createStripeConfirmationTokenController({
       publishableKey,
-      amount: Math.max(0, options.amount ?? currentPaymentAmount()),
-      currency: options.currency || currentCurrency() || "usd",
+      connectedAccountId: options.connectedAccountId || currentStripeConnectedAccountId() || void 0,
+      amount,
+      currency: paymentCurrency,
       ...options.appearance ? { appearance: options.appearance } : {}
     });
     controller.mount(target);
@@ -1915,10 +2350,24 @@ function initialize(config) {
   }
   async function identify(params = {}) {
     if (params.market) setMarket(params.market);
-    const result = await client.identify({ ...params, market: params.market || currentMarketKey() });
-    session.set(result);
+    const result = await client.identify({
+      ...params,
+      market: params.market || currentMarketKey()
+    });
+    session.set({
+      contact: result.contact,
+      store: result.store,
+      market: result.market
+    });
     return result;
   }
+  async function identifyContactEmailIfMissing(email) {
+    const normalizedEmail = email.trim().toLowerCase();
+    if (!normalizedEmail) throw new Error("Contact email is required");
+    const current = session.get();
+    if (current?.contact.email === normalizedEmail) return current;
+    return identify({ email: normalizedEmail });
+  }
   function setMarket(key) {
     market_key.set(key);
     client.setMarket(key);
@@ -1943,7 +2392,9 @@ function initialize(config) {
     const refreshRevision = cartWriteRevision;
     cartRequest = (async () => {
       await ensureSession();
-      const response = await client.cart.refresh({ market: currentMarketKey() });
+      const response = await client.eshop.cart.current({
+        market: currentMarketKey()
+      });
       await applyCartResponse(response, { ifRevision: refreshRevision });
       return response;
     })();
@@ -1957,9 +2408,9 @@ function initialize(config) {
       cart_status.setKey("loading", false);
     }
   }
-  async function buildProductCartItem(item, source) {
+  async function buildProductCartItem(item, source, productHint) {
     try {
-      const product = await client.eshop.product.get({ id: item.product_id });
+      const product = productHint?.id === item.product_id ? productHint : 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 {
@@ -1970,7 +2421,7 @@ function initialize(config) {
         product_slug: entitySlug(product, currentLocale()),
         variant_attributes: variant.attributes,
         requires_shipping: variant.requires_shipping !== false,
-        price: priceForMarket(variant.prices, currentMarketKey(), currentCurrency()),
+        price: priceForMarket(variant.prices, currentMarketKey(), market.get()?.currency),
         quantity: item.quantity,
         added_at: source.created_at ? source.created_at * 1e3 : Date.now(),
         max_stock: availableStock(client, variant)
@@ -1992,18 +2443,15 @@ function initialize(config) {
         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
-        });
-      }
+      rows.push({
+        id: item.id || createId("service"),
+        service_id: item.service_id,
+        provider_id: item.provider_id,
+        slots: item.slots,
+        forms: item.forms || [],
+        service_name: service ? serviceName(service, currentLocale()) : item.service_id,
+        provider_name: provider ? providerName(provider, currentLocale()) : item.provider_id
+      });
     }
     return rows;
   }
@@ -2018,11 +2466,9 @@ function initialize(config) {
     quote.set(response.quote_snapshot || null);
     const items = response.items || [];
     const products = await Promise.all(
-      items.filter((item) => item.type === "product").map((item) => buildProductCartItem(item, response))
-    );
-    const services = await buildServiceCartItems(
-      items.filter((item) => item.type === "service")
+      items.filter((item) => item.type === "product").map((item) => buildProductCartItem(item, response, options.productHint))
     );
+    const services = await buildServiceCartItems(items.filter((item) => item.type === "service"));
     product_items.set(products.filter((item) => item !== null));
     service_items.set(services);
     return response;
@@ -2038,21 +2484,17 @@ function initialize(config) {
     cart_status.setKey("error", null);
     try {
       const current = cart.get() || await ensureCart();
-      const response = await client.cart.update({
+      const response = await client.eshop.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_key: input.payment_method_key || void 0,
-        shipping_method_id: input.shipping_method_id || cart_status.get().selected_shipping_method_id || void 0
+        shipping_address: input.shipping_address,
+        billing_address: input.billing_address,
+        forms: input.forms,
+        promo_code: input.promo_code === null ? "" : input.promo_code === void 0 ? promo_code.get() || void 0 : input.promo_code,
+        payment_method_key: input.payment_method_key === null ? "" : input.payment_method_key,
+        shipping_method_id: input.shipping_method_id === null ? "" : input.shipping_method_id === void 0 ? cart_status.get().selected_shipping_method_id || void 0 : input.shipping_method_id
       });
-      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 applyCartResponse(response, { ifRevision: writeRevision });
       return response;
     } catch (error) {
@@ -2067,7 +2509,7 @@ function initialize(config) {
     const writeRevision = nextCartWriteRevision();
     try {
       const current = cart.get() || await ensureCart();
-      const response = await client.cart.addItem({
+      const response = await client.eshop.cart.addItem({
         id: current.id,
         item: {
           type: "product",
@@ -2076,7 +2518,7 @@ function initialize(config) {
           quantity
         }
       });
-      await applyCartResponse(response, { ifRevision: writeRevision });
+      await applyCartResponse(response, { ifRevision: writeRevision, productHint: product });
       return response;
     } catch (error) {
       cart_status.setKey("error", readErrorMessage(error, "Failed to add product to cart."));
@@ -2099,11 +2541,9 @@ function initialize(config) {
     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({
+    const response = await client.eshop.cart.removeItem({
       id: current.id,
-      item_id: item.id,
-      product_id: item.product_id,
-      variant_id: item.variant_id
+      item_id: item.id
     });
     await applyCartResponse(response, { ifRevision: writeRevision });
     return response;
@@ -2125,7 +2565,7 @@ function initialize(config) {
     const current = cart.get();
     clearLocalCart();
     if (!current) return null;
-    const response = await client.cart.clear({ id: current.id });
+    const response = await client.eshop.cart.clear({ id: current.id });
     await applyCartResponse(response, { ifRevision: writeRevision });
     return response;
   }
@@ -2146,7 +2586,7 @@ function initialize(config) {
     cart_status.setKey("quote_error", null);
     try {
       const current = await syncCart(input);
-      const response = await client.cart.quote({ id: current.id });
+      const response = await client.eshop.cart.quote({ id: current.id });
       quote.set(response);
       return response;
     } catch (error) {
@@ -2164,23 +2604,17 @@ function initialize(config) {
     try {
       const current = await syncCart(input);
       const quoteValue = quote.get();
-      const paymentMethodKey = input.payment_method_key || current.payment_method_key || quoteValue?.payment?.payment_method_key || void 0;
-      let chargeAmount = firstFiniteNumber(
-        quoteValue?.charge_amount,
-        quoteValue?.payment?.total,
-        current.quote_snapshot?.charge_amount,
-        current.quote_snapshot?.payment?.total
-      );
+      const paymentMethodKey = input.payment_method_key || current.payment_method_key || quoteValue?.money?.payment_method_key || void 0;
+      let chargeAmount = firstFiniteNumber(quoteValue?.charge_amount, current.quote_snapshot?.charge_amount);
       if (paymentMethodKey === "credit_card" && chargeAmount === void 0) {
-        const latestQuote = await client.cart.quote({ id: current.id });
+        const latestQuote = await client.eshop.cart.quote({ id: current.id });
         quote.set(latestQuote);
-        chargeAmount = firstFiniteNumber(
-          latestQuote.charge_amount,
-          latestQuote.payment?.total,
-          latestQuote.total
-        );
+        chargeAmount = firstFiniteNumber(latestQuote.charge_amount, latestQuote.total);
+      }
+      if (paymentMethodKey === "credit_card" && (typeof chargeAmount !== "number" || !Number.isSafeInteger(chargeAmount) || chargeAmount < 0)) {
+        throw new Error("Card checkout requires a non-negative integer charge amount in minor units");
       }
-      const needsConfirmationToken = paymentMethodKey === "credit_card" && (chargeAmount === void 0 || chargeAmount > 0);
+      const needsConfirmationToken = paymentMethodKey === "credit_card" && typeof chargeAmount === "number" && chargeAmount > 0;
       let confirmationTokenId;
       let returnUrl = input.return_url;
       const paymentController = input.payment ?? payment_controller.get();
@@ -2194,7 +2628,7 @@ function initialize(config) {
         confirmationTokenId = token.confirmation_token_id;
         returnUrl = token.return_url || returnUrl;
       }
-      const response = await client.cart.checkout({
+      const response = await client.eshop.cart.checkout({
         id: current.id,
         payment_method_key: paymentMethodKey,
         confirmation_token_id: confirmationTokenId,
@@ -2213,8 +2647,8 @@ function initialize(config) {
         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(),
+        total: response.payment.amount,
+        currency: response.payment.currency,
         payment_method_key: paymentMethodKey || null,
         created_at: Date.now()
       };
@@ -2232,7 +2666,7 @@ function initialize(config) {
   }
   function serviceCalendar() {
     const state = service_state.get();
-    const { currentMonth, selectedDate, startDate, endDate, availability, selectedProviderId } = state;
+    const { currentMonth, selectedDate, availability, selectedProviderId } = state;
     const year = currentMonth.getFullYear();
     const monthIndex = currentMonth.getMonth();
     const first = new Date(year, monthIndex, 1);
@@ -2255,18 +2689,12 @@ function initialize(config) {
     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,
+        isSelected: iso === selectedDate,
+        isInRange: false,
         isToday: date.getTime() === today.getTime(),
         blank: false
       });
@@ -2303,46 +2731,38 @@ function initialize(config) {
       })
     }));
   }
-  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) {
+  function toServiceCartItem(slots, forms = []) {
+    const orderedSlots = [...slots].sort((left, right) => left.from - right.from || left.to - right.to);
+    const [first] = orderedSlots;
+    if (!first) throw new Error("At least one service slot is required");
+    if (orderedSlots.some((slot) => slot.serviceId !== first.serviceId || slot.providerId !== first.providerId)) {
+      throw new Error("A booking can only contain slots for one service and provider");
+    }
+    if (orderedSlots.some((slot) => !Number.isSafeInteger(slot.from) || !Number.isSafeInteger(slot.to) || slot.from >= slot.to)) {
+      throw new Error("A booking contains an invalid service slot");
+    }
+    for (let index = 1; index < orderedSlots.length; index += 1) {
+      if (orderedSlots[index - 1].to !== orderedSlots[index].from) {
+        throw new Error("A multi-slot booking must contain adjacent slots");
+      }
+    }
     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
+      id: createId("booking"),
+      service_id: first.serviceId,
+      provider_id: first.providerId,
+      slots: orderedSlots.map(({ from, to }) => ({ from, to })),
+      forms,
+      service_name: first.serviceName,
+      date_text: first.dateText,
+      time_text: first.timeText,
+      is_multi_day: orderedSlots.length > 1
     };
   }
-  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) {
+  async function syncServiceCart(items) {
     try {
       return await syncCart({
         product_items: product_items.get(),
-        service_items: slots.map(toServiceCartItem)
+        service_items: items
       });
     } catch (error) {
       service_state.setKey("quoteError", readErrorMessage(error, "Failed to sync service cart."));
@@ -2359,18 +2779,22 @@ function initialize(config) {
   const service_can_proceed = nanostores.computed(service_state, (state) => {
     const step = serviceCurrentStepName();
     if (step === "datetime") {
-      return state.isMultiDay ? !!(state.startDate && state.endDate && state.selectedSlot) : !!(state.selectedDate && state.selectedSlot);
+      return !!(state.selectedDate && state.selectedSlot);
     }
     if (step === "review") return true;
     return false;
   });
   const service_month_year = nanostores.computed(
     service_state,
-    (state) => state.currentMonth.toLocaleString(void 0, { month: "long", year: "numeric" })
+    (state) => state.currentMonth.toLocaleString(void 0, {
+      month: "long",
+      year: "numeric"
+    })
   );
-  const service_chain_start = nanostores.computed(service_state, (state) => {
-    if (!state.cart.length) return null;
-    return Math.max(...state.cart.map((slot) => slot.to));
+  const service_chain_start = nanostores.computed(service_items, (items) => {
+    const slots = items.flatMap((item) => item.slots);
+    if (!slots.length) return null;
+    return Math.max(...slots.map((slot) => slot.to));
   });
   const service_total_steps = nanostores.computed(service_state, (state) => state.service ? 2 : 0);
   const service_steps = nanostores.computed(service_state, () => ({
@@ -2385,40 +2809,101 @@ function initialize(config) {
   });
   function formatServiceDateDisplay(value) {
     if (!value) return "";
-    return new Date(value).toLocaleDateString(void 0, { month: "short", day: "numeric" });
+    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 configuredServiceFormIds(relationship) {
+    const formIds = relationship.forms.map((entry) => entry.form_id.trim());
+    if (formIds.some((formId) => !formId) || new Set(formIds).size !== formIds.length) {
+      throw new Error(`Service provider ${relationship.provider_id} has blank or duplicate configured form IDs`);
+    }
+    return formIds;
+  }
+  function resolveServiceProvider(state, providerId) {
+    const serviceId = state.service?.id;
+    if (!serviceId) return null;
+    const relationships = state.serviceProviders.filter((relationship) => relationship.service_id === serviceId);
+    const targetProviderId = providerId ?? state.selectedSlot?.providerId ?? state.selectedProviderId;
+    if (targetProviderId) {
+      return relationships.find((relationship) => relationship.provider_id === targetProviderId) || null;
+    }
+    return relationships.length === 1 ? relationships[0] : null;
+  }
+  function clearServiceFormState(error = null, loading = false) {
+    service_form_state.set({
+      provider_id: null,
+      groups: [],
+      loading,
+      error
+    });
   }
-  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;
+  function activateServiceProviderForms(providerId, reset = false) {
+    const relationship = resolveServiceProvider(service_state.get(), providerId);
+    if (!relationship) {
+      clearServiceFormState();
+      return null;
+    }
+    const formIds = configuredServiceFormIds(relationship);
+    const current = service_form_state.get();
+    const currentFormIds = current.groups.map((group) => group.form.id);
+    if (!reset && current.provider_id === relationship.provider_id && currentFormIds.length === formIds.length && currentFormIds.every((formId, index) => formId === formIds[index])) {
+      if (current.error) service_form_state.setKey("error", null);
+      return relationship;
     }
-    return providers[0];
+    const groups = formIds.map((formId) => {
+      const form = service_form_definitions.get(formId);
+      if (!form) throw new Error(`Configured booking form '${formId}' was not loaded`);
+      return {
+        form,
+        blocks: form.schema.map(formSchemaToBlock)
+      };
+    });
+    service_form_state.set({
+      provider_id: relationship.provider_id,
+      groups,
+      loading: false,
+      error: null
+    });
+    return relationship;
   }
-  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 [];
+  async function loadServiceFormDefinitions(relationships) {
+    const formIds = [
+      ...new Set(relationships.flatMap((relationship) => configuredServiceFormIds(relationship)))
+    ];
+    if (formIds.length === 0) return;
+    const forms = await Promise.all(formIds.map((formId) => loadForm({ id: formId })));
+    for (let index = 0; index < forms.length; index += 1) {
+      const form = forms[index];
+      const formId = formIds[index];
+      if (form.id !== formId) {
+        throw new Error(`Configured booking form '${formId}' resolved to '${form.id}'`);
+      }
     }
+    for (const form of forms) service_form_definitions.set(form.id, form);
+  }
+  function configuredServiceFormEntries(relationship) {
+    const formIds = configuredServiceFormIds(relationship);
+    if (formIds.length === 0) return [];
+    activateServiceProviderForms(relationship.provider_id);
+    const state = service_form_state.get();
+    if (state.provider_id !== relationship.provider_id || state.groups.length !== formIds.length || state.groups.some((group, index) => group.form.id !== formIds[index])) {
+      throw new Error(`Booking forms are not ready for provider ${relationship.provider_id}`);
+    }
+    return state.groups.map(
+      (group) => createFormEntryFromValues(
+        group.form,
+        Object.fromEntries(group.blocks.map((block) => [block.key, block.value]))
+      )
+    );
   }
   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);
@@ -2427,39 +2912,62 @@ function initialize(config) {
       if (state.selectedDate) {
         service_state.setKey("slots", computeServiceSlots(state.selectedDate));
         service_state.setKey("selectedSlot", null);
+        service_state.setKey("quote", null);
+        service_state.setKey("quoteError", null);
+        activateServiceProviderForms();
       }
     },
     async select(service) {
-      service_state.setKey("loading", true);
+      service_form_definitions.clear();
+      clearServiceFormState(null, true);
+      service_state.set({
+        ...service_state.get(),
+        service: null,
+        serviceProviders: [],
+        providers: [],
+        selectedProviderId: null,
+        availability: null,
+        selectedDate: null,
+        slots: [],
+        selectedSlot: null,
+        dateTimeConfirmed: false,
+        quote: null,
+        quoteError: null,
+        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 })
+          client.eshop.service.findProviders({
+            service_id: service.id
+          })
+        ]);
+        const providerIds = [...new Set(serviceProviders.map((relationship) => relationship.provider_id))];
+        const [providerResults] = await Promise.all([
+          Promise.all(providerIds.map((id) => client.eshop.provider.get({ id }).catch(() => null))),
+          loadServiceFormDefinitions(serviceProviders)
         ]);
-        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,
+          serviceProviders,
           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
+          dateTimeConfirmed: false,
+          quote: null,
+          quoteError: null
         });
+        activateServiceProviderForms();
         await service_controller.loadMonth();
       } catch (error) {
+        service_form_definitions.clear();
+        clearServiceFormState(readErrorMessage(error, "Failed to load booking forms."));
         service_state.setKey("loading", false);
         throw error;
       }
@@ -2502,90 +3010,71 @@ function initialize(config) {
       void service_controller.loadMonth();
     },
     selectProvider(providerId) {
+      const state = service_state.get();
+      if (providerId && !resolveServiceProvider(state, providerId)) {
+        throw new Error(`Provider ${providerId} is not configured for the selected service`);
+      }
       service_state.set({
-        ...service_state.get(),
+        ...state,
         selectedProviderId: providerId,
         selectedDate: null,
-        startDate: null,
-        endDate: null,
         slots: [],
-        selectedSlot: null
+        selectedSlot: null,
+        dateTimeConfirmed: false,
+        quote: null,
+        quoteError: null
       });
+      activateServiceProviderForms(providerId);
       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());
-      }
+      service_state.set({
+        ...state,
+        selectedDate: cell.iso,
+        slots: computeServiceSlots(cell.iso),
+        selectedSlot: null,
+        dateTimeConfirmed: false,
+        quote: null,
+        quoteError: null
+      });
+      activateServiceProviderForms();
+      service_state.setKey("calendar", serviceCalendar());
     },
-    createMultiDaySlots() {
+    selectTimeSlot(slot) {
       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
-          });
+      if (slot) {
+        if (!state.service || slot.serviceId !== state.service.id) {
+          throw new Error("The selected slot does not belong to the selected service");
+        }
+        if (state.selectedProviderId && slot.providerId !== state.selectedProviderId) {
+          throw new Error("The selected slot does not belong to the selected provider");
+        }
+        if (!resolveServiceProvider(state, slot.providerId)) {
+          throw new Error(`Provider ${slot.providerId} is not configured for the selected service`);
         }
       }
-      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);
+      service_state.set({
+        ...state,
+        selectedSlot: slot,
+        dateTimeConfirmed: false,
+        quote: null,
+        quoteError: null
+      });
+      activateServiceProviderForms(slot?.providerId);
     },
     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);
+      service_state.set({
+        ...service_state.get(),
+        selectedDate: null,
+        slots: [],
+        selectedSlot: null,
+        dateTimeConfirmed: false,
+        quote: null,
+        quoteError: null
+      });
+      activateServiceProviderForms();
     },
     updateCalendar() {
       service_state.setKey("calendar", serviceCalendar());
@@ -2598,70 +3087,79 @@ function initialize(config) {
         }
       }
     },
-    async addToCart() {
+    async addToCart(explicitSlots) {
       const state = service_state.get();
-      const serviceBlocks = state.service?.forms || [];
-      const enrich = (slot) => ({
+      const slots = explicitSlots || (state.selectedSlot ? [state.selectedSlot] : []);
+      if (slots.length === 0) return;
+      const first = slots[0];
+      if (!state.service || first.serviceId !== state.service.id) {
+        throw new Error("The booking slots do not belong to the selected service");
+      }
+      const relationship = resolveServiceProvider(state, first.providerId);
+      if (!relationship) {
+        throw new Error(`Provider ${first.providerId} is not configured for the selected service`);
+      }
+      let forms;
+      try {
+        forms = configuredServiceFormEntries(relationship);
+      } catch (error) {
+        service_form_state.setKey("error", readErrorMessage(error, "Booking forms are invalid."));
+        throw error;
+      }
+      const displayName = serviceName(state.service, currentLocale());
+      const enriched = slots.map((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];
+        serviceName: displayName,
+        date: slot.dateText
+      }));
+      const nextItems = [...service_items.get(), toServiceCartItem(enriched, forms)];
+      await syncServiceCart(nextItems);
       service_state.set({
-        ...state,
-        cart: nextCart,
+        ...service_state.get(),
         selectedDate: null,
-        startDate: null,
-        endDate: null,
         slots: [],
-        selectedSlot: null
+        selectedSlot: null,
+        dateTimeConfirmed: false,
+        quote: null,
+        quoteError: null
       });
-      await syncServiceCart(nextCart);
+      activateServiceProviderForms(service_state.get().selectedProviderId, true);
       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 removeFromCart(bookingId) {
+      await syncServiceCart(service_items.get().filter((item) => item.id !== bookingId));
     },
     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" };
+      const items = service_items.get();
+      if (!items.length) throw new Error("Cart is empty");
       service_state.setKey("loading", true);
       try {
         const result = await checkout({
-          service_items: state.cart.map((slot) => ({
-            ...toServiceCartItem(slot),
-            forms: []
-          })),
+          service_items: items,
           payment_method_key: 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.") };
+        return result;
       } finally {
         service_state.setKey("loading", false);
       }
     },
     async fetchQuote(paymentMethodId, promoCode) {
-      const state = service_state.get();
-      if (!state.cart.length) return null;
+      service_state.get();
+      const items = service_items.get();
+      if (!items.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),
+          service_items: items,
           payment_method_key: paymentMethodId,
           promo_code: promoCode || void 0
         });
@@ -2689,6 +3187,9 @@ function initialize(config) {
       if (current === "datetime") {
         service_state.setKey("selectedSlot", null);
         service_state.setKey("dateTimeConfirmed", false);
+        service_state.setKey("quote", null);
+        service_state.setKey("quoteError", null);
+        activateServiceProviderForms();
       }
     },
     nextStep() {
@@ -2698,17 +3199,20 @@ function initialize(config) {
     },
     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";
+      const relationship = resolveServiceProvider(state);
+      if (!relationship) return "";
+      try {
+        const price = priceForMarket(relationship.prices, currentMarketKey(), market.get()?.currency);
+        return client.utils.formatPrice([price]);
+      } catch {
+        return "";
+      }
     },
     formatDateDisplay: formatServiceDateDisplay,
-    serviceItemsFromSlots(slots) {
-      return slots.map(toServiceCartItem);
+    serviceItemsFromSlots(slots, forms = []) {
+      return slots.length ? [toServiceCartItem(slots, forms)] : [];
     }
   };
-  service_items.subscribe((items) => setServiceCartFromServiceItems(items));
   async function loadEntry(params, options) {
     cms_state.setKey("loading", true);
     cms_state.setKey("error", null);
@@ -2718,7 +3222,10 @@ function initialize(config) {
       if (entryParams.id) {
         const entry2 = await client.cms.entry.get(entryParams, options);
         const cacheKey = entryParams.key || entryParams.id || entry2.id;
-        cms_state.setKey("entries", { ...cms_state.get().entries, [cacheKey]: entry2 });
+        cms_state.setKey("entries", {
+          ...cms_state.get().entries,
+          [cacheKey]: entry2
+        });
         return entry2;
       }
       if (!entryParams.collection_id || !entryParams.key) {
@@ -2737,7 +3244,10 @@ function initialize(config) {
       if (!entry) {
         throw new Error("CMS entry not found");
       }
-      cms_state.setKey("entries", { ...cms_state.get().entries, [entryParams.key]: entry });
+      cms_state.setKey("entries", {
+        ...cms_state.get().entries,
+        [entryParams.key]: entry
+      });
       return entry;
     } catch (error) {
       cms_state.setKey("error", readErrorMessage(error, "Failed to load CMS entry."));
@@ -2746,13 +3256,22 @@ function initialize(config) {
       cms_state.setKey("loading", false);
     }
   }
+  function formCacheKey(params) {
+    const storeId = params.store_id || client.getStoreId();
+    const identifier = params.id ? `id:${params.id}` : params.key ? `key:${params.key}` : "missing";
+    return `${storeId}:${identifier}`;
+  }
   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 });
+      const storeId = params.store_id || client.getStoreId();
+      const formClient = clientForStore(storeId);
+      const form = await formClient.cms.form.get({ ...params, store_id: storeId }, options);
+      const forms = { ...cms_state.get().forms };
+      forms[formCacheKey({ id: form.id, store_id: storeId })] = form;
+      forms[formCacheKey({ key: form.key, store_id: storeId })] = form;
+      cms_state.setKey("forms", forms);
       return form;
     } catch (error) {
       cms_state.setKey("error", readErrorMessage(error, "Failed to load CMS form."));
@@ -2761,12 +3280,26 @@ function initialize(config) {
       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 ensureFormClient(storeId) {
+    const formClient = clientForStore(storeId);
+    const marketKey = currentMarketKey();
+    if (formClient === client) {
+      await ensureSession();
+    } else if (!formClient.session || marketKey && formClient.session.market?.key !== marketKey) {
+      await formClient.identify({ market: marketKey });
+    }
+    return formClient;
+  }
+  async function submitForm(params, options) {
+    const storeId = params.store_id || client.getStoreId();
+    const formClient = await ensureFormClient(storeId);
+    return formClient.cms.form.submit({ ...params, store_id: storeId }, options);
+  }
+  async function submitFormByKey(params, options) {
+    const storeId = params.store_id || client.getStoreId();
+    const form = await loadForm({ key: params.key, store_id: storeId }, options);
+    const entry = createFormEntryFromValues(form, params.values);
+    return submitForm({ store_id: storeId, form_id: form.id, fields: entry.fields }, options);
   }
   async function loadProducts(params = {}, options) {
     eshop_state.setKey("loading_products", true);
@@ -2869,38 +3402,32 @@ function initialize(config) {
       destroy: destroyPaymentController
     },
     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,
+    createFormEntry,
     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)
+    list: loadProducts
   };
   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_state: service_form_state,
+    form_groups: service_form_groups,
     form_blocks: service_form_blocks,
     current_step_name: service_current_step_name,
     can_proceed: service_can_proceed,
@@ -2917,7 +3444,6 @@ function initialize(config) {
     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,
@@ -2941,8 +3467,8 @@ function initialize(config) {
     currency,
     allowed_payment_methods,
     payment_config,
-    cart: cart_store,
     identify,
+    identifyContactEmailIfMissing,
     verify: client.verify,
     me: client.me,
     logout: client.logout,
@@ -2967,7 +3493,7 @@ function initialize(config) {
       },
       form: {
         get: loadForm,
-        submit: (params, options) => client.cms.form.submit(params, options),
+        submit: submitForm,
         submitByKey: submitFormByKey
       },
       taxonomy: client.cms.taxonomy
@@ -2978,7 +3504,7 @@ function initialize(config) {
       service: service_store,
       provider: {
         get: (params, options) => client.eshop.provider.get(params, options),
-        find: loadProviders
+        list: loadProviders
       },
       order: client.eshop.order,
       cart: cart_store
@@ -3001,11 +3527,37 @@ function initialize(config) {
     utils: client.utils
   };
 }
+function initialize(config) {
+  const stores = /* @__PURE__ */ new Map();
+  const createScope = (scopeConfig) => {
+    const existing = stores.get(scopeConfig.storeId);
+    if (existing) return existing;
+    const store = initializeStore(scopeConfig);
+    stores.set(scopeConfig.storeId, store);
+    Object.defineProperty(store, "forStore", {
+      enumerable: true,
+      configurable: false,
+      writable: false,
+      value: (storeId) => createScope({
+        ...config,
+        storeId,
+        market: store.getMarket(),
+        locale: store.getLocale()
+      })
+    });
+    return store;
+  };
+  return createScope(config);
+}
 
 exports.COMMON_ACTION_KEYS = COMMON_ACTION_KEYS;
+exports.buildFormFields = buildFormFields;
 exports.createCartController = createCartController;
+exports.createFormEntry = createFormEntry;
+exports.createFormEntryFromValues = createFormEntryFromValues;
 exports.createStorefront = createStorefront;
 exports.createStripeConfirmationTokenController = createStripeConfirmationTokenController;
+exports.getBlockContentValue = getBlockContentValue;
 exports.initialize = initialize;
 //# sourceMappingURL=storefront.cjs.map
 //# sourceMappingURL=storefront.cjs.map