arky-sdk 0.9.20 → 0.10.0

package/dist/storefront.cjs

@@ -42,70 +42,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
           );
         },
@@ -117,13 +97,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
           );
         }
@@ -131,13 +111,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
           );
         }
@@ -146,85 +126,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
           );
         }
@@ -233,113 +187,90 @@ 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();
           return apiConfig.httpClient.get(
-            `${base(store_id)}/carts/${params.id}`,
+            `${base}/carts/${params.id}`,
             {
               ...options,
               params: params.token ? { token: params.token } : options?.params
             }
           );
         },
-        update(params, options) {
-          const { store_id, items, ...payload } = params;
-          const target = store_id || apiConfig.storeId;
+        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
@@ -349,115 +280,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 }
           );
         }
       }
@@ -471,36 +372,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
             );
@@ -510,110 +398,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,
+            `${base}/contact-lists/${params.id}/access`,
             options
           );
         },
-        manage(token, options) {
+        async checkContentAccess(params, options) {
+          await lifecycle.ensureVisitorSession();
           return apiConfig.httpClient.post(
-            `${base()}/contact-lists/manage`,
-            { token },
-            options
-          );
-        },
-        unsubscribe(token, options) {
-          const headers = { ...options?.headers };
-          for (const name of Object.keys(headers)) {
-            if (name.toLowerCase() === "content-type") delete headers[name];
-          }
-          return apiConfig.httpClient.post(
-            `${base()}/contact-lists/unsubscribe`,
-            new URLSearchParams({ "List-Unsubscribe": "One-Click" }),
-            {
-              ...options,
-              params: { ...options?.params || {}, token },
-              headers: {
-                ...headers,
-                "Content-Type": "application/x-www-form-urlencoded"
-              }
-            }
-          );
-        },
-        confirm(token, options) {
-          return apiConfig.httpClient.post(
-            `${base()}/contact-lists/confirm`,
-            { 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
         );
@@ -773,6 +625,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");
 }
@@ -848,10 +709,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;
@@ -862,7 +738,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,
@@ -893,8 +770,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");
@@ -975,13 +863,6 @@ function createHttpClient(cfg) {
 }
 
 // src/api/support.ts
-function supportConversationQuery(params) {
-  const qs = new URLSearchParams({ store_id: params.store_id });
-  if (params.message_limit) qs.set("message_limit", String(params.message_limit));
-  if (typeof params.after_created_at === "number") qs.set("after_created_at", String(params.after_created_at));
-  if (params.after_id) qs.set("after_id", params.after_id);
-  return qs.toString();
-}
 function storefrontSupportOptions(supportToken, options) {
   if (!/^[0-9a-f]{64}$/.test(supportToken)) {
     throw new Error("support_token must be a 64-character lowercase hexadecimal token");
@@ -998,32 +879,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)
       );
     }
@@ -1481,280 +1368,6 @@ function getFirstAvailableFCId(variant, quantity = 1) {
   return inv?.location_id;
 }
 
-// src/index.ts
-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
-  };
-}
-function defaultStorefrontSessionStorage() {
-  if (typeof window === "undefined") return null;
-  try {
-    return window.localStorage;
-  } catch {
-    return null;
-  }
-}
-function storefrontSessionStorageKey(baseUrl, storeId) {
-  const normalizedBaseUrl = baseUrl.trim().replace(/\/+$/, "").toLowerCase();
-  return `arky_contact_session:${encodeURIComponent(normalizedBaseUrl)}:${encodeURIComponent(storeId)}`;
-}
-function createStorefrontClient(config) {
-  const locale = config.locale || "en";
-  const initialMarket = config.market || "";
-  const listeners = /* @__PURE__ */ new Set();
-  let bareIdentifyPromise = null;
-  let identityTail = Promise.resolve();
-  const sessionStorage = config.sessionStorage || defaultStorefrontSessionStorage();
-  let memorySession = null;
-  function readContactSession() {
-    if (!sessionStorage) return memorySession;
-    try {
-      const raw = sessionStorage.getItem(
-        storefrontSessionStorageKey(config.baseUrl, config.storeId)
-      );
-      return raw ? JSON.parse(raw) : null;
-    } catch {
-      return memorySession;
-    }
-  }
-  function writeContactSession(session) {
-    memorySession = session;
-    if (!sessionStorage) return;
-    const key = storefrontSessionStorageKey(config.baseUrl, config.storeId);
-    try {
-      if (session) {
-        sessionStorage.setItem(key, JSON.stringify(session));
-      } else {
-        sessionStorage.removeItem(key);
-      }
-    } catch {
-    }
-  }
-  function toPublic(s) {
-    return s ? { contact: s.contact, store: s.store, market: s.market } : null;
-  }
-  function emit() {
-    const pub = toPublic(readContactSession());
-    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);
-    writeContactSession(next);
-    emit();
-  };
-  const authStorage = config.apiToken ? {
-    getTokens: () => ({ access_token: config.apiToken }),
-    onTokensRefreshed: () => {
-    },
-    onForcedLogout: () => {
-    }
-  } : {
-    getTokens() {
-      const s = readContactSession();
-      return s ? { access_token: s.access_token } : null;
-    },
-    onTokensRefreshed() {
-    },
-    onForcedLogout() {
-      bareIdentifyPromise = null;
-      updateSession(() => null);
-    }
-  };
-  const httpClient = createHttpClient({
-    baseUrl: config.baseUrl,
-    storeId: config.storeId,
-    refreshPath: config.refreshPath,
-    navigate: config.navigate,
-    loginFallbackPath: config.loginFallbackPath,
-    authStorage
-  });
-  const apiConfig = {
-    httpClient,
-    storeId: config.storeId,
-    baseUrl: config.baseUrl,
-    market: initialMarket,
-    locale,
-    authStorage
-  };
-  const storefrontApi = createStorefrontApi(apiConfig, updateSession);
-  const contactApi = storefrontApi.crm.contact;
-  function identify(params) {
-    if (params?.market !== void 0) apiConfig.market = params.market;
-    const market = apiConfig.market;
-    const isBareCall = !params?.email && !params?.verify;
-    if (isBareCall && bareIdentifyPromise) return bareIdentifyPromise;
-    const 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 promise = identityTail.then(run);
-    identityTail = promise.then(
-      () => void 0,
-      () => void 0
-    );
-    if (isBareCall) {
-      bareIdentifyPromise = promise;
-      void promise.then(
-        () => {
-          if (bareIdentifyPromise === promise) bareIdentifyPromise = null;
-        },
-        () => {
-          if (bareIdentifyPromise === promise) bareIdentifyPromise = null;
-        }
-      );
-    }
-    return promise;
-  }
-  async function verify(params) {
-    const result = await contactApi.verify(params);
-    bareIdentifyPromise = null;
-    return result;
-  }
-  async function logout() {
-    if (config.apiToken) return;
-    bareIdentifyPromise = null;
-    try {
-      await contactApi.logout();
-    } catch {
-      updateSession(() => null);
-    }
-  }
-  return {
-    identify,
-    verify,
-    logout,
-    me: () => contactApi.getMe(),
-    get session() {
-      if (config.apiToken) return null;
-      return toPublic(readContactSession());
-    },
-    get isAuthenticated() {
-      if (config.apiToken) return true;
-      const s = readContactSession();
-      return s !== null && !!s.access_token;
-    },
-    onAuthStateChanged(listener) {
-      listeners.add(listener);
-      const current = toPublic(readContactSession());
-      if (current) {
-        Promise.resolve().then(() => listener(current)).catch(() => {
-        });
-      }
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    store: storefrontApi.store,
-    cms: storefrontApi.cms,
-    eshop: storefrontApi.eshop,
-    crm: storefrontApi.crm,
-    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,
-    utils: createUtilitySurface(apiConfig)
-  };
-}
-function createStorefront(config) {
-  const sessionStorage = config.sessionStorage || defaultStorefrontSessionStorage() || void 0;
-  const scopedConfig = {
-    ...config,
-    sessionStorage
-  };
-  const client = createStorefrontClient(scopedConfig);
-  Object.defineProperty(client, "forStore", {
-    enumerable: true,
-    configurable: false,
-    writable: false,
-    value: (storeId) => createStorefront({
-      ...scopedConfig,
-      storeId,
-      market: client.getMarket(),
-      locale: client.getLocale()
-    })
-  });
-  return client;
-}
-
 // src/payments/stripe.ts
 async function defaultStripeLoader(publishableKey, options) {
   const { loadStripe } = await import('@stripe/stripe-js');
@@ -2131,22 +1744,24 @@ function normalizeTimezoneGroups(groups) {
 function firstFiniteNumber(...values) {
   return values.find((value) => typeof value === "number" && Number.isFinite(value));
 }
-function initializeStore(config) {
-  const client = createStorefront(config);
-  const formClients = /* @__PURE__ */ new Map([[client.getStoreId(), client]]);
+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(session, (value) => value?.market || null);
+  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(session, (value) => {
-    const store = value?.store;
-    const methods = value?.market?.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: store?.payment || null,
-      enabled: hasCreditCard && !!store?.payment
+      provider: setupValue?.payment || null,
+      enabled: hasCreditCard && Boolean(setupValue?.readiness.payment)
     };
   });
   const cart = nanostores.atom(null);
@@ -2242,24 +1857,17 @@ function initializeStore(config) {
   const service_form_blocks = nanostores.computed(service_form_groups, (groups) => groups.flatMap((group) => group.blocks));
   client.onAuthStateChanged((value) => session.set(value));
   currency.subscribe((value) => service_state.setKey("currency", value));
-  session.subscribe((value) => {
-    const methods = value?.market?.payment_methods || [];
+  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() || market.get()?.key || "";
+    return market_key.get() || client.getMarket() || setup.get()?.markets.default || "";
   }
   function currentLocale() {
-    return locale.get() || client.getLocale() || "en";
-  }
-  function clientForStore(storeId) {
-    const existing = formClients.get(storeId);
-    if (existing) return existing;
-    const scoped = client.forStore(storeId);
-    formClients.set(storeId, scoped);
-    return scoped;
+    return locale.get() || client.getLocale() || setup.get()?.languages.default || "en";
   }
   function currentStripePublishableKey() {
     const provider = payment_config.get()?.provider;
@@ -2289,10 +1897,24 @@ function initializeStore(config) {
   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 mountStripePayment(target, options = {}) {
-    const publishableKey = options.publishableKey || currentStripePublishableKey();
-    if (!publishableKey) {
-      throw new Error("Stripe publishable key is required to mount card payment");
+    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());
@@ -2308,8 +1930,8 @@ function initializeStore(config) {
       throw new Error("An explicit three-letter payment currency is required to mount card payment");
     }
     const controller = await createStripeConfirmationTokenController({
-      publishableKey,
-      connectedAccountId: options.connectedAccountId || currentStripeConnectedAccountId() || void 0,
+      publishableKey: publishableKey2,
+      connectedAccountId: currentStripeConnectedAccountId() || void 0,
       amount,
       currency: paymentCurrency,
       ...options.appearance ? { appearance: options.appearance } : {}
@@ -2321,15 +1943,11 @@ function initializeStore(config) {
   function updatePaymentController(input) {
     payment_controller.get()?.update(input);
   }
-  function marketForLocale(value) {
-    return config.marketForLocale?.(value) || null;
-  }
   async function ensureSession() {
     const current = session.get();
-    const marketKey = currentMarketKey();
-    if (current && (!marketKey || current.market?.key === marketKey)) return current;
+    if (client.isAuthenticated) return current;
     if (!sessionRequest) {
-      sessionRequest = identify({ market: marketKey }).finally(() => {
+      sessionRequest = identify().finally(() => {
         sessionRequest = null;
       });
     }
@@ -2342,9 +1960,7 @@ function initializeStore(config) {
       market: params.market || currentMarketKey()
     });
     session.set({
-      contact: result.contact,
-      store: result.store,
-      market: result.market
+      contact: result.contact
     });
     return result;
   }
@@ -2356,21 +1972,24 @@ function initializeStore(config) {
     return identify({ email: normalizedEmail });
   }
   function setMarket(key) {
-    market_key.set(key);
-    client.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, options = {}) {
+  function setLocale(value) {
     locale.set(value);
     client.setLocale(value);
-    const nextMarket = options.market || marketForLocale(value);
-    if (nextMarket) setMarket(nextMarket);
   }
   function setContext(context) {
-    if (context.locale) {
-      setLocale(context.locale, { market: context.market });
-      return;
-    }
-    if (context.market) setMarket(context.market);
+    if (context.market !== void 0) setMarket(context.market);
+    if (context.locale !== void 0) setLocale(context.locale);
   }
   async function ensureCart() {
     if (cartRequest) return cartRequest;
@@ -2379,9 +1998,7 @@ function initializeStore(config) {
     const refreshRevision = cartWriteRevision;
     cartRequest = (async () => {
       await ensureSession();
-      const response = await client.eshop.cart.current({
-        market: currentMarketKey()
-      });
+      const response = await client.eshop.cart.current();
       await applyCartResponse(response, { ifRevision: refreshRevision });
       return response;
     })();
@@ -2473,7 +2090,6 @@ function initializeStore(config) {
       const current = cart.get() || await ensureCart();
       const response = await client.eshop.cart.update({
         id: current.id,
-        market: currentMarketKey(),
         items: checkoutItems(input),
         shipping_address: input.shipping_address,
         billing_address: input.billing_address,
@@ -2889,7 +2505,7 @@ function initializeStore(config) {
     async initialize() {
       service_state.setKey("tzGroups", normalizeTimezoneGroups(client.utils.tzGroups));
       await ensureCart();
-      const methods = session.get()?.market?.payment_methods || [];
+      const methods = market.get()?.payment_methods || [];
       if (methods.length) service_state.setKey("availablePaymentMethods", methods);
     },
     setTimezone(tz) {
@@ -2938,7 +2554,9 @@ function initializeStore(config) {
           ...service_state.get(),
           service: fullService,
           serviceProviders,
-          providers: providerResults.filter((provider) => provider !== null),
+          providers: providerResults.filter(
+            (provider) => provider !== null
+          ),
           selectedProviderId: null,
           availability: null,
           selectedDate: null,
@@ -3152,7 +2770,7 @@ function initializeStore(config) {
         });
         service_state.setKey("cartId", cart.get()?.id || null);
         service_state.setKey("quote", response);
-        const methods = response?.payment_methods || session.get()?.market?.payment_methods || [];
+        const methods = response?.payment_methods || market.get()?.payment_methods || [];
         if (methods.length) service_state.setKey("availablePaymentMethods", methods);
         return response;
       } catch (error) {
@@ -3244,20 +2862,17 @@ function initializeStore(config) {
     }
   }
   function formCacheKey(params) {
-    const storeId = params.store_id || client.getStoreId();
     const identifier = params.id ? `id:${params.id}` : params.key ? `key:${params.key}` : "missing";
-    return `${storeId}:${identifier}`;
+    return identifier;
   }
   async function loadForm(params, options) {
     cms_state.setKey("loading", true);
     cms_state.setKey("error", null);
     try {
-      const storeId = params.store_id || client.getStoreId();
-      const formClient = clientForStore(storeId);
-      const form = await formClient.cms.form.get({ ...params, store_id: storeId }, options);
+      const form = await client.cms.form.get(params, options);
       const forms = { ...cms_state.get().forms };
-      forms[formCacheKey({ id: form.id, store_id: storeId })] = form;
-      forms[formCacheKey({ key: form.key, store_id: storeId })] = form;
+      forms[formCacheKey({ id: form.id })] = form;
+      forms[formCacheKey({ key: form.key })] = form;
       cms_state.setKey("forms", forms);
       return form;
     } catch (error) {
@@ -3267,26 +2882,14 @@ function initializeStore(config) {
       cms_state.setKey("loading", false);
     }
   }
-  async function ensureFormClient(storeId) {
-    const formClient = clientForStore(storeId);
-    const marketKey = currentMarketKey();
-    if (formClient === client) {
-      await ensureSession();
-    } else if (!formClient.session || marketKey && formClient.session.market?.key !== marketKey) {
-      await formClient.identify({ market: marketKey });
-    }
-    return formClient;
-  }
   async function submitForm(params, options) {
-    const storeId = params.store_id || client.getStoreId();
-    const formClient = await ensureFormClient(storeId);
-    return formClient.cms.form.submit({ ...params, store_id: storeId }, options);
+    await ensureSession();
+    return client.cms.form.submit(params, options);
   }
   async function submitFormByKey(params, options) {
-    const storeId = params.store_id || client.getStoreId();
-    const form = await loadForm({ key: params.key, store_id: storeId }, options);
+    const form = await loadForm({ key: params.key }, options);
     const entry = createFormEntryFromValues(form, params.values);
-    return submitForm({ store_id: storeId, form_id: form.id, fields: entry.fields }, options);
+    return submitForm({ form_id: form.id, fields: entry.fields }, options);
   }
   async function loadProducts(params = {}, options) {
     eshop_state.setKey("loading_products", true);
@@ -3448,6 +3051,7 @@ function initializeStore(config) {
   return {
     client,
     session,
+    setup,
     market,
     market_key,
     locale,
@@ -3466,7 +3070,6 @@ function initializeStore(config) {
     setMarket,
     setLocale,
     setContext,
-    getStoreId: client.getStoreId,
     getMarket: currentMarketKey,
     getLocale: currentLocale,
     cms: {
@@ -3510,31 +3113,400 @@ function initializeStore(config) {
       use: useExperiment
     },
     support: client.support,
-    store: client.store,
+    store: {
+      ...client.store,
+      setup,
+      load: loadSetup
+    },
     utils: client.utils
   };
 }
-function initialize(config) {
-  const stores = /* @__PURE__ */ new Map();
-  const createScope = (scopeConfig) => {
-    const existing = stores.get(scopeConfig.storeId);
-    if (existing) return existing;
-    const store = initializeStore(scopeConfig);
-    stores.set(scopeConfig.storeId, store);
-    Object.defineProperty(store, "forStore", {
-      enumerable: true,
-      configurable: false,
-      writable: false,
-      value: (storeId) => createScope({
-        ...config,
-        storeId,
-        market: store.getMarket(),
-        locale: store.getLocale()
-      })
+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
+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 DEFAULT_STOREFRONT_API_URL = "https://api.arky.io";
+var storefrontScopeSequence = 0;
+function defaultStorefrontSessionStorage() {
+  if (typeof window === "undefined") return null;
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+}
+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 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 identifyPromise = null;
+  let identityTail = Promise.resolve();
+  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;
+  let memorySessionToken = null;
+  function readSessionToken() {
+    if (!sessionStorage) return memorySessionToken;
+    try {
+      const stored = sessionStorage.getItem(storageKey);
+      return isVisitorSessionToken(stored) ? stored : memorySessionToken;
+    } catch {
+      return memorySessionToken;
+    }
+  }
+  function writeContactSession(session) {
+    memorySession = session;
+    memorySessionToken = session?.sessionToken || null;
+    if (!sessionStorage) return;
+    try {
+      if (session) {
+        sessionStorage.setItem(storageKey, session.sessionToken);
+      } else {
+        sessionStorage.removeItem(storageKey);
+      }
+    } catch {
+    }
+  }
+  function toPublic(s) {
+    return s ? { contact: s.contact } : null;
+  }
+  function emit() {
+    const pub = toPublic(memorySession);
+    for (const l of listeners) {
+      Promise.resolve().then(() => l(pub)).catch(() => {
+      });
+    }
+  }
+  const updateSession = (updater) => {
+    const next = updater(memorySession);
+    writeContactSession(next);
+    emit();
+  };
+  const authStorage = {
+    getTokens() {
+      const sessionToken = readSessionToken();
+      return sessionToken ? { access_token: sessionToken } : null;
+    },
+    onTokensRefreshed() {
+    },
+    onForcedLogout() {
+      identifyPromise = null;
+      updateSession(() => null);
+    }
+  };
+  let recoverUnauthorized = async () => false;
+  let visitorRecoveryPromise = null;
+  const httpClient = createHttpClient({
+    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,
+    apiUrl,
+    publishableKey,
+    market,
+    locale,
+    authStorage
+  };
+  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) {
+    requireVisitorSessionCapability();
+    if (params?.market !== void 0) setMarket(params.market);
+    const isBareCall = !params?.email && !params?.verify;
+    if (isBareCall && identifyPromise) return identifyPromise;
+    const run = async () => {
+      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(
+      () => void 0,
+      () => void 0
+    );
+    if (isBareCall) {
+      identifyPromise = promise;
+      void promise.then(
+        () => {
+          if (identifyPromise === promise) identifyPromise = null;
+        },
+        () => {
+          if (identifyPromise === promise) identifyPromise = null;
+        }
+      );
+    }
+    return promise;
+  }
+  async function verify(params) {
+    requireVisitorSessionCapability();
+    const result = await contactApi.verify(params);
+    identifyPromise = null;
+    return { contact: result.contact };
+  }
+  async function me() {
+    await ensureVisitorSession();
+    return contactApi.getMe();
+  }
+  async function logout() {
+    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;
+      }
     });
-    return store;
+    visitorRecoveryPromise = trackedRecovery;
+    await trackedRecovery;
+    return true;
+  };
+  return {
+    identify,
+    verify,
+    logout,
+    me,
+    get session() {
+      return toPublic(memorySession);
+    },
+    get isAuthenticated() {
+      return Boolean(readSessionToken());
+    },
+    onAuthStateChanged(listener) {
+      listeners.add(listener);
+      const current = toPublic(memorySession);
+      if (current) {
+        Promise.resolve().then(() => listener(current)).catch(() => {
+        });
+      }
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    store: storefrontApi.store,
+    cms: storefrontApi.cms,
+    eshop: storefrontApi.eshop,
+    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, ensureVisitorSession),
+    getSetup,
+    setContext,
+    setMarket,
+    getMarket: () => market,
+    setLocale,
+    getLocale: () => locale,
+    utils: createUtilitySurface(apiConfig)
   };
-  return createScope(config);
+}
+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
+      );
+    }
+  });
+}
+function createStorefront(publishableKey, options = {}) {
+  return createStorefrontClient(publishableKey, options);
 }
 
 exports.COMMON_ACTION_KEYS = COMMON_ACTION_KEYS;