arky-sdk 0.9.20 → 0.11.0

package/dist/index.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+var nanostores = require('nanostores');
+
 // src/types/index.ts
 var PaymentMethodType = /* @__PURE__ */ ((PaymentMethodType2) => {
   PaymentMethodType2["Cash"] = "cash";
@@ -47,70 +49,50 @@ var COMMON_ACTION_KEYS = [
   "share",
   "wishlist.added"
 ];
-var createActionApi = (apiConfig) => ({
+var createActionApi = (apiConfig, lifecycle) => ({
   COMMON_ACTION_KEYS,
   async track(params) {
+    await lifecycle.ensureVisitorSession();
     try {
-      await apiConfig.httpClient.post(
-        `/v1/storefront/${apiConfig.storeId}/actions/track`,
-        { key: params.key, payload: params.payload }
-      );
+      await apiConfig.httpClient.post("/v1/storefront/actions/track", {
+        key: params.key,
+        payload: params.payload
+      });
     } catch {
     }
   }
 });
-var createStorefrontApi = (apiConfig, updateContactSession) => {
-  const base = (storeId = apiConfig.storeId) => `/v1/storefront/${storeId}`;
-  const pendingVerifications = /* @__PURE__ */ new Map();
+var createStorefrontApi = (apiConfig, updateContactSession, lifecycle) => {
+  const base = "/v1/storefront";
   function persistIdentification(result) {
-    const issued = result.token;
-    if (issued?.token) {
+    const sessionToken = result.token?.token;
+    if (sessionToken) {
       updateContactSession(() => ({
-        access_token: issued.token,
-        contact: result.contact,
-        store: result.store,
-        market: result.market
+        sessionToken,
+        contact: result.contact
       }));
     } 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
+        (current) => current ? { ...current, contact: result.contact } : 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
-      },
+      `${base}/account/${path}`,
+      { email: params?.email },
       options
     );
     return persistIdentification(result);
   }
   return {
     store: {
-      getStore(options) {
-        return apiConfig.httpClient.get(base(), options);
-      },
+      getSetup: lifecycle.getSetup,
       location: {
         getCountries(options) {
           return apiConfig.httpClient.get(
-            `/v1/platform/countries`,
+            "/v1/platform/countries",
             options
           );
         },
@@ -122,13 +104,13 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
         },
         list(options) {
           return apiConfig.httpClient.get(
-            `${base()}/locations`,
+            `${base}/locations`,
             options
           );
         },
         get(id, options) {
           return apiConfig.httpClient.get(
-            `${base()}/locations/${id}`,
+            `${base}/locations/${id}`,
             options
           );
         }
@@ -136,13 +118,13 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
       market: {
         list(options) {
           return apiConfig.httpClient.get(
-            `${base()}/markets`,
+            `${base}/markets`,
             options
           );
         },
         get(id, options) {
           return apiConfig.httpClient.get(
-            `${base()}/markets/${id}`,
+            `${base}/markets/${id}`,
             options
           );
         }
@@ -151,85 +133,59 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
     cms: {
       collection: {
         get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          const identifier = params.id !== void 0 ? params.id : `${store_id}:${params.key}`;
+          const identifier = params.id ?? params.key;
           return apiConfig.httpClient.get(
-            `${base(store_id)}/collections/${identifier}`,
+            `${base}/collections/${identifier}`,
             options
           );
         }
       },
       entry: {
         get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          if (!params.id) {
-            throw new Error("GetEntryParams requires id");
-          }
           return apiConfig.httpClient.get(
-            `${base(store_id)}/entries/${params.id}`,
+            `${base}/entries/${params.id}`,
             options
           );
         },
         find(params, options) {
-          const { store_id, ...queryParams } = params;
           return apiConfig.httpClient.get(
-            `${base(store_id)}/entries`,
-            {
-              ...options,
-              params: queryParams
-            }
+            `${base}/entries`,
+            { ...options, params }
           );
         }
       },
       form: {
         get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          let identifier;
-          if (params.id) {
-            identifier = params.id;
-          } else if (params.key) {
-            identifier = `${store_id}:${params.key}`;
-          } else {
-            throw new Error("GetFormParams requires id or key");
-          }
+          const identifier = params.id ?? params.key;
+          if (!identifier) throw new Error("GetFormParams requires id or key");
           return apiConfig.httpClient.get(
-            `${base(store_id)}/forms/${identifier}`,
+            `${base}/forms/${identifier}`,
             options
           );
         },
-        submit(params, options) {
-          const { store_id, form_id, ...payload } = params;
-          const target_store_id = store_id || apiConfig.storeId;
-          if (!form_id) {
-            throw new Error("SubmitFormParams requires form_id");
-          }
+        async submit(params, options) {
+          await lifecycle.ensureVisitorSession();
+          const { form_id, ...payload } = params;
+          if (!form_id) throw new Error("SubmitFormParams requires form_id");
           return apiConfig.httpClient.post(
-            `${base(target_store_id)}/forms/${form_id}/submissions`,
-            { ...payload, form_id, store_id: target_store_id },
+            `${base}/forms/${form_id}/submissions`,
+            { ...payload, form_id },
             options
           );
         }
       },
       taxonomy: {
         get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          let identifier;
-          if (params.id) {
-            identifier = params.id;
-          } else if (params.key) {
-            identifier = `${store_id}:${params.key}`;
-          } else {
-            throw new Error("GetTaxonomyParams requires id or key");
-          }
+          const identifier = params.id ?? params.key;
+          if (!identifier) throw new Error("GetTaxonomyParams requires id or key");
           return apiConfig.httpClient.get(
-            `${base(store_id)}/taxonomies/${identifier}`,
+            `${base}/taxonomies/${identifier}`,
             options
           );
         },
         getChildren(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
           return apiConfig.httpClient.get(
-            `${base(store_id)}/taxonomies/${params.id}/children`,
+            `${base}/taxonomies/${params.id}/children`,
             options
           );
         }
@@ -238,113 +194,106 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
     eshop: {
       product: {
         get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          let identifier;
-          if (params.id) {
-            identifier = params.id;
-          } else if (params.slug) {
-            identifier = `${store_id}:${apiConfig.locale}:${params.slug}`;
-          } else {
-            throw new Error("GetProductParams requires id or slug");
-          }
+          const identifier = params.id ?? params.slug;
+          if (!identifier) throw new Error("GetProductParams requires id or slug");
           return apiConfig.httpClient.get(
-            `${base(store_id)}/products/${identifier}`,
+            `${base}/products/${identifier}`,
             options
           );
         },
         find(params, options) {
-          const { store_id, ...queryParams } = params;
           return apiConfig.httpClient.get(
-            `${base(store_id)}/products`,
-            {
-              ...options,
-              params: queryParams
-            }
+            `${base}/products`,
+            { ...options, params }
           );
         }
       },
       cart: {
-        current(params = {}, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          const { store_id: _store_id, ...payload } = params;
+        async current(options) {
+          await lifecycle.ensureVisitorSession();
           return apiConfig.httpClient.post(
-            `${base(store_id)}/carts/current`,
-            {
-              ...payload,
-              store_id,
-              market: payload.market || apiConfig.market
-            },
+            `${base}/carts/current`,
+            {},
             options
           );
         },
-        get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
+        async get(params, options) {
+          await lifecycle.ensureVisitorSession();
+          const queryParams = Object.fromEntries(
+            Object.entries(
+              options?.params || {}
+            ).filter(
+              ([name]) => !["token", "cart_token"].includes(name.toLowerCase())
+            )
+          );
+          const headers = Object.fromEntries(
+            Object.entries(options?.headers || {}).filter(
+              ([name]) => name.toLowerCase() !== "x-arky-cart-token"
+            )
+          );
           return apiConfig.httpClient.get(
-            `${base(store_id)}/carts/${params.id}`,
+            `${base}/carts/${params.id}`,
             {
               ...options,
-              params: params.token ? { token: params.token } : options?.params
+              headers: {
+                ...headers,
+                ...params.token ? { "X-Arky-Cart-Token": params.token } : {}
+              },
+              params: Object.keys(queryParams).length > 0 ? queryParams : void 0
             }
           );
         },
-        update(params, options) {
-          const { store_id, items, ...payload } = params;
-          const target = store_id || apiConfig.storeId;
+        async update(params, options) {
+          await lifecycle.ensureVisitorSession();
+          const { items, ...payload } = params;
           return apiConfig.httpClient.put(
-            `${base(target)}/carts/${params.id}`,
+            `${base}/carts/${params.id}`,
             {
               ...payload,
-              store_id: target,
               ...items ? { items: sanitizePublicCheckoutItems(items) } : {}
             },
             options
           );
         },
-        addItem(params, options) {
-          const { store_id, item, ...payload } = params;
-          const target = store_id || apiConfig.storeId;
+        async addItem(params, options) {
+          await lifecycle.ensureVisitorSession();
+          const { item, ...payload } = params;
           return apiConfig.httpClient.post(
-            `${base(target)}/carts/${params.id}/items`,
-            {
-              ...payload,
-              store_id: target,
-              item: sanitizePublicCheckoutItems([item])[0]
-            },
+            `${base}/carts/${params.id}/items`,
+            { ...payload, item: sanitizePublicCheckoutItems([item])[0] },
             options
           );
         },
-        removeItem(params, options) {
-          const { store_id, ...payload } = params;
-          const target = store_id || apiConfig.storeId;
+        async removeItem(params, options) {
+          await lifecycle.ensureVisitorSession();
           return apiConfig.httpClient.post(
-            `${base(target)}/carts/${params.id}/items/remove`,
-            { ...payload, store_id: target },
+            `${base}/carts/${params.id}/items/remove`,
+            params,
             options
           );
         },
-        clear(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
+        async clear(params, options) {
+          await lifecycle.ensureVisitorSession();
           return apiConfig.httpClient.post(
-            `${base(store_id)}/carts/${params.id}/clear`,
-            { id: params.id, store_id },
+            `${base}/carts/${params.id}/clear`,
+            { id: params.id },
             options
           );
         },
-        quote(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
+        async quote(params, options) {
+          await lifecycle.ensureVisitorSession();
           return apiConfig.httpClient.post(
-            `${base(store_id)}/carts/${params.id}/quote`,
-            { id: params.id, store_id },
+            `${base}/carts/${params.id}/quote`,
+            { id: params.id },
             options
           );
         },
-        checkout(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
+        async checkout(params, options) {
+          await lifecycle.ensureVisitorSession();
           return apiConfig.httpClient.post(
-            `${base(store_id)}/carts/${params.id}/checkout`,
+            `${base}/carts/${params.id}/checkout`,
             {
               id: params.id,
-              store_id,
               payment_method_key: params.payment_method_key,
               confirmation_token_id: params.confirmation_token_id,
               return_url: params.return_url
@@ -354,115 +303,85 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
         }
       },
       order: {
-        get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
+        async get(params, options) {
+          await lifecycle.ensureVisitorSession();
           return apiConfig.httpClient.get(
-            `${base(store_id)}/orders/${params.id}`,
+            `${base}/orders/${params.id}`,
             options
           );
         },
-        find(params, options) {
-          const { store_id, ...queryParams } = params;
+        async find(params, options) {
+          await lifecycle.ensureVisitorSession();
           return apiConfig.httpClient.get(
-            `${base(store_id)}/orders`,
-            {
-              ...options,
-              params: queryParams
-            }
+            `${base}/orders`,
+            { ...options, params }
           );
         },
-        downloadDigitalAccess(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
+        async downloadDigitalAccess(params, options) {
+          await lifecycle.ensureVisitorSession();
           return apiConfig.httpClient.post(
-            `${base(store_id)}/orders/${params.order_id}/digital-access/${params.grant_id}/download`,
+            `${base}/orders/${params.order_id}/digital-access/${params.grant_id}/download`,
             {},
             options
           );
         },
-        findDigitalAccess(params, options) {
-          const { order_id, store_id, ...queryParams } = params;
+        async findDigitalAccess(params, options) {
+          await lifecycle.ensureVisitorSession();
+          const { order_id, ...queryParams } = params;
           return apiConfig.httpClient.get(
-            `${base(store_id)}/orders/${order_id}/digital-access`,
+            `${base}/orders/${order_id}/digital-access`,
             { ...options, params: queryParams }
           );
         },
-        getDigitalAccess(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
+        async getDigitalAccess(params, options) {
+          await lifecycle.ensureVisitorSession();
           return apiConfig.httpClient.get(
-            `${base(store_id)}/orders/${params.order_id}/digital-access/${params.grant_id}`,
+            `${base}/orders/${params.order_id}/digital-access/${params.grant_id}`,
             options
           );
         }
       },
       service: {
         get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          let identifier;
-          if (params.id) {
-            identifier = params.id;
-          } else if (params.slug) {
-            identifier = `${store_id}:${apiConfig.locale}:${params.slug}`;
-          } else {
-            throw new Error("GetServiceParams requires id or slug");
-          }
+          const identifier = params.id ?? params.slug;
+          if (!identifier) throw new Error("GetServiceParams requires id or slug");
           return apiConfig.httpClient.get(
-            `${base(store_id)}/services/${identifier}`,
+            `${base}/services/${identifier}`,
             options
           );
         },
         find(params, options) {
-          const { store_id, ...queryParams } = params;
           return apiConfig.httpClient.get(
-            `${base(store_id)}/services`,
-            {
-              ...options,
-              params: queryParams
-            }
+            `${base}/services`,
+            { ...options, params }
           );
         },
         findProviders(params, options) {
-          const { store_id, ...queryParams } = params;
           return apiConfig.httpClient.get(
-            `${base(store_id)}/service-providers`,
-            {
-              ...options,
-              params: queryParams
-            }
+            `${base}/service-providers`,
+            { ...options, params }
           );
         },
         getAvailability(params, options) {
-          const { store_id, ...queryParams } = params;
-          const target_store_id = store_id || apiConfig.storeId;
           return apiConfig.httpClient.get(
-            `${base(target_store_id)}/services/availability`,
-            { ...options, params: queryParams }
+            `${base}/services/availability`,
+            { ...options, params }
           );
         }
       },
       provider: {
         get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          let identifier;
-          if (params.id) {
-            identifier = params.id;
-          } else if (params.slug) {
-            identifier = `${store_id}:${apiConfig.locale}:${params.slug}`;
-          } else {
-            throw new Error("GetProviderParams requires id or slug");
-          }
+          const identifier = params.id ?? params.slug;
+          if (!identifier) throw new Error("GetProviderParams requires id or slug");
           return apiConfig.httpClient.get(
-            `${base(store_id)}/providers/${identifier}`,
+            `${base}/providers/${identifier}`,
             options
           );
         },
         find(params, options) {
-          const { store_id, ...queryParams } = params;
           return apiConfig.httpClient.get(
-            `${base(store_id)}/providers`,
-            {
-              ...options,
-              params: queryParams
-            }
+            `${base}/providers`,
+            { ...options, params }
           );
         }
       }
@@ -476,36 +395,23 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
           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, challenge_id: params.challenge_id, code: params.code },
+            `${base}/account/verify`,
+            params,
             options
           );
-          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.token,
-                contact: result.contact
-              } : {
-                access_token: result.token.token,
-                contact: result.contact,
-                store: identifiedStore,
-                market: pending?.market || null
-              }
-            );
-            pendingVerifications.delete(params.challenge_id);
+          if (result.token?.token) {
+            updateContactSession(() => ({
+              sessionToken: result.token.token,
+              contact: result.contact
+            }));
           }
           return result;
         },
         async logout(options) {
-          const store_id = apiConfig.storeId;
           try {
             await apiConfig.httpClient.post(
-              `${base(store_id)}/account/logout`,
+              `${base}/account/logout`,
               {},
               options
             );
@@ -515,110 +421,74 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
         },
         getMe(options) {
           return apiConfig.httpClient.get(
-            `${base()}/account/me`,
+            `${base}/account/me`,
             options
           );
         }
       },
       contactList: {
         get(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
           return apiConfig.httpClient.get(
-            `${base(store_id)}/contact-lists/${params.id}`,
+            `${base}/contact-lists/${params.id}`,
             options
           );
         },
-        find(params, options) {
-          const { store_id, ...queryParams } = params || {};
+        find(params = {}, options) {
           return apiConfig.httpClient.get(
-            `${base(store_id)}/contact-lists`,
-            {
-              ...options,
-              params: queryParams
-            }
+            `${base}/contact-lists`,
+            { ...options, params }
           );
         },
         plans: {
           find(params, options) {
-            const { store_id, contact_list_id, ...queryParams } = params;
+            const { contact_list_id, ...queryParams } = params;
             return apiConfig.httpClient.get(
-              `${base(store_id)}/contact-lists/${contact_list_id}/plans`,
+              `${base}/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`, {
+          async find(params = {}, options) {
+            await lifecycle.ensureVisitorSession();
+            return apiConfig.httpClient.get(`${base}/contact-lists/memberships`, {
               ...options,
-              params: queryParams
+              params
             });
           }
         },
-        subscribe(params, options) {
-          const { store_id, id, ...payload } = params;
+        async subscribe(params, options) {
+          await lifecycle.ensureVisitorSession();
+          const { id, ...payload } = params;
           return apiConfig.httpClient.post(
-            `${base(store_id)}/contact-lists/${id}/subscribe`,
+            `${base}/contact-lists/${id}/subscribe`,
             payload,
             options
           );
         },
-        checkAccess(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
+        async checkAccess(params, options) {
+          await lifecycle.ensureVisitorSession();
           return apiConfig.httpClient.get(
-            `${base(store_id)}/contact-lists/${params.id}/access`,
-            options
-          );
-        },
-        checkContentAccess(params, options) {
-          const { store_id, ...payload } = params;
-          return apiConfig.httpClient.post(
-            `${base(store_id)}/contact-lists/access`,
-            payload,
-            options
-          );
-        },
-        manage(token, options) {
-          return apiConfig.httpClient.post(
-            `${base()}/contact-lists/manage`,
-            { token },
+            `${base}/contact-lists/${params.id}/access`,
             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) {
+        async checkContentAccess(params, options) {
+          await lifecycle.ensureVisitorSession();
           return apiConfig.httpClient.post(
-            `${base()}/contact-lists/confirm`,
-            { token },
+            `${base}/contact-lists/access`,
+            params,
             options
           );
         }
       }
     },
-    action: createActionApi(apiConfig),
+    action: createActionApi(apiConfig, lifecycle),
     experiments: {
-      use(params, options) {
-        const store_id = params.store_id || apiConfig.storeId;
+      async use(params, options) {
+        await lifecycle.ensureVisitorSession();
         return apiConfig.httpClient.post(
-          `${base(store_id)}/experiments/use`,
+          `${base}/experiments/use`,
           { key: params.key },
           options
         );
@@ -778,6 +648,15 @@ function requestError(name, message, details = {}) {
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
+function omitStorefrontRouting(value) {
+  if (!isRecord(value) || Array.isArray(value)) return value;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return value;
+  const result = { ...value };
+  delete result.store_id;
+  delete result.market;
+  return result;
+}
 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");
 }
@@ -853,10 +732,25 @@ function createHttpClient(cfg) {
     if (!retried && options?.transformRequest) {
       body = options.transformRequest(body);
     }
+    if (cfg.storefrontMode) {
+      body = omitStorefrontRouting(body);
+    }
+    const forcedHeaders = typeof cfg.forcedHeaders === "function" ? cfg.forcedHeaders() : cfg.forcedHeaders || {};
+    const callerHeaders = { ...options?.headers || {} };
+    const protectedHeaderNames = new Set(
+      Object.keys(forcedHeaders).map((name) => name.toLowerCase())
+    );
+    if (cfg.storefrontMode) protectedHeaderNames.add("authorization");
+    for (const name of Object.keys(callerHeaders)) {
+      if (protectedHeaderNames.has(name.toLowerCase())) {
+        delete callerHeaders[name];
+      }
+    }
     const headers = {
       Accept: "application/json",
       "Content-Type": "application/json",
-      ...options?.headers || {}
+      ...callerHeaders,
+      ...forcedHeaders
     };
     let tokens = authStorage.getTokens();
     const nowSec = Date.now() / 1e3;
@@ -867,7 +761,8 @@ function createHttpClient(cfg) {
     if (tokens?.access_token) {
       headers["Authorization"] = `Bearer ${tokens.access_token}`;
     }
-    const finalPath = options?.params ? path + buildQueryString(options.params) : path;
+    const requestParams = cfg.storefrontMode ? omitStorefrontRouting(options?.params) : options?.params;
+    const finalPath = requestParams ? path + buildQueryString(requestParams) : path;
     const fetchOptions = {
       method,
       headers,
@@ -898,8 +793,19 @@ function createHttpClient(cfg) {
       throw err;
     }
     if (res.status === 401 && !retried) {
-      await ensureFreshToken();
-      return request(method, path, body, options, true);
+      if (cfg.onUnauthorized) {
+        const recovered = await cfg.onUnauthorized({
+          hadAuthorization: Boolean(tokens?.access_token),
+          authorizationToken: tokens?.access_token || null,
+          path
+        });
+        if (recovered) {
+          return request(method, path, body, options, true);
+        }
+      } else {
+        await ensureFreshToken();
+        return request(method, path, body, options, true);
+      }
     }
     try {
       const contentLength = res.headers.get("content-length");
@@ -1115,6 +1021,14 @@ var createStoreApi = (apiConfig, _updateSession) => {
         params
       });
     },
+    async regeneratePublishableKey(params = {}, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${store_id}/publishable-key/regenerate`,
+        {},
+        options
+      );
+    },
     async getSubscriptionPlans(_params, options) {
       return apiConfig.httpClient.get("/v1/stores/plans", options);
     },
@@ -2013,7 +1927,10 @@ var createMarketApi = (apiConfig) => {
     async delete(params, options) {
       return apiConfig.httpClient.delete(
         `/v1/stores/${apiConfig.storeId}/markets/${params.id}`,
-        options
+        {
+          ...options,
+          params: params.replacement_default_market_id ? { replacement_default_market_id: params.replacement_default_market_id } : options?.params
+        }
       );
     }
   };
@@ -2639,32 +2556,38 @@ function storefrontSupportOptions(supportToken, options) {
     }
   };
 }
-function createStorefrontSupportApi(config) {
+function createStorefrontSupportApi(config, ensureVisitorSession) {
   const { httpClient } = config;
   return {
     async startConversation(params = {}, opts) {
-      const storeId = config.storeId;
+      await ensureVisitorSession();
       return httpClient.post(
-        `/v1/storefront/${storeId}/support/conversations`,
-        { ...params, store_id: storeId },
+        "/v1/storefront/support/conversations",
+        params,
         opts
       );
     },
     async sendMessage(params, opts) {
+      await ensureVisitorSession();
       const { support_token, ...request } = params;
-      const storeId = config.storeId;
       return httpClient.post(
-        `/v1/storefront/${storeId}/support/conversations/${request.conversation_id}/messages`,
-        { ...request, store_id: storeId },
+        `/v1/storefront/support/conversations/${request.conversation_id}/messages`,
+        request,
         storefrontSupportOptions(support_token, opts)
       );
     },
     async getConversation(params, opts) {
+      await ensureVisitorSession();
       const { support_token, ...request } = params;
-      const storeId = config.storeId;
-      const qs = supportConversationQuery({ ...request, store_id: storeId });
+      const query = new URLSearchParams();
+      if (request.message_limit) query.set("message_limit", String(request.message_limit));
+      if (typeof request.after_created_at === "number") {
+        query.set("after_created_at", String(request.after_created_at));
+      }
+      if (request.after_id) query.set("after_id", request.after_id);
+      const suffix = query.size ? `?${query}` : "";
       return httpClient.get(
-        `/v1/storefront/${storeId}/support/conversations/${request.conversation_id}?${qs}`,
+        `/v1/storefront/support/conversations/${request.conversation_id}${suffix}`,
         storefrontSupportOptions(support_token, opts)
       );
     }
@@ -4115,138 +4038,1929 @@ function getFirstAvailableFCId(variant, quantity = 1) {
   return inv?.location_id;
 }
 
-// src/index.ts
-var SDK_VERSION = "0.9.20";
-var SUPPORTED_FRAMEWORKS = [
-  "astro",
-  "react",
-  "vue",
-  "svelte",
-  "vanilla"
-];
-function createUtilitySurface(apiConfig) {
-  return {
-    getImageUrl: (imageBlock, isBlock2 = true) => getImageUrl(imageBlock, isBlock2),
-    getBlockValue,
-    getBlockTextValue,
-    getBlockContentValue,
-    getBlockValues,
-    getBlockLabel,
-    getBlockObjectValues,
-    getBlockFromArray,
-    formatBlockValue,
-    prepareBlocksForSubmission,
-    extractBlockValues,
-    formatPrice: (prices) => formatPrice(prices, apiConfig.market),
-    getPriceAmount: (prices) => getPriceAmount(prices, apiConfig.market),
-    formatPayment,
-    formatMinor,
-    getCurrencySymbol,
-    getCurrencyName,
-    validatePhoneNumber,
-    tzGroups,
-    findTimeZone,
-    slugify,
-    humanize,
-    categorify,
-    formatDate,
-    getSvgContentForAstro,
-    fetchSvgContent,
-    injectSvgIntoElement,
-    isValidKey,
-    validateKey,
-    toKey,
-    nameToKey,
-    getAvailableStock,
-    getReservedStock,
-    hasStock,
-    getInventoryAt,
-    getFirstAvailableFCId
-  };
-}
-var ADMIN_STORAGE_KEY = "arky_admin_session";
-function readAdminSession() {
-  if (typeof window === "undefined") return null;
-  try {
-    const raw = localStorage.getItem(ADMIN_STORAGE_KEY);
-    return raw ? JSON.parse(raw) : null;
-  } catch {
-    return null;
-  }
+// src/payments/stripe.ts
+async function defaultStripeLoader(publishableKey, options) {
+  const { loadStripe } = await import('@stripe/stripe-js');
+  return loadStripe(publishableKey, options);
 }
-function writeAdminSession(s) {
-  if (typeof window === "undefined") return;
-  if (s) {
-    localStorage.setItem(ADMIN_STORAGE_KEY, JSON.stringify(s));
-  } else {
-    localStorage.removeItem(ADMIN_STORAGE_KEY);
-  }
+function normalizeCurrency(currency) {
+  return currency.trim().toLowerCase();
 }
-function createAdmin(config) {
-  const locale = config.locale || "en";
-  const listeners = /* @__PURE__ */ new Set();
-  function toPublic(s) {
-    return s ? { email: s.email } : null;
-  }
-  function emit() {
-    const pub = toPublic(readAdminSession());
-    for (const l of listeners) {
-      Promise.resolve().then(() => l(pub)).catch(() => {
+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", {
+    layout: "tabs"
+  });
+  return {
+    mount(target) {
+      if (!paymentElement) {
+        paymentElement = elements.create("payment", { layout: "tabs" });
+      }
+      paymentElement.mount(target);
+    },
+    update(input) {
+      elements.update({
+        ...input.amount !== void 0 ? { amount: input.amount } : {},
+        ...input.currency ? { currency: normalizeCurrency(input.currency) } : {}
       });
-    }
-  }
-  const updateSession = (updater) => {
-    if (config.apiToken) return;
-    const prev = readAdminSession();
-    const next = updater(prev);
-    writeAdminSession(next);
-    emit();
-  };
-  const authStorage = config.apiToken ? {
-    getTokens: () => ({ access_token: config.apiToken }),
-    onTokensRefreshed: () => {
     },
-    onForcedLogout: () => {
-    }
-  } : {
-    getTokens() {
-      const s = readAdminSession();
-      if (!s) return null;
+    async createConfirmationToken(options = {}) {
+      const submitResult = await elements.submit();
+      if (submitResult.error) {
+        throw new Error(submitResult.error.message || "Payment details are incomplete");
+      }
+      const tokenInput = {
+        elements,
+        params: {
+          ...options.return_url ? { return_url: options.return_url } : {},
+          ...options.billing_details ? { payment_method_data: { billing_details: options.billing_details } } : {}
+        }
+      };
+      const result = await stripe.createConfirmationToken(tokenInput);
+      if (result.error) {
+        throw new Error(result.error.message || "Payment confirmation token failed");
+      }
+      if (!result.confirmationToken?.id) {
+        throw new Error("Stripe did not return a confirmation token");
+      }
       return {
-        access_token: s.access_token,
-        refresh_token: s.refresh_token,
-        access_expires_at: s.access_expires_at
+        confirmation_token_id: result.confirmationToken.id,
+        return_url: options.return_url
       };
     },
-    onTokensRefreshed(tokens) {
-      updateSession(
-        (prev) => prev ? {
-          ...prev,
-          access_token: tokens.access_token,
-          refresh_token: tokens.refresh_token ?? prev.refresh_token,
-          access_expires_at: tokens.access_expires_at ?? prev.access_expires_at
-        } : null
-      );
+    async handleNextAction(clientSecret) {
+      const result = await stripe.handleNextAction({ clientSecret });
+      if (result.error) {
+        throw new Error(result.error.message || "Payment authentication failed");
+      }
     },
-    onForcedLogout() {
-      updateSession(() => null);
+    destroy() {
+      paymentElement?.destroy();
+      paymentElement = null;
     }
   };
-  const httpClient = createHttpClient({
-    baseUrl: config.baseUrl,
-    storeId: config.storeId,
-    refreshPath: config.refreshPath,
-    navigate: config.navigate,
-    loginFallbackPath: config.loginFallbackPath,
-    authStorage
+}
+function createElements(stripe, config) {
+  return stripe.elements({
+    mode: "payment",
+    amount: config.amount,
+    currency: normalizeCurrency(config.currency),
+    paymentMethodCreation: "manual",
+    ...config.appearance ? { appearance: config.appearance } : {},
+    ...config.setupFutureUsage ? { setupFutureUsage: config.setupFutureUsage } : {}
   });
-  const apiConfig = {
-    httpClient,
-    storeId: config.storeId,
-    baseUrl: config.baseUrl,
-    market: config.market,
-    locale,
-    authStorage
+}
+
+// src/storefrontStore/utils.ts
+function readErrorMessage(error, fallback) {
+  if (error instanceof Error && error.message) return error.message;
+  if (typeof error === "string" && error.length > 0) return error;
+  return fallback;
+}
+function createId(prefix) {
+  const cryptoValue = globalThis.crypto;
+  if (cryptoValue && "randomUUID" in cryptoValue) return cryptoValue.randomUUID();
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+}
+function firstLocalized(value, locale) {
+  if (typeof value === "string") return value;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return "";
+  const record = value;
+  const localeValue = record[locale];
+  if (typeof localeValue === "string") return localeValue;
+  const englishValue = record.en;
+  if (typeof englishValue === "string") return englishValue;
+  for (const entry of Object.values(record)) {
+    if (typeof entry === "string") return entry;
+  }
+  return "";
+}
+function findBlock2(blocks, keys) {
+  return (blocks || []).find((block) => keys.includes(block.key)) || null;
+}
+function blockText(blocks, keys, locale) {
+  const block = findBlock2(blocks, keys);
+  if (!block) return "";
+  return firstLocalized(block.value, locale);
+}
+function productName(product, locale) {
+  return blockText(product.blocks, ["name", "title"], locale) || product.key || product.id;
+}
+function serviceName(service, locale) {
+  return blockText(service.blocks, ["name", "title"], locale) || service.key || service.id;
+}
+function providerName(provider, locale) {
+  return blockText(provider.blocks, ["name", "title"], locale) || provider.key || provider.id;
+}
+function entitySlug(entity, locale) {
+  return entity.slug?.[locale] || entity.slug?.en || Object.values(entity.slug || {})[0] || entity.id;
+}
+function priceForMarket(prices, market, 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);
+  if (Number.isFinite(fromUtility)) return fromUtility;
+  const stock = (variant.inventory || []).reduce((total, row) => total + (row.available || 0), 0);
+  return stock > 0 ? stock : void 0;
+}
+function locationToAddress(location) {
+  return {
+    country: location.country || "",
+    state: location.state || "",
+    city: location.city || "",
+    postal_code: location.postal_code || "",
+    name: "",
+    street1: "",
+    street2: null
+  };
+}
+function createFormEntry(formId, fields) {
+  if (!formId.trim()) throw new Error("formId is required");
+  return { form_id: formId, fields };
+}
+function toProductCheckoutItems(items) {
+  return items.map((item) => ({
+    type: "product",
+    id: item.id,
+    product_id: item.product_id,
+    variant_id: item.variant_id,
+    quantity: item.quantity
+  }));
+}
+function toServiceCheckoutItems(items) {
+  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;
+    }
+    if (isEmptyOptionalValue(field, value)) continue;
+    fields.push(buildFormField(field, value));
+  }
+  return fields;
+}
+function createFormEntryFromValues(form, values) {
+  return createFormEntry(form.id, buildFormFields(form.schema, values));
+}
+function getFormBlockType(field) {
+  if (field.key === "email") return "email";
+  if (field.key === "phone") return "phone";
+  if (field.type === "geo_location") return "address";
+  return field.type;
+}
+function getFormBlockValue(field) {
+  if (field.type === "boolean") return false;
+  if (field.type === "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,
+    type: getFormBlockType(field),
+    properties: {
+      isRequired: field.required,
+      minValues: field.required ? 1 : 0,
+      min,
+      max,
+      options,
+      pattern: field.key === "email" ? "^.+@.+\\..+$" : field.key === "phone" ? "^.{6,20}$" : void 0
+    },
+    value: getFormBlockValue(field)
+  };
+}
+function formatServiceTime(ts, tz) {
+  return new Date(ts * 1e3).toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit",
+    timeZone: tz
+  });
+}
+function formatServiceSlotTime(from, to, tz) {
+  return `${formatServiceTime(from, tz)} - ${formatServiceTime(to, tz)}`;
+}
+function getSlotsForDate(availability, dateStr, providerId) {
+  if (!availability) return [];
+  const slots = [];
+  for (const provider of availability.providers) {
+    if (providerId && provider.provider_id !== providerId) continue;
+    const day = provider.days.find((candidate) => candidate.date === dateStr);
+    if (!day) continue;
+    for (const slot of day.slots) {
+      if (slot.spots > 0) slots.push({ from: slot.from, to: slot.to, providerId: provider.provider_id });
+    }
+  }
+  return slots.sort((a, b) => a.from - b.from);
+}
+function hasAvailableSlotsForDate(availability, dateStr, providerId) {
+  if (!availability) return false;
+  return availability.providers.some((provider) => {
+    if (providerId && provider.provider_id !== providerId) return false;
+    const day = provider.days.find((candidate) => candidate.date === dateStr);
+    return !!day?.slots.some((slot) => slot.spots > 0);
+  });
+}
+var SERVICE_WEEKDAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+function createServiceInitialState() {
+  return {
+    service: null,
+    availability: null,
+    providers: [],
+    serviceProviders: [],
+    selectedProviderId: null,
+    currentMonth: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), 1),
+    calendar: [],
+    selectedDate: null,
+    slots: [],
+    selectedSlot: null,
+    timezone: typeof window !== "undefined" ? Intl.DateTimeFormat().resolvedOptions().timeZone : "UTC",
+    tzGroups: {},
+    loading: false,
+    weekdays: SERVICE_WEEKDAYS,
+    quote: null,
+    fetchingQuote: false,
+    quoteError: null,
+    currency: null,
+    dateTimeConfirmed: false,
+    availablePaymentMethods: [],
+    cartId: null,
+    promoCode: null
+  };
+}
+function normalizeTimezoneGroups(groups) {
+  const normalized = {};
+  for (const group of groups) {
+    normalized[group.label] = group.zones.map((zone) => ({
+      zone: zone.value,
+      name: zone.label
+    }));
+  }
+  return normalized;
+}
+
+// src/storefrontStore/initialize.ts
+function firstFiniteNumber(...values) {
+  return values.find((value) => typeof value === "number" && Number.isFinite(value));
+}
+function initializeStoreCore(publishableKey, config, scopedClient) {
+  const client = scopedClient || createStorefront(publishableKey, config);
+  const session = nanostores.atom(client.session);
+  const setup = nanostores.atom(null);
+  const locale = nanostores.atom(config.locale || client.getLocale());
+  const market_key = nanostores.atom(config.market || client.getMarket());
+  const market = nanostores.computed([setup, market_key], (setupValue, marketKey) => {
+    const resolvedKey = marketKey || setupValue?.markets.default;
+    return setupValue?.markets.available.find((candidate) => candidate.key === resolvedKey) || null;
+  });
+  const currency = nanostores.computed(market, (value) => value?.currency || null);
+  const allowed_payment_methods = nanostores.computed(market, (value) => value?.payment_methods || []);
+  const payment_config = nanostores.computed([setup, market], (setupValue, marketValue) => {
+    const methods = marketValue?.payment_methods || [];
+    const hasCreditCard = methods.some((method) => method.type === "credit_card");
+    return {
+      provider: setupValue?.payment || null,
+      enabled: hasCreditCard && Boolean(setupValue?.readiness.payment)
+    };
+  });
+  const cart = nanostores.atom(null);
+  const product_items = nanostores.atom([]);
+  const service_items = nanostores.atom([]);
+  const quote = nanostores.atom(null);
+  const promo_code = nanostores.atom(null);
+  const last_order = nanostores.atom(null);
+  const payment_controller = nanostores.atom(null);
+  const payment_ready = nanostores.computed(payment_controller, (value) => value !== null);
+  const cart_status = nanostores.map({
+    loading: false,
+    syncing: false,
+    fetching_quote: false,
+    processing_checkout: false,
+    error: null,
+    quote_error: null,
+    selected_shipping_method_id: null,
+    user_token: null
+  });
+  function rawProductItemCount(value) {
+    return (value?.items || []).reduce((total, item) => {
+      if (item.type !== "product") return total;
+      return total + (item.quantity || 0);
+    }, 0);
+  }
+  function rawServiceItemCount(value) {
+    return (value?.items || []).reduce((total, item) => {
+      if (item.type !== "service") return total;
+      return total + Math.max(1, item.slots?.length || 0);
+    }, 0);
+  }
+  const product_item_count = nanostores.computed(
+    [cart, product_items],
+    (cartValue, items) => Math.max(
+      rawProductItemCount(cartValue),
+      items.reduce((total, item) => total + (item.quantity || 0), 0)
+    )
+  );
+  const service_item_count = nanostores.computed(
+    [cart, service_items],
+    (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],
+    (cartValue, products, services) => Math.max(cartValue?.item_count || 0, products + services)
+  );
+  const snapshot = nanostores.computed([cart, product_items, service_items, item_count], (cartValue, products, services, count) => ({
+    cart: cartValue,
+    product_items: products,
+    service_items: services,
+    item_count: count
+  }));
+  let cartWriteRevision = 0;
+  let sessionRequest = null;
+  let cartRequest = null;
+  function nextCartWriteRevision() {
+    cartWriteRevision += 1;
+    return cartWriteRevision;
+  }
+  const cms_state = nanostores.map({
+    entries: {},
+    forms: {},
+    loading: false,
+    error: null
+  });
+  const eshop_state = nanostores.map({
+    products: [],
+    services: [],
+    providers: [],
+    product_cursor: null,
+    service_cursor: null,
+    provider_cursor: null,
+    availability: null,
+    loading_products: false,
+    loading_services: false,
+    loading_providers: false,
+    loading_availability: false,
+    error: null
+  });
+  const service_state = nanostores.map(createServiceInitialState());
+  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));
+  market.subscribe((value) => {
+    const methods = value?.payment_methods || [];
+    if (methods.length && service_state.get().availablePaymentMethods.length === 0) {
+      service_state.setKey("availablePaymentMethods", methods);
+    }
+  });
+  function currentMarketKey() {
+    return market_key.get() || client.getMarket() || setup.get()?.markets.default || "";
+  }
+  function currentLocale() {
+    return locale.get() || client.getLocale() || setup.get()?.languages.default || "en";
+  }
+  function currentStripePublishableKey() {
+    const provider = payment_config.get()?.provider;
+    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, 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) {
+      current.destroy();
+    }
+    payment_controller.set(controller);
+    return controller;
+  }
+  function destroyPaymentController() {
+    setPaymentController(null);
+  }
+  async function loadSetup() {
+    const current = setup.get();
+    if (current) return current;
+    const result = await client.getSetup();
+    setup.set(result);
+    if (!market_key.get() && result.markets.default) {
+      market_key.set(result.markets.default);
+    }
+    if (!locale.get() && result.languages.default) {
+      locale.set(result.languages.default);
+    }
+    return result;
+  }
+  async function mountPayment(target, options = {}) {
+    await loadSetup();
+    const publishableKey2 = currentStripePublishableKey();
+    if (!publishableKey2) {
+      throw new Error("Stripe card payment is not configured for this Store");
+    }
+    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: publishableKey2,
+      connectedAccountId: currentStripeConnectedAccountId() || void 0,
+      amount,
+      currency: paymentCurrency,
+      ...options.appearance ? { appearance: options.appearance } : {},
+      ...options.setupFutureUsage ? { setupFutureUsage: options.setupFutureUsage } : {}
+    });
+    controller.mount(target);
+    setPaymentController(controller);
+    return controller;
+  }
+  function updatePaymentController(input) {
+    payment_controller.get()?.update(input);
+  }
+  async function ensureSession() {
+    const current = session.get();
+    if (client.isAuthenticated) return current;
+    if (!sessionRequest) {
+      sessionRequest = identify().finally(() => {
+        sessionRequest = null;
+      });
+    }
+    return sessionRequest;
+  }
+  async function identify(params = {}) {
+    if (params.market) setMarket(params.market);
+    const result = await client.identify({
+      ...params,
+      market: params.market || currentMarketKey()
+    });
+    session.set({
+      contact: result.contact
+    });
+    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) {
+    const next = key.trim();
+    const current = currentMarketKey();
+    if (next && current && next !== current && (cart.get()?.item_count || item_count.get()) > 0) {
+      throw Object.assign(
+        new Error("Market cannot change while the cart contains items"),
+        { code: "CART_MARKET_LOCKED" }
+      );
+    }
+    market_key.set(next);
+    client.setMarket(next);
+  }
+  function setLocale(value) {
+    locale.set(value);
+    client.setLocale(value);
+  }
+  function setContext(context) {
+    if (context.market !== void 0) setMarket(context.market);
+    if (context.locale !== void 0) setLocale(context.locale);
+  }
+  async function ensureCart() {
+    if (cartRequest) return cartRequest;
+    cart_status.setKey("loading", true);
+    cart_status.setKey("error", null);
+    const refreshRevision = cartWriteRevision;
+    cartRequest = (async () => {
+      await ensureSession();
+      const response = await client.eshop.cart.current();
+      await applyCartResponse(response, { ifRevision: refreshRevision });
+      return response;
+    })();
+    try {
+      return await cartRequest;
+    } catch (error) {
+      cart_status.setKey("error", readErrorMessage(error, "Failed to load cart."));
+      throw error;
+    } finally {
+      cartRequest = null;
+      cart_status.setKey("loading", false);
+    }
+  }
+  async function buildProductCartItem(item, source, productHint) {
+    try {
+      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) {
+        cart_status.setKey(
+          "error",
+          `Cart product ${item.product_id} references unavailable variant ${item.variant_id}.`
+        );
+        return null;
+      }
+      return {
+        id: item.id || createId("product"),
+        product_id: product.id,
+        variant_id: variant.id,
+        product_name: productName(product, currentLocale()),
+        product_slug: entitySlug(product, currentLocale()),
+        variant_attributes: variant.attributes,
+        requires_shipping: variant.requires_shipping !== false,
+        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)
+      };
+    } catch (error) {
+      cart_status.setKey(
+        "error",
+        readErrorMessage(
+          error,
+          `Failed to load cart product ${item.product_id}.`
+        )
+      );
+      return null;
+    }
+  }
+  async function buildServiceCartItems(items) {
+    const rows = [];
+    for (const item of items) {
+      let service = null;
+      let provider = null;
+      try {
+        service = await client.eshop.service.get({ id: item.service_id });
+      } catch {
+      }
+      try {
+        provider = await client.eshop.provider.get({ id: item.provider_id });
+      } catch {
+      }
+      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;
+  }
+  async function applyCartResponse(response, options = {}) {
+    if (options.ifRevision !== void 0 && options.ifRevision !== cartWriteRevision) {
+      return cart.get() || response;
+    }
+    cart.set(response);
+    cart_status.setKey("user_token", response.token || null);
+    cart_status.setKey("selected_shipping_method_id", response.shipping_method_id || null);
+    promo_code.set(response.promo_code || null);
+    quote.set(response.quote_snapshot || null);
+    const items = response.items || [];
+    if (items.length > 0) await loadSetup();
+    const products = await Promise.all(
+      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;
+  }
+  function checkoutItems(input = {}) {
+    return [
+      ...toProductCheckoutItems(input.product_items || product_items.get()),
+      ...toServiceCheckoutItems(input.service_items || service_items.get())
+    ];
+  }
+  async function syncCart(input = {}, writeRevision = nextCartWriteRevision()) {
+    cart_status.setKey("syncing", true);
+    cart_status.setKey("error", null);
+    try {
+      const current = cart.get() || await ensureCart();
+      const response = await client.eshop.cart.update({
+        id: current.id,
+        items: checkoutItems(input),
+        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
+      });
+      await applyCartResponse(response, { ifRevision: writeRevision });
+      return response;
+    } catch (error) {
+      cart_status.setKey("error", readErrorMessage(error, "Failed to sync cart."));
+      throw error;
+    } finally {
+      cart_status.setKey("syncing", false);
+    }
+  }
+  async function addProduct(product, variant, quantity = 1) {
+    cart_status.setKey("error", null);
+    const writeRevision = nextCartWriteRevision();
+    try {
+      const current = cart.get() || await ensureCart();
+      const response = await client.eshop.cart.addItem({
+        id: current.id,
+        item: {
+          type: "product",
+          product_id: product.id,
+          variant_id: variant.id,
+          quantity
+        }
+      });
+      await applyCartResponse(response, { ifRevision: writeRevision, productHint: product });
+      return response;
+    } catch (error) {
+      cart_status.setKey("error", readErrorMessage(error, "Failed to add product to cart."));
+      throw error;
+    }
+  }
+  async function setProductQuantity(itemId, quantity) {
+    const writeRevision = nextCartWriteRevision();
+    const next = product_items.get().map((item) => {
+      if (item.id !== itemId) return item;
+      const bounded = item.max_stock ? Math.min(Math.max(1, quantity), item.max_stock) : Math.max(1, quantity);
+      return { ...item, quantity: bounded };
+    });
+    product_items.set(next);
+    return syncCart({ product_items: next }, writeRevision);
+  }
+  async function removeProduct(itemId) {
+    const writeRevision = nextCartWriteRevision();
+    const item = product_items.get().find((candidate) => candidate.id === itemId);
+    product_items.set(product_items.get().filter((candidate) => candidate.id !== itemId));
+    const current = cart.get();
+    if (!current || !item) return null;
+    const response = await client.eshop.cart.removeItem({
+      id: current.id,
+      item_id: item.id
+    });
+    await applyCartResponse(response, { ifRevision: writeRevision });
+    return response;
+  }
+  async function addServiceItem(item) {
+    const writeRevision = nextCartWriteRevision();
+    const next = [...service_items.get(), item];
+    service_items.set(next);
+    return syncCart({ service_items: next }, writeRevision);
+  }
+  async function removeServiceItem(itemId) {
+    const writeRevision = nextCartWriteRevision();
+    const next = service_items.get().filter((item) => item.id !== itemId);
+    service_items.set(next);
+    return syncCart({ service_items: next }, writeRevision);
+  }
+  async function clearCart() {
+    const writeRevision = nextCartWriteRevision();
+    const current = cart.get();
+    clearLocalCart();
+    if (!current) return null;
+    const response = await client.eshop.cart.clear({ id: current.id });
+    await applyCartResponse(response, { ifRevision: writeRevision });
+    return response;
+  }
+  function clearLocalCart() {
+    product_items.set([]);
+    service_items.set([]);
+    cart.set(null);
+    quote.set(null);
+    promo_code.set(null);
+    cart_status.setKey("selected_shipping_method_id", null);
+  }
+  async function fetchQuote(input = {}) {
+    if (checkoutItems(input).length === 0) {
+      quote.set(null);
+      return null;
+    }
+    cart_status.setKey("fetching_quote", true);
+    cart_status.setKey("quote_error", null);
+    try {
+      const current = await syncCart(input);
+      const response = await client.eshop.cart.quote({ id: current.id });
+      quote.set(response);
+      return response;
+    } catch (error) {
+      quote.set(null);
+      cart_status.setKey("quote_error", readErrorMessage(error, "Failed to fetch quote."));
+      throw error;
+    } finally {
+      cart_status.setKey("fetching_quote", false);
+    }
+  }
+  async function checkout(input = {}) {
+    if (checkoutItems(input).length === 0) throw new Error("Cart is empty");
+    cart_status.setKey("processing_checkout", true);
+    cart_status.setKey("error", null);
+    try {
+      const current = await syncCart(input);
+      const quoteValue = quote.get();
+      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.eshop.cart.quote({ id: current.id });
+        quote.set(latestQuote);
+        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" && typeof chargeAmount === "number" && chargeAmount > 0;
+      let confirmationTokenId;
+      let returnUrl = input.return_url;
+      const paymentController = input.payment ?? payment_controller.get();
+      if (needsConfirmationToken) {
+        if (!paymentController) throw new Error("Payment controller is required for card checkout");
+        returnUrl = returnUrl || (typeof window !== "undefined" ? window.location.href : void 0);
+        const token = await paymentController.createConfirmationToken({
+          return_url: returnUrl,
+          billing_details: input.billing_details
+        });
+        confirmationTokenId = token.confirmation_token_id;
+        returnUrl = token.return_url || returnUrl;
+      }
+      const response = await client.eshop.cart.checkout({
+        id: current.id,
+        payment_method_key: paymentMethodKey,
+        confirmation_token_id: confirmationTokenId,
+        return_url: returnUrl
+      });
+      if (response.payment_action.type === "handle_next_action") {
+        if (!paymentController) throw new Error("Payment controller is required for card authentication");
+        await paymentController.handleNextAction(response.payment_action.client_secret);
+      }
+      const stored = {
+        order_id: response.order_id,
+        number: response.number,
+        payment_action: response.payment_action,
+        payment: response.payment,
+        product_items: input.product_items || product_items.get(),
+        service_items: input.service_items || service_items.get(),
+        shipping_address: input.shipping_address || null,
+        billing_address: input.billing_address || null,
+        total: response.payment.amount,
+        currency: response.payment.currency,
+        payment_method_key: paymentMethodKey || null,
+        created_at: Date.now()
+      };
+      last_order.set(stored);
+      if (input.clear_after_checkout !== false) {
+        clearLocalCart();
+      }
+      return response;
+    } catch (error) {
+      cart_status.setKey("error", readErrorMessage(error, "Checkout failed."));
+      throw error;
+    } finally {
+      cart_status.setKey("processing_checkout", false);
+    }
+  }
+  function serviceCalendar() {
+    const state = service_state.get();
+    const { currentMonth, selectedDate, availability, selectedProviderId } = state;
+    const year = currentMonth.getFullYear();
+    const monthIndex = currentMonth.getMonth();
+    const first = new Date(year, monthIndex, 1);
+    const last = new Date(year, monthIndex + 1, 0);
+    const today = /* @__PURE__ */ new Date();
+    today.setHours(0, 0, 0, 0);
+    const cells = [];
+    const pad = (first.getDay() + 6) % 7;
+    for (let i = 0; i < pad; i++) {
+      cells.push({
+        date: /* @__PURE__ */ new Date(0),
+        iso: "",
+        available: false,
+        isSelected: false,
+        isInRange: false,
+        isToday: false,
+        blank: true
+      });
+    }
+    for (let day = 1; day <= last.getDate(); day++) {
+      const date = new Date(year, monthIndex, day);
+      const iso = `${year}-${String(monthIndex + 1).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+      cells.push({
+        date,
+        iso,
+        available: hasAvailableSlotsForDate(availability, iso, selectedProviderId),
+        isSelected: iso === selectedDate,
+        isInRange: false,
+        isToday: date.getTime() === today.getTime(),
+        blank: false
+      });
+    }
+    const suffix = (7 - cells.length % 7) % 7;
+    for (let i = 0; i < suffix; i++) {
+      cells.push({
+        date: /* @__PURE__ */ new Date(0),
+        iso: "",
+        available: false,
+        isSelected: false,
+        isInRange: false,
+        isToday: false,
+        blank: true
+      });
+    }
+    return cells;
+  }
+  function computeServiceSlots(dateStr) {
+    const state = service_state.get();
+    const { availability, selectedProviderId, timezone, service } = state;
+    return getSlotsForDate(availability, dateStr, selectedProviderId).map((slot, index) => ({
+      id: `${service?.id || "service"}-${slot.from}-${index}`,
+      serviceId: service?.id || "",
+      providerId: slot.providerId,
+      from: slot.from,
+      to: slot.to,
+      timeText: formatServiceSlotTime(slot.from, slot.to, timezone),
+      dateText: new Date(slot.from * 1e3).toLocaleDateString([], {
+        weekday: "short",
+        month: "short",
+        day: "numeric",
+        timeZone: timezone
+      })
+    }));
+  }
+  function toServiceCartItem(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: 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
+    };
+  }
+  async function syncServiceCart(items) {
+    try {
+      return await syncCart({
+        product_items: product_items.get(),
+        service_items: items
+      });
+    } catch (error) {
+      service_state.setKey("quoteError", readErrorMessage(error, "Failed to sync service cart."));
+      throw error;
+    }
+  }
+  function serviceCurrentStepName() {
+    const state = service_state.get();
+    if (!state.service) return "";
+    if (!state.selectedSlot || !state.dateTimeConfirmed) return "datetime";
+    return "review";
+  }
+  const service_current_step_name = nanostores.computed(service_state, serviceCurrentStepName);
+  const service_can_proceed = nanostores.computed(service_state, (state) => {
+    const step = serviceCurrentStepName();
+    if (step === "datetime") {
+      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"
+    })
+  );
+  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, () => ({
+    1: { name: "datetime" },
+    2: { name: "review" }
+  }));
+  const service_current_step = nanostores.computed([service_current_step_name, service_steps], (name, steps) => {
+    for (const [idx, step] of Object.entries(steps)) {
+      if (step.name === name) return Number(idx);
+    }
+    return 1;
+  });
+  function formatServiceDateDisplay(value) {
+    if (!value) return "";
+    return new Date(value).toLocaleDateString(void 0, {
+      month: "short",
+      day: "numeric"
+    });
+  }
+  function 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 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;
+    }
+    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 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();
+      const methods = market.get()?.payment_methods || [];
+      if (methods.length) service_state.setKey("availablePaymentMethods", methods);
+    },
+    setTimezone(tz) {
+      service_state.setKey("timezone", tz);
+      service_state.setKey("calendar", serviceCalendar());
+      const state = service_state.get();
+      if (state.selectedDate) {
+        service_state.setKey("slots", computeServiceSlots(state.selectedDate));
+        service_state.setKey("selectedSlot", null);
+        service_state.setKey("quote", null);
+        service_state.setKey("quoteError", null);
+        activateServiceProviderForms();
+      }
+    },
+    async select(service) {
+      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 [fullService, serviceProviders] = await Promise.all([
+          client.eshop.service.get({ id: service.id }),
+          client.eshop.service.findProviders({
+            service_id: service.id
+          })
+        ]);
+        const providerIds = [...new Set(serviceProviders.map((relationship) => relationship.provider_id))];
+        const [providerResults] = await Promise.all([
+          Promise.all(providerIds.map((id) => client.eshop.provider.get({ id }).catch(() => null))),
+          loadServiceFormDefinitions(serviceProviders)
+        ]);
+        service_state.set({
+          ...service_state.get(),
+          service: fullService,
+          serviceProviders,
+          providers: providerResults.filter(
+            (provider) => provider !== null
+          ),
+          selectedProviderId: null,
+          availability: null,
+          selectedDate: null,
+          slots: [],
+          selectedSlot: null,
+          currentMonth: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), 1),
+          loading: false,
+          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;
+      }
+    },
+    async loadMonth() {
+      const state = service_state.get();
+      if (!state.service) return;
+      service_state.setKey("loading", true);
+      try {
+        const chainedStart = service_chain_start.get();
+        let from;
+        let to;
+        if (chainedStart) {
+          from = chainedStart;
+          to = chainedStart;
+        } else {
+          const month = state.currentMonth;
+          from = Math.floor(Date.UTC(month.getFullYear(), month.getMonth(), 1) / 1e3);
+          to = Math.floor(Date.UTC(month.getFullYear(), month.getMonth() + 1, 1) / 1e3);
+        }
+        const availability = await loadAvailability({
+          service_id: state.service.id,
+          from,
+          to
+        });
+        service_state.setKey("availability", availability);
+        service_state.setKey("calendar", serviceCalendar());
+      } finally {
+        service_state.setKey("loading", false);
+      }
+    },
+    prevMonth() {
+      const { currentMonth } = service_state.get();
+      service_state.setKey("currentMonth", new Date(currentMonth.getFullYear(), currentMonth.getMonth() - 1, 1));
+      void service_controller.loadMonth();
+    },
+    nextMonth() {
+      const { currentMonth } = service_state.get();
+      service_state.setKey("currentMonth", new Date(currentMonth.getFullYear(), currentMonth.getMonth() + 1, 1));
+      void service_controller.loadMonth();
+    },
+    selectProvider(providerId) {
+      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({
+        ...state,
+        selectedProviderId: providerId,
+        selectedDate: null,
+        slots: [],
+        selectedSlot: null,
+        dateTimeConfirmed: false,
+        quote: null,
+        quoteError: null
+      });
+      activateServiceProviderForms(providerId);
+      void service_controller.loadMonth();
+    },
+    selectDate(cell) {
+      if (cell.blank || !cell.available) return;
+      const state = service_state.get();
+      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());
+    },
+    selectTimeSlot(slot) {
+      const state = service_state.get();
+      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.set({
+        ...state,
+        selectedSlot: slot,
+        dateTimeConfirmed: false,
+        quote: null,
+        quoteError: null
+      });
+      activateServiceProviderForms(slot?.providerId);
+    },
+    resetDateSelection() {
+      service_state.set({
+        ...service_state.get(),
+        selectedDate: null,
+        slots: [],
+        selectedSlot: null,
+        dateTimeConfirmed: false,
+        quote: null,
+        quoteError: null
+      });
+      activateServiceProviderForms();
+    },
+    updateCalendar() {
+      service_state.setKey("calendar", serviceCalendar());
+    },
+    findFirstAvailable() {
+      for (const day of service_state.get().calendar) {
+        if (!day.blank && day.available) {
+          service_controller.selectDate(day);
+          return;
+        }
+      }
+    },
+    async addToCart(explicitSlots) {
+      const state = service_state.get();
+      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: displayName,
+        date: slot.dateText
+      }));
+      const nextItems = [...service_items.get(), toServiceCartItem(enriched, forms)];
+      await syncServiceCart(nextItems);
+      service_state.set({
+        ...service_state.get(),
+        selectedDate: null,
+        slots: [],
+        selectedSlot: null,
+        dateTimeConfirmed: false,
+        quote: null,
+        quoteError: null
+      });
+      activateServiceProviderForms(service_state.get().selectedProviderId, true);
+      service_state.setKey("calendar", serviceCalendar());
+    },
+    async removeFromCart(bookingId) {
+      await syncServiceCart(service_items.get().filter((item) => item.id !== bookingId));
+    },
+    async clearCart() {
+      await syncServiceCart([]);
+    },
+    async checkout(paymentMethodId, forms = []) {
+      const state = service_state.get();
+      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: items,
+          payment_method_key: paymentMethodId,
+          promo_code: state.promoCode || void 0,
+          forms
+        });
+        service_state.setKey("cartId", cart.get()?.id || null);
+        return result;
+      } finally {
+        service_state.setKey("loading", false);
+      }
+    },
+    async fetchQuote(paymentMethodId, promoCode) {
+      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: items,
+          payment_method_key: paymentMethodId,
+          promo_code: promoCode || void 0
+        });
+        service_state.setKey("cartId", cart.get()?.id || null);
+        service_state.setKey("quote", response);
+        const methods = response?.payment_methods || market.get()?.payment_methods || [];
+        if (methods.length) service_state.setKey("availablePaymentMethods", methods);
+        return response;
+      } catch (error) {
+        service_state.setKey("quoteError", readErrorMessage(error, "Failed to fetch quote."));
+        return null;
+      } finally {
+        service_state.setKey("fetchingQuote", false);
+      }
+    },
+    getProvidersList() {
+      return service_state.get().providers;
+    },
+    prevStep() {
+      const current = serviceCurrentStepName();
+      if (current === "review") {
+        service_state.setKey("dateTimeConfirmed", false);
+        return;
+      }
+      if (current === "datetime") {
+        service_state.setKey("selectedSlot", null);
+        service_state.setKey("dateTimeConfirmed", false);
+        service_state.setKey("quote", null);
+        service_state.setKey("quoteError", null);
+        activateServiceProviderForms();
+      }
+    },
+    nextStep() {
+      if (serviceCurrentStepName() === "datetime" && service_can_proceed.get()) {
+        service_state.setKey("dateTimeConfirmed", true);
+      }
+    },
+    getServicePrice() {
+      const state = service_state.get();
+      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, forms = []) {
+      return slots.length ? [toServiceCartItem(slots, forms)] : [];
+    }
+  };
+  async function loadEntry(params, options) {
+    cms_state.setKey("loading", true);
+    cms_state.setKey("error", null);
+    try {
+      const { locale: nextLocale, market: nextMarket, ...entryParams } = params;
+      setContext({ locale: nextLocale, market: nextMarket });
+      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
+        });
+        return entry2;
+      }
+      if (!entryParams.collection_id || !entryParams.key) {
+        throw new Error("ArkyCmsEntryParams requires id, or collection_id and key");
+      }
+      const result = await client.cms.entry.find(
+        {
+          ...entryParams,
+          collection_id: entryParams.collection_id,
+          key: entryParams.key,
+          limit: 1
+        },
+        options
+      );
+      const entry = result.items?.[0];
+      if (!entry) {
+        throw new Error("CMS entry not found");
+      }
+      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."));
+      throw error;
+    } finally {
+      cms_state.setKey("loading", false);
+    }
+  }
+  function formCacheKey(params) {
+    const identifier = params.id ? `id:${params.id}` : params.key ? `key:${params.key}` : "missing";
+    return 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 forms = { ...cms_state.get().forms };
+      forms[formCacheKey({ id: form.id })] = form;
+      forms[formCacheKey({ key: form.key })] = form;
+      cms_state.setKey("forms", forms);
+      return form;
+    } catch (error) {
+      cms_state.setKey("error", readErrorMessage(error, "Failed to load CMS form."));
+      throw error;
+    } finally {
+      cms_state.setKey("loading", false);
+    }
+  }
+  async function submitForm(params, options) {
+    await ensureSession();
+    return client.cms.form.submit(params, options);
+  }
+  async function submitFormByKey(params, options) {
+    const form = await loadForm({ key: params.key }, options);
+    const entry = createFormEntryFromValues(form, params.values);
+    return submitForm({ form_id: form.id, fields: entry.fields }, options);
+  }
+  async function loadProducts(params = {}, options) {
+    eshop_state.setKey("loading_products", true);
+    eshop_state.setKey("error", null);
+    try {
+      const response = await client.eshop.product.find(params, options);
+      eshop_state.setKey("products", response.items || []);
+      eshop_state.setKey("product_cursor", response.cursor || null);
+      return response;
+    } catch (error) {
+      eshop_state.setKey("error", readErrorMessage(error, "Failed to load products."));
+      throw error;
+    } finally {
+      eshop_state.setKey("loading_products", false);
+    }
+  }
+  async function loadServices(params = {}, options) {
+    eshop_state.setKey("loading_services", true);
+    eshop_state.setKey("error", null);
+    try {
+      const response = await client.eshop.service.find(params, options);
+      eshop_state.setKey("services", response.items || []);
+      eshop_state.setKey("service_cursor", response.cursor || null);
+      return response;
+    } catch (error) {
+      eshop_state.setKey("error", readErrorMessage(error, "Failed to load services."));
+      throw error;
+    } finally {
+      eshop_state.setKey("loading_services", false);
+    }
+  }
+  async function loadProviders(params = {}, options) {
+    eshop_state.setKey("loading_providers", true);
+    eshop_state.setKey("error", null);
+    try {
+      const response = await client.eshop.provider.find(params, options);
+      eshop_state.setKey("providers", response.items || []);
+      eshop_state.setKey("provider_cursor", response.cursor || null);
+      return response;
+    } catch (error) {
+      eshop_state.setKey("error", readErrorMessage(error, "Failed to load providers."));
+      throw error;
+    } finally {
+      eshop_state.setKey("loading_providers", false);
+    }
+  }
+  async function loadAvailability(params, options) {
+    eshop_state.setKey("loading_availability", true);
+    eshop_state.setKey("error", null);
+    try {
+      const response = await client.eshop.service.getAvailability(params, options);
+      eshop_state.setKey("availability", response);
+      return response;
+    } catch (error) {
+      eshop_state.setKey("error", readErrorMessage(error, "Failed to load availability."));
+      throw error;
+    } finally {
+      eshop_state.setKey("loading_availability", false);
+    }
+  }
+  async function useExperiment(params) {
+    await ensureSession();
+    const input = typeof params === "string" ? { key: params } : params;
+    return client.experiments.use(input);
+  }
+  async function trackAction(params) {
+    await ensureSession();
+    return client.action.track(params);
+  }
+  const cart_store = {
+    cart,
+    product_items,
+    service_items,
+    quote_result: quote,
+    promo_code,
+    last_order,
+    status: cart_status,
+    product_item_count,
+    service_item_count,
+    item_count,
+    snapshot,
+    load: ensureCart,
+    refresh: syncCart,
+    addProduct,
+    setProductQuantity,
+    removeProduct,
+    addServiceItem,
+    removeServiceItem,
+    clear: clearCart,
+    clearLocal: clearLocalCart,
+    quote: fetchQuote,
+    checkout,
+    payment: {
+      controller: payment_controller,
+      ready: payment_ready,
+      setController: setPaymentController,
+      getController: () => payment_controller.get(),
+      mount: mountPayment,
+      update: updatePaymentController,
+      destroy: destroyPaymentController
+    },
+    applyPromoCode(code, input = {}) {
+      return fetchQuote({ ...input, promo_code: code });
+    },
+    removePromoCode(input = {}) {
+      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),
+    list: loadProducts
+  };
+  const service_store = {
+    get: (params, options) => client.eshop.service.get(params, options),
+    list: loadServices,
+    listProviders: (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,
+    month_year: service_month_year,
+    chain_start: service_chain_start,
+    total_steps: service_total_steps,
+    steps: service_steps,
+    current_step: service_current_step,
+    initialize: service_controller.initialize,
+    select: service_controller.select,
+    setTimezone: service_controller.setTimezone,
+    loadMonth: service_controller.loadMonth,
+    prevMonth: service_controller.prevMonth,
+    nextMonth: service_controller.nextMonth,
+    selectProvider: service_controller.selectProvider,
+    selectDate: service_controller.selectDate,
+    selectTimeSlot: service_controller.selectTimeSlot,
+    resetDateSelection: service_controller.resetDateSelection,
+    updateCalendar: service_controller.updateCalendar,
+    findFirstAvailable: service_controller.findFirstAvailable,
+    addToCart: service_controller.addToCart,
+    removeFromCart: service_controller.removeFromCart,
+    clearCart: service_controller.clearCart,
+    getProvidersList: service_controller.getProvidersList,
+    prevStep: service_controller.prevStep,
+    nextStep: service_controller.nextStep,
+    getServicePrice: service_controller.getServicePrice,
+    formatDateDisplay: service_controller.formatDateDisplay,
+    serviceItemsFromSlots: service_controller.serviceItemsFromSlots
+  };
+  return {
+    client,
+    session,
+    setup,
+    market,
+    market_key,
+    locale,
+    currency,
+    allowed_payment_methods,
+    payment_config,
+    identify,
+    identifyContactEmailIfMissing,
+    verify: client.verify,
+    me: client.me,
+    logout: client.logout,
+    onAuthStateChanged: client.onAuthStateChanged,
+    get isAuthenticated() {
+      return client.isAuthenticated;
+    },
+    setMarket,
+    setLocale,
+    setContext,
+    getMarket: currentMarketKey,
+    getLocale: currentLocale,
+    cms: {
+      state: cms_state,
+      collection: {
+        get: (params, options) => client.cms.collection.get(params, options)
+      },
+      entry: {
+        get: loadEntry,
+        find: (params, options) => client.cms.entry.find(params, options)
+      },
+      form: {
+        get: loadForm,
+        submit: submitForm,
+        submitByKey: submitFormByKey
+      },
+      taxonomy: client.cms.taxonomy
+    },
+    eshop: {
+      state: eshop_state,
+      product: product_store,
+      service: service_store,
+      provider: {
+        get: (params, options) => client.eshop.provider.get(params, options),
+        list: loadProviders
+      },
+      order: client.eshop.order,
+      cart: cart_store
+    },
+    crm: client.crm,
+    action: {
+      track(params) {
+        return trackAction(params);
+      },
+      pageView(payload = {}) {
+        return trackAction({ key: "page.view", payload });
+      },
+      state: nanostores.atom(null)
+    },
+    experiments: {
+      use: useExperiment
+    },
+    support: client.support,
+    store: {
+      ...client.store,
+      setup,
+      load: loadSetup
+    },
+    utils: client.utils
+  };
+}
+function initializeStore(publishableKey, config, scopedClient) {
+  const store = initializeStoreCore(publishableKey, config, scopedClient);
+  return Object.assign(store, {
+    withContext(context) {
+      return initializeStore(
+        publishableKey,
+        {
+          ...config,
+          locale: context.locale ?? store.getLocale(),
+          market: context.market ?? store.getMarket()
+        },
+        store.client.withContext(context)
+      );
+    }
+  });
+}
+function initialize(publishableKey, options = {}) {
+  return initializeStore(publishableKey, options);
+}
+
+// src/index.ts
+var SDK_VERSION = "0.11.0";
+var SUPPORTED_FRAMEWORKS = [
+  "astro",
+  "react",
+  "vue",
+  "svelte",
+  "vanilla"
+];
+function createUtilitySurface(apiConfig) {
+  return {
+    getImageUrl: (imageBlock, isBlock2 = true) => getImageUrl(imageBlock, isBlock2),
+    getBlockValue,
+    getBlockTextValue,
+    getBlockContentValue,
+    getBlockValues,
+    getBlockLabel,
+    getBlockObjectValues,
+    getBlockFromArray,
+    formatBlockValue,
+    prepareBlocksForSubmission,
+    extractBlockValues,
+    formatPrice: (prices) => formatPrice(prices, apiConfig.market),
+    getPriceAmount: (prices) => getPriceAmount(prices, apiConfig.market),
+    formatPayment,
+    formatMinor,
+    getCurrencySymbol,
+    getCurrencyName,
+    validatePhoneNumber,
+    tzGroups,
+    findTimeZone,
+    slugify,
+    humanize,
+    categorify,
+    formatDate,
+    getSvgContentForAstro,
+    fetchSvgContent,
+    injectSvgIntoElement,
+    isValidKey,
+    validateKey,
+    toKey,
+    nameToKey,
+    getAvailableStock,
+    getReservedStock,
+    hasStock,
+    getInventoryAt,
+    getFirstAvailableFCId
+  };
+}
+var ADMIN_STORAGE_KEY = "arky_admin_session";
+function readAdminSession() {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = localStorage.getItem(ADMIN_STORAGE_KEY);
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+function writeAdminSession(s) {
+  if (typeof window === "undefined") return;
+  if (s) {
+    localStorage.setItem(ADMIN_STORAGE_KEY, JSON.stringify(s));
+  } else {
+    localStorage.removeItem(ADMIN_STORAGE_KEY);
+  }
+}
+function createAdmin(config) {
+  const locale = config.locale || "en";
+  const listeners = /* @__PURE__ */ new Set();
+  function toPublic(s) {
+    return s ? { email: s.email } : null;
+  }
+  function emit() {
+    const pub = toPublic(readAdminSession());
+    for (const l of listeners) {
+      Promise.resolve().then(() => l(pub)).catch(() => {
+      });
+    }
+  }
+  const updateSession = (updater) => {
+    if (config.apiToken) return;
+    const prev = readAdminSession();
+    const next = updater(prev);
+    writeAdminSession(next);
+    emit();
+  };
+  const authStorage = config.apiToken ? {
+    getTokens: () => ({ access_token: config.apiToken }),
+    onTokensRefreshed: () => {
+    },
+    onForcedLogout: () => {
+    }
+  } : {
+    getTokens() {
+      const s = readAdminSession();
+      if (!s) return null;
+      return {
+        access_token: s.access_token,
+        refresh_token: s.refresh_token,
+        access_expires_at: s.access_expires_at
+      };
+    },
+    onTokensRefreshed(tokens) {
+      updateSession(
+        (prev) => prev ? {
+          ...prev,
+          access_token: tokens.access_token,
+          refresh_token: tokens.refresh_token ?? prev.refresh_token,
+          access_expires_at: tokens.access_expires_at ?? prev.access_expires_at
+        } : null
+      );
+    },
+    onForcedLogout() {
+      updateSession(() => null);
+    }
+  };
+  const httpClient = createHttpClient({
+    baseUrl: config.baseUrl,
+    storeId: config.storeId,
+    refreshPath: config.refreshPath,
+    navigate: config.navigate,
+    loginFallbackPath: config.loginFallbackPath,
+    authStorage
+  });
+  const apiConfig = {
+    httpClient,
+    storeId: config.storeId,
+    baseUrl: config.baseUrl,
+    market: config.market,
+    locale,
+    authStorage
   };
   const accountApi = createAccountApi(apiConfig);
   const authApi = createAuthApi(apiConfig, updateSession);
@@ -4314,6 +6028,7 @@ function createAdmin(config) {
       update: storeApi.updateStore,
       get: storeApi.getStore,
       find: storeApi.getStores,
+      regeneratePublishableKey: storeApi.regeneratePublishableKey,
       subscription: {
         get: storeApi.getSubscription,
         getPlans: storeApi.getSubscriptionPlans,
@@ -4632,6 +6347,8 @@ function createAdmin(config) {
   };
   return sdk;
 }
+var DEFAULT_STOREFRONT_API_URL = "https://api.arky.io";
+var storefrontScopeSequence = 0;
 function defaultStorefrontSessionStorage() {
   if (typeof window === "undefined") return null;
   try {
@@ -4640,132 +6357,177 @@ function defaultStorefrontSessionStorage() {
     return null;
   }
 }
-function storefrontSessionStorageKey(baseUrl, storeId) {
-  const normalizedBaseUrl = baseUrl.trim().replace(/\/+$/, "").toLowerCase();
-  return `arky_contact_session:${encodeURIComponent(normalizedBaseUrl)}:${encodeURIComponent(storeId)}`;
+function normalizeStorefrontApiUrl(value) {
+  const input = value?.trim() || DEFAULT_STOREFRONT_API_URL;
+  let parsed;
+  try {
+    parsed = new URL(input);
+  } catch {
+    throw new Error("Storefront apiUrl must be a valid HTTP(S) URL");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("Storefront apiUrl must use HTTP or HTTPS");
+  }
+  return input.replace(/\/+$/, "");
 }
-function createStorefrontClient(config) {
-  const locale = config.locale || "en";
-  const initialMarket = config.market || "";
+function validatePublishableKey(publishableKey) {
+  if (typeof publishableKey !== "string") {
+    throw new Error(
+      "A valid Arky publishable key is required (arky_pk_ followed by 43 URL-safe characters)"
+    );
+  }
+  const key = publishableKey.trim();
+  if (!/^arky_pk_[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/.test(key)) {
+    throw new Error(
+      "A valid Arky publishable key is required (arky_pk_ followed by 43 URL-safe characters)"
+    );
+  }
+  return key;
+}
+function publishableKeyFingerprint(publishableKey) {
+  let hashA = 2166136261;
+  let hashB = 2654435769;
+  for (let index = 0; index < publishableKey.length; index += 1) {
+    const code = publishableKey.charCodeAt(index);
+    hashA = Math.imul(hashA ^ code, 16777619);
+    hashB = Math.imul(hashB ^ code, 2246822507);
+  }
+  return `${(hashA >>> 0).toString(36)}${(hashB >>> 0).toString(36)}`;
+}
+function storefrontSessionStorageKey(apiUrl, publishableKey) {
+  return `arky_visitor_session:${encodeURIComponent(apiUrl.toLowerCase())}:${publishableKeyFingerprint(publishableKey)}`;
+}
+function isVisitorSessionToken(value) {
+  return Boolean(value && /^arky_vst_[0-9a-f]{64}$/.test(value));
+}
+function createStorefrontClientCore(publishableKeyInput, options = {}, isolatedSession = false) {
+  const publishableKey = validatePublishableKey(publishableKeyInput);
+  const apiUrl = normalizeStorefrontApiUrl(options.apiUrl);
+  let locale = options.locale?.trim() || "";
+  let market = options.market?.trim() || "";
   const listeners = /* @__PURE__ */ new Set();
-  let bareIdentifyPromise = null;
+  let identifyPromise = null;
   let identityTail = Promise.resolve();
-  const sessionStorage = config.sessionStorage || defaultStorefrontSessionStorage();
+  let setupPromise = null;
+  let setupValue = null;
+  const explicitSessionStorage = options.sessionStorage;
+  const sessionStorage = isolatedSession ? explicitSessionStorage || null : explicitSessionStorage || defaultStorefrontSessionStorage();
+  const canCreateVisitorSession = typeof window !== "undefined" || Boolean(explicitSessionStorage);
+  const storageKey = `${storefrontSessionStorageKey(apiUrl, publishableKey)}${isolatedSession ? `:scope:${++storefrontScopeSequence}` : ""}`;
   let memorySession = null;
-  function readContactSession() {
-    if (!sessionStorage) return memorySession;
+  let memorySessionToken = null;
+  function readSessionToken() {
+    if (!sessionStorage) return memorySessionToken;
     try {
-      const raw = sessionStorage.getItem(
-        storefrontSessionStorageKey(config.baseUrl, config.storeId)
-      );
-      return raw ? JSON.parse(raw) : null;
+      const stored = sessionStorage.getItem(storageKey);
+      return isVisitorSessionToken(stored) ? stored : memorySessionToken;
     } catch {
-      return memorySession;
+      return memorySessionToken;
     }
   }
   function writeContactSession(session) {
     memorySession = session;
+    memorySessionToken = session?.sessionToken || null;
     if (!sessionStorage) return;
-    const key = storefrontSessionStorageKey(config.baseUrl, config.storeId);
     try {
       if (session) {
-        sessionStorage.setItem(key, JSON.stringify(session));
+        sessionStorage.setItem(storageKey, session.sessionToken);
       } else {
-        sessionStorage.removeItem(key);
+        sessionStorage.removeItem(storageKey);
       }
     } catch {
     }
   }
   function toPublic(s) {
-    return s ? { contact: s.contact, store: s.store, market: s.market } : null;
+    return s ? { contact: s.contact } : null;
   }
   function emit() {
-    const pub = toPublic(readContactSession());
+    const pub = toPublic(memorySession);
     for (const l of listeners) {
       Promise.resolve().then(() => l(pub)).catch(() => {
       });
     }
   }
   const updateSession = (updater) => {
-    if (config.apiToken) return;
-    const prev = readContactSession();
-    const next = updater(prev);
+    const next = updater(memorySession);
     writeContactSession(next);
     emit();
   };
-  const authStorage = config.apiToken ? {
-    getTokens: () => ({ access_token: config.apiToken }),
-    onTokensRefreshed: () => {
-    },
-    onForcedLogout: () => {
-    }
-  } : {
+  const authStorage = {
     getTokens() {
-      const s = readContactSession();
-      return s ? { access_token: s.access_token } : null;
+      const sessionToken = readSessionToken();
+      return sessionToken ? { access_token: sessionToken } : null;
     },
     onTokensRefreshed() {
     },
     onForcedLogout() {
-      bareIdentifyPromise = null;
+      identifyPromise = null;
       updateSession(() => null);
     }
   };
+  let recoverUnauthorized = async () => false;
+  let visitorRecoveryPromise = null;
   const httpClient = createHttpClient({
-    baseUrl: config.baseUrl,
-    storeId: config.storeId,
-    refreshPath: config.refreshPath,
-    navigate: config.navigate,
-    loginFallbackPath: config.loginFallbackPath,
-    authStorage
+    baseUrl: apiUrl,
+    authStorage,
+    storefrontMode: true,
+    forcedHeaders: () => ({
+      "X-Arky-Publishable-Key": publishableKey,
+      ...locale ? { "X-Arky-Locale": locale } : {},
+      ...market ? { "X-Arky-Market": market } : {}
+    }),
+    onUnauthorized: ({ authorizationToken, path }) => recoverUnauthorized(authorizationToken, path)
   });
   const apiConfig = {
     httpClient,
-    storeId: config.storeId,
-    baseUrl: config.baseUrl,
-    market: initialMarket,
+    apiUrl,
+    publishableKey,
+    market,
     locale,
     authStorage
   };
-  const storefrontApi = createStorefrontApi(apiConfig, updateSession);
+  function requireVisitorSessionCapability() {
+    if (!canCreateVisitorSession) {
+      throw new Error(
+        "Stateful storefront operations during SSR require an explicit request-local sessionStorage adapter"
+      );
+    }
+  }
+  async function getSetup(requestOptions) {
+    if (setupValue) return setupValue;
+    if (setupPromise) return setupPromise;
+    setupPromise = httpClient.get(
+      "/v1/storefront",
+      requestOptions
+    ).then((setup) => {
+      setupValue = setup;
+      return setup;
+    }).finally(() => {
+      setupPromise = null;
+    });
+    return setupPromise;
+  }
+  async function ensureVisitorSession() {
+    if (readSessionToken()) return;
+    requireVisitorSessionCapability();
+    await identify();
+  }
+  const storefrontApi = createStorefrontApi(apiConfig, updateSession, {
+    ensureVisitorSession,
+    getSetup
+  });
   const contactApi = storefrontApi.crm.contact;
   function identify(params) {
-    if (params?.market !== void 0) apiConfig.market = params.market;
-    const market = apiConfig.market;
+    requireVisitorSessionCapability();
+    if (params?.market !== void 0) setMarket(params.market);
     const isBareCall = !params?.email && !params?.verify;
-    if (isBareCall && bareIdentifyPromise) return bareIdentifyPromise;
+    if (isBareCall && identifyPromise) return identifyPromise;
     const run = async () => {
-      try {
-        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,
-          verification_challenge: result.verification_challenge
-        };
-      } catch (err) {
-        const e = err;
-        const status = e?.statusCode || e?.status || e?.response?.status;
-        if (isBareCall && status === 401) {
-          updateSession(() => null);
-          const result = await contactApi.identify({
-            market
-          });
-          return {
-            contact: result.contact,
-            store: result.store,
-            market: result.market,
-            verification_challenge: result.verification_challenge
-          };
-        }
-        throw err;
-      }
+      const result = await (params?.verify ? contactApi.requestCode({ email: params.email }) : contactApi.identify({ email: params?.email }));
+      return {
+        contact: result.contact,
+        verification_challenge: result.verification_challenge
+      };
     };
     const promise = identityTail.then(run);
     identityTail = promise.then(
@@ -4773,49 +6535,88 @@ function createStorefrontClient(config) {
       () => void 0
     );
     if (isBareCall) {
-      bareIdentifyPromise = promise;
+      identifyPromise = promise;
       void promise.then(
         () => {
-          if (bareIdentifyPromise === promise) bareIdentifyPromise = null;
+          if (identifyPromise === promise) identifyPromise = null;
         },
         () => {
-          if (bareIdentifyPromise === promise) bareIdentifyPromise = null;
+          if (identifyPromise === promise) identifyPromise = null;
         }
       );
     }
     return promise;
   }
   async function verify(params) {
+    requireVisitorSessionCapability();
     const result = await contactApi.verify(params);
-    bareIdentifyPromise = null;
-    return result;
+    identifyPromise = null;
+    return { contact: result.contact };
+  }
+  async function me() {
+    await ensureVisitorSession();
+    return contactApi.getMe();
   }
   async function logout() {
-    if (config.apiToken) return;
-    bareIdentifyPromise = null;
+    identifyPromise = null;
+    if (!readSessionToken()) {
+      updateSession(() => null);
+      return;
+    }
     try {
       await contactApi.logout();
     } catch {
       updateSession(() => null);
     }
   }
+  function setMarket(value) {
+    market = value.trim();
+    apiConfig.market = market;
+    identifyPromise = null;
+  }
+  function setLocale(value) {
+    locale = value.trim();
+    apiConfig.locale = locale;
+  }
+  function setContext(context) {
+    if (context.locale !== void 0) setLocale(context.locale);
+    if (context.market !== void 0) setMarket(context.market);
+  }
+  recoverUnauthorized = async (authorizationToken, path) => {
+    if (!authorizationToken) return false;
+    const currentToken = readSessionToken();
+    if (currentToken !== authorizationToken) {
+      if (currentToken) return true;
+      if (!visitorRecoveryPromise) return false;
+      await visitorRecoveryPromise;
+      return Boolean(readSessionToken());
+    }
+    updateSession(() => null);
+    if (/\/account\/(identify|code)$/.test(path)) return true;
+    const recovery = ensureVisitorSession();
+    const trackedRecovery = recovery.finally(() => {
+      if (visitorRecoveryPromise === trackedRecovery) {
+        visitorRecoveryPromise = null;
+      }
+    });
+    visitorRecoveryPromise = trackedRecovery;
+    await trackedRecovery;
+    return true;
+  };
   return {
     identify,
     verify,
     logout,
-    me: () => contactApi.getMe(),
+    me,
     get session() {
-      if (config.apiToken) return null;
-      return toPublic(readContactSession());
+      return toPublic(memorySession);
     },
     get isAuthenticated() {
-      if (config.apiToken) return true;
-      const s = readContactSession();
-      return s !== null && !!s.access_token;
+      return Boolean(readSessionToken());
     },
     onAuthStateChanged(listener) {
       listeners.add(listener);
-      const current = toPublic(readContactSession());
+      const current = toPublic(memorySession);
       if (current) {
         Promise.resolve().then(() => listener(current)).catch(() => {
         });
@@ -4827,50 +6628,63 @@ function createStorefrontClient(config) {
     store: storefrontApi.store,
     cms: storefrontApi.cms,
     eshop: storefrontApi.eshop,
-    crm: storefrontApi.crm,
+    crm: {
+      ...storefrontApi.crm,
+      contact: {
+        identify: (params) => identify(params),
+        requestCode: (params) => identify({ ...params, verify: true }),
+        verify,
+        logout,
+        getMe: me
+      }
+    },
     action: storefrontApi.action,
     experiments: storefrontApi.experiments,
-    support: createStorefrontSupportApi(apiConfig),
-    getStoreId: () => apiConfig.storeId,
-    setMarket: (key) => {
-      apiConfig.market = key;
-      bareIdentifyPromise = null;
-    },
-    getMarket: () => apiConfig.market,
-    setLocale: (l) => {
-      apiConfig.locale = l;
-    },
-    getLocale: () => apiConfig.locale,
+    support: createStorefrontSupportApi(apiConfig, ensureVisitorSession),
+    getSetup,
+    setContext,
+    setMarket,
+    getMarket: () => market,
+    setLocale,
+    getLocale: () => locale,
     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()
-    })
+function createStorefrontClient(publishableKey, options = {}, isolatedSession = false) {
+  const client = createStorefrontClientCore(
+    publishableKey,
+    options,
+    isolatedSession
+  );
+  return Object.assign(client, {
+    withContext(context) {
+      return createStorefrontClient(
+        publishableKey,
+        {
+          ...options,
+          locale: context.locale ?? client.getLocale(),
+          market: context.market ?? client.getMarket()
+        },
+        true
+      );
+    }
   });
-  return client;
+}
+function createStorefront(publishableKey, options = {}) {
+  return createStorefrontClient(publishableKey, options);
 }
 
 exports.COMMON_ACTION_KEYS = COMMON_ACTION_KEYS;
+exports.DEFAULT_STOREFRONT_API_URL = DEFAULT_STOREFRONT_API_URL;
 exports.PaymentMethodType = PaymentMethodType;
 exports.SDK_VERSION = SDK_VERSION;
 exports.SUPPORTED_FRAMEWORKS = SUPPORTED_FRAMEWORKS;
+exports.buildFormFields = buildFormFields;
 exports.createAdmin = createAdmin;
 exports.createCartController = createCartController;
+exports.createFormEntry = createFormEntry;
+exports.createFormEntryFromValues = createFormEntryFromValues;
 exports.createStorefront = createStorefront;
+exports.initialize = initialize;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map