@juo/blocks 2.0.0-alpha.1 → 2.0.0-alpha.10

package/dist/core.js

@@ -3,12 +3,33 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { e as createContext, f as d, m as w, n as defineBlock, h as createBlockInstance, j as getDefinedBlocks, p as registerBlock, E, u, s as subscribeContext } from "./block-BjJztStr.js";
 import { B, q, t, S, v, _, x, c, y, g, z, A, D, F, G, i, H, b, I, o, J, k, K, l, L, w as w2 } from "./block-BjJztStr.js";
-import { G as GRID_V1_ENGINE_ID, d as clampRect, e as applyFillExpansion, f as compactItems, g as findFreeRect, D as DEFAULT_GRID } from "./css-runtime-B7tZrBIp.js";
-import { h, i as i2, L as L2, P, a, T, b as b2, j, k as k2, l as l2, m, n, o as o2, p, q as q2, s, t as t2, u as u2, v as v2, c as c2, w as w3, r } from "./css-runtime-B7tZrBIp.js";
+import { G as GRID_V1_ENGINE_ID, d as clampRect, e as applyFillExpansion, f as compactItems, g as findFreeRect, D as DEFAULT_GRID } from "./css-runtime-CjZl0K48.js";
+import { h, i as i2, L as L2, P, a, T, b as b2, j, k as k2, l as l2, m, n, o as o2, p, q as q2, s, t as t2, u as u2, v as v2, c as c2, w as w3, r } from "./css-runtime-CjZl0K48.js";
 import { reportBlockWarning, reportBlockError } from "./observability.js";
-import { a as createEditorBridge, E as createSelectBlockMessage } from "./bridge-Mz0CqG6E.js";
-import { p as p2 } from "./project-gridstack-PxN_DIfP.js";
+import { a as createEditorBridge, E as createSelectBlockMessage } from "./bridge-Bss7Xq3D.js";
+import { p as p2 } from "./project-gridstack-CRZ_7HoT.js";
 import { clearLayoutModeAdapter, getLayoutModeAdapter, registerLayoutModeAdapter } from "./layout-mode-adapter-BBd4JRQd.js";
+const SUPPORTED_UI_LANGUAGES = [
+  { code: "cs", label: "Czech" },
+  { code: "da", label: "Danish" },
+  { code: "nl", label: "Dutch" },
+  { code: "en", label: "English" },
+  { code: "fr", label: "French" },
+  { code: "de", label: "German" },
+  { code: "el", label: "Greek" },
+  { code: "hu", label: "Hungarian" },
+  { code: "pl", label: "Polish" },
+  { code: "pt", label: "Portuguese" },
+  { code: "sk", label: "Slovak" },
+  { code: "sl", label: "Slovenian" },
+  { code: "es", label: "Spanish" }
+];
+function toLanguageSelectOptions(languages) {
+  return languages.map(({ code, label }) => ({ label, value: code }));
+}
+const SUPPORTED_UI_LANGUAGE_OPTIONS = toLanguageSelectOptions(
+  SUPPORTED_UI_LANGUAGES
+);
 function createState() {
   const discountCode = d(null);
   const products = d([]);
@@ -273,33 +294,233 @@ function createCustomerService(options) {
       const result = await options.adapter.getCurrent();
       if (result._tag === "Success") current.value = result.data;
       return result;
+    },
+    createPaymentMethod(params) {
+      return options.adapter.createPaymentMethod(params);
+    },
+    async updateAttributes(attributes) {
+      var _a;
+      const merged = { ...(_a = current.value) == null ? void 0 : _a.attributes, ...attributes };
+      const result = await options.adapter.updateAttributes(merged);
+      if (result._tag === "Success") current.value = result.data;
+      return result;
     }
   };
 }
 const CustomerServiceContext = createContext("services/customer");
+const PAYMENT_INSTRUMENT_TYPES = [
+  "credit_card",
+  "paypal",
+  "shop_pay",
+  "sepa_direct_debit",
+  "blik",
+  "mbway",
+  "bacs",
+  "manual"
+];
+const INSTRUMENT_TYPE_TO_NAME = {
+  credit_card: null,
+  paypal: "PayPal",
+  blik: "BLIK",
+  sepa_direct_debit: "SEPA",
+  mbway: "MB WAY",
+  shop_pay: "Shop Pay",
+  bacs: "Bacs",
+  manual: "Shopify Checkout"
+};
+function getPaymentInstrumentName(instrument) {
+  const name = INSTRUMENT_TYPE_TO_NAME[instrument.type] ?? null;
+  if (name != null) return name;
+  return instrument.type === "credit_card" ? instrument.brand || instrument.type : instrument.type;
+}
+function getPaymentInstrumentDigits(instrument) {
+  switch (instrument.type) {
+    case "credit_card":
+    case "shop_pay":
+    case "bacs":
+      return instrument.maskedNumber.slice(-4) || null;
+    case "sepa_direct_debit":
+      return instrument.consumerAccount.slice(-4) || null;
+    default:
+      return null;
+  }
+}
+function getPaymentInstrumentDetail(instrument) {
+  switch (instrument.type) {
+    case "paypal":
+      return instrument.paypalAccountEmail ?? null;
+    case "sepa_direct_debit":
+      return instrument.consumerName ?? null;
+    case "blik":
+      return instrument.label ?? null;
+    case "mbway":
+      return instrument.phone ?? null;
+    default:
+      return null;
+  }
+}
+function getPaymentInstrumentExpiry(instrument, now = /* @__PURE__ */ new Date()) {
+  if (instrument.type !== "credit_card" && instrument.type !== "shop_pay") {
+    return null;
+  }
+  const { expiryMonth: month, expiryYear: year } = instrument;
+  if (month == null || year == null) return null;
+  const nowYear = now.getFullYear();
+  const nowMonth = now.getMonth() + 1;
+  const expiresThisMonth = year === nowYear && month === nowMonth;
+  const isExpired = year < nowYear || year === nowYear && month < nowMonth;
+  return { month, year, isExpired, expiresThisMonth };
+}
+function serializeV1PaymentInstrument(raw) {
+  if (raw == null || typeof raw !== "object") return null;
+  const r2 = raw;
+  if (typeof r2.type !== "string") return null;
+  switch (r2.type) {
+    case "credit-card":
+      return {
+        type: "credit_card",
+        brand: r2.brand ?? "",
+        maskedNumber: r2.maskedNumber ?? "",
+        ...r2.expiryMonth != null ? { expiryMonth: r2.expiryMonth } : {},
+        ...r2.expiryYear != null ? { expiryYear: r2.expiryYear } : {},
+        ...r2.cardholderName != null ? { cardholderName: r2.cardholderName } : {}
+      };
+    case "paypal":
+      return { type: "paypal", paypalAccountEmail: r2.paypalAccountEmail ?? null };
+    case "shop-pay":
+      return {
+        type: "shop_pay",
+        maskedNumber: r2.maskedNumber ?? "",
+        ...r2.expiryMonth != null ? { expiryMonth: r2.expiryMonth } : {},
+        ...r2.expiryYear != null ? { expiryYear: r2.expiryYear } : {},
+        ...r2.cardholderName != null ? { cardholderName: r2.cardholderName } : {}
+      };
+    case "sepa-direct-debit":
+      return {
+        type: "sepa_direct_debit",
+        consumerName: r2.consumerName ?? "",
+        consumerBic: r2.consumerBic ?? null,
+        consumerAccount: r2.maskedConsumerAccount ?? ""
+      };
+    case "blik":
+      return { type: "blik" };
+    case "mbway":
+      return { type: "mbway", ...r2.phone != null ? { phone: r2.phone } : {} };
+    case "bacs":
+      return { type: "bacs", maskedNumber: r2.maskedNumber ?? "" };
+    case "manual":
+      return { type: "manual" };
+    default:
+      return null;
+  }
+}
 function createMockCustomerAdapter() {
-  const customer = { id: "customer-1", name: "Customer 1" };
+  let customer = { id: "customer-1", name: "Customer 1", attributes: {} };
   return {
     async getCurrent() {
       return { _tag: "Success", data: customer };
+    },
+    async updateAttributes(attributes) {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      customer = { ...customer, attributes: { ...attributes } };
+      return { _tag: "Success", data: customer };
+    },
+    async createPaymentMethod(params) {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      if (params.provider === "shopify") {
+        return {
+          _tag: "Success",
+          data: {
+            kind: "email_sent",
+            paymentMethodId: "pm_mock_1",
+            instrument: { type: "credit_card", brand: "visa", maskedNumber: "•••• 4242" }
+          }
+        };
+      }
+      if (params.provider === "mollie") {
+        return {
+          _tag: "Success",
+          data: { kind: "redirect", redirectUrl: params.returnUrl }
+        };
+      }
+      return { _tag: "Failure", error: new Error(`Payment provider "${params.provider}" is not supported`) };
     }
   };
 }
+function fromV1Customer(body) {
+  return {
+    id: body.id,
+    name: body.displayName,
+    email: body.email ?? void 0,
+    attributes: Object.fromEntries(
+      body.customAttributes.map(({ key, value }) => [key, value])
+    )
+  };
+}
 function createApiCustomerAdapter(fetcher) {
   return {
     async getCurrent() {
       try {
-        const res = await fetcher("/customer/info");
+        const res = await fetcher("/customer/v1/customer");
         if (!res.ok) return { _tag: "Failure", error: `HTTP ${res.status}` };
-        const data = await res.json();
-        const name = [data.firstName, data.lastName].filter(Boolean).join(" ") || data.email || "";
         return {
           _tag: "Success",
-          data: { id: data.id, name, email: data.email }
+          data: fromV1Customer(await res.json())
         };
       } catch (e) {
         return { _tag: "Failure", error: e };
       }
+    },
+    async updateAttributes(attributes) {
+      try {
+        const res = await fetcher("/customer/v1/customer", {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ customAttributes: attributes })
+        });
+        if (!res.ok) return { _tag: "Failure", error: `HTTP ${res.status}` };
+        return {
+          _tag: "Success",
+          data: fromV1Customer(await res.json())
+        };
+      } catch (e) {
+        return { _tag: "Failure", error: e };
+      }
+    },
+    async createPaymentMethod(params) {
+      try {
+        if (params.provider === "shopify") {
+          const res = await fetcher("/customer/v1/payment-methods", {
+            method: "POST"
+          });
+          if (!res.ok) return { _tag: "Failure", error: `HTTP ${res.status}` };
+          const body = await res.json();
+          return {
+            _tag: "Success",
+            data: {
+              kind: "email_sent",
+              paymentMethodId: body.id,
+              instrument: serializeV1PaymentInstrument(body.instrument) ?? void 0
+            }
+          };
+        }
+        if (params.provider === "mollie") {
+          const res = await fetcher("/customer/payment-methods", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ redirectUrl: params.returnUrl })
+          });
+          if (!res.ok) return { _tag: "Failure", error: `HTTP ${res.status}` };
+          const body = await res.json();
+          return {
+            _tag: "Success",
+            data: { kind: "redirect", redirectUrl: body.redirectUrl }
+          };
+        }
+        return { _tag: "Failure", error: new Error(`Payment provider "${params.provider}" is not supported`) };
+      } catch (e) {
+        return { _tag: "Failure", error: e };
+      }
     }
   };
 }
@@ -319,6 +540,33 @@ function uuid() {
     (c3) => (c3 ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c3 / 4).toString(16)
   );
 }
+const REFRESH_LOCK_NAME = "juo:auth:refresh";
+const LOCK_WAIT_TIMEOUT_MS = 1e4;
+let fallbackQueue = Promise.resolve();
+function runQueued(run) {
+  const result = fallbackQueue.then(run, run);
+  fallbackQueue = result.catch(() => void 0);
+  return result;
+}
+function withRefreshLock(run) {
+  const locks = typeof navigator === "undefined" ? void 0 : navigator.locks;
+  if (locks == null) {
+    return runQueued(run);
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), LOCK_WAIT_TIMEOUT_MS);
+  let granted = false;
+  return locks.request(REFRESH_LOCK_NAME, { signal: controller.signal }, () => {
+    granted = true;
+    clearTimeout(timer);
+    return run();
+  }).catch((error) => {
+    if (!granted && controller.signal.aborted) {
+      return run();
+    }
+    throw error;
+  }).finally(() => clearTimeout(timer));
+}
 function createMockLoginAdapter(opts = {}) {
   const appUrl = opts.appUrl ?? "https://admin.juo.io";
   return {
@@ -418,6 +666,12 @@ function createApiLoginAdapter(fetcher, opts) {
             });
           }
         }
+        if (res.status === 401) {
+          const data = await res.json().catch(() => null);
+          if (data != null && typeof data === "object" && "message" in data && data.message === "Customer not found") {
+            throw new AuthenticationError(AuthenticationErrorReason.Missing);
+          }
+        }
         if (!res.ok) {
           throw new Error(`Unexpected response: ${res.statusText}`);
         }
@@ -457,20 +711,61 @@ class AuthenticationError extends Error {
 const STORAGE_DELEGATED_TOKEN = "delegated-token";
 const STORAGE_REFRESH_TOKEN_KEY = "refresh-token";
 const STORAGE_STATE_KEY = "state";
-function storage(key, value) {
-  const storageKey = `auth:${key}`;
+function webStorage(kind) {
   try {
-    if (value === null) {
-      sessionStorage.removeItem(storageKey);
-    } else if (value !== void 0) {
-      sessionStorage.setItem(storageKey, value);
-    } else {
-      return sessionStorage.getItem("auth:" + key);
+    return (kind === "local" ? localStorage : sessionStorage) ?? null;
+  } catch (error) {
+    console.warn(`Failed to reach ${kind} storage: ${error}`);
+    return null;
+  }
+}
+function readFrom(store, key) {
+  try {
+    return (store == null ? void 0 : store.getItem(key)) ?? null;
+  } catch (error) {
+    console.warn(`Failed to read web storage: ${error}`);
+    return null;
+  }
+}
+function writeTo(store, key, value) {
+  try {
+    if (store != null && store.getItem(key) !== value) {
+      store.setItem(key, value);
     }
   } catch (error) {
-    console.warn(`Failed to use session storage: ${error}`);
+    console.warn(`Failed to write web storage: ${error}`);
+  }
+}
+function removeFrom(store, key) {
+  try {
+    store == null ? void 0 : store.removeItem(key);
+  } catch (error) {
+    console.warn(`Failed to clear web storage: ${error}`);
   }
-  return null;
+}
+function storage(key, value) {
+  const storageKey = `auth:${key}`;
+  const isRefreshToken = key === STORAGE_REFRESH_TOKEN_KEY;
+  const store = webStorage(isRefreshToken ? "local" : "session");
+  const legacyStore = isRefreshToken ? webStorage("session") : null;
+  if (value === null) {
+    removeFrom(store, storageKey);
+    removeFrom(legacyStore, storageKey);
+    return null;
+  }
+  if (value !== void 0) {
+    writeTo(store, storageKey, value);
+    return null;
+  }
+  const stored = readFrom(store, storageKey);
+  if (stored !== null || legacyStore == null) {
+    return stored;
+  }
+  const legacy = readFrom(legacyStore, storageKey);
+  if (legacy !== null) {
+    writeTo(store, storageKey, legacy);
+  }
+  return legacy;
 }
 function nonce(len = 10) {
   return uuid().replace(/-/g, "").slice(0, len);
@@ -510,25 +805,75 @@ function createLoginService(init) {
   E(() => {
     storage(STORAGE_STATE_KEY, state.value);
   });
+  if (typeof window !== "undefined") {
+    window.addEventListener("storage", (event) => {
+      if (event.storageArea !== webStorage("local") || event.key !== `auth:${STORAGE_REFRESH_TOKEN_KEY}`) {
+        return;
+      }
+      if (event.newValue == null) {
+        accessToken.value = null;
+        expires.value = null;
+        refreshToken.value = null;
+        return;
+      }
+      if (event.newValue !== refreshToken.value) {
+        refreshToken.value = event.newValue;
+      }
+    });
+  }
   function storeTokens(data) {
     const { access_token, refresh_token, expires_in } = data;
     accessToken.value = access_token;
-    refreshToken.value = refresh_token;
-    expires.value = new Date(Date.now() + expires_in);
+    if (typeof refresh_token === "string" && refresh_token !== "") {
+      refreshToken.value = refresh_token;
+    }
+    const lifetime = Number.isFinite(expires_in) ? expires_in : 300;
+    const margin = Math.min(60, lifetime / 2);
+    expires.value = new Date(Date.now() + (lifetime - margin) * 1e3);
+  }
+  async function rotate(token) {
+    const result = await adapter.authenticate({ refreshToken: token });
+    if (result._tag === "Failure") {
+      throw result.error;
+    }
+    if (refreshToken.value === token) {
+      storeTokens(result.data);
+    } else {
+      accessToken.value = null;
+      expires.value = null;
+    }
+    return result.data.access_token;
+  }
+  async function refreshLocked() {
+    const stored = storage(STORAGE_REFRESH_TOKEN_KEY);
+    if (stored != null && stored !== refreshToken.value) {
+      refreshToken.value = stored;
+    }
+    const current = refreshToken.value;
+    if (current == null) {
+      throw new AuthenticationError(
+        "expired"
+        /* Expired */
+      );
+    }
+    try {
+      return await rotate(current);
+    } catch (error) {
+      const latest = storage(STORAGE_REFRESH_TOKEN_KEY);
+      if (latest != null && latest !== current) {
+        refreshToken.value = latest;
+        return await rotate(latest);
+      }
+      throw error;
+    }
   }
   async function getToken() {
     if (refreshToken.value == null) return null;
     if (accessToken.value == null || typeof accessToken.value === "string" && (expires.value == null || expires.value < /* @__PURE__ */ new Date())) {
-      accessToken.value = new Promise(
-        (resolve, reject) => adapter.authenticate({ refreshToken: refreshToken.value }).then((result) => {
-          if (result._tag === "Failure") {
-            reject(result.error);
-            return;
-          }
-          storeTokens(result.data);
-          resolve(result.data.access_token);
-        }).catch(reject)
-      );
+      accessToken.value = withRefreshLock(refreshLocked).catch((error) => {
+        accessToken.value = null;
+        throw error;
+      });
     }
     return Promise.resolve(accessToken.value);
   }
@@ -691,7 +1036,10 @@ function createMockOrderAdapter() {
       currencyCode: "USD",
       totalPrice: 89.97,
       financialStatus: "PAID",
+      paymentStatus: "paid",
+      paidAt: "2024-10-15T09:31:00Z",
       fulfillmentStatus: "FULFILLED",
+      subscriptionIds: ["subscription_1"],
       lines: [
         {
           id: "line_1",
@@ -716,7 +1064,10 @@ function createMockOrderAdapter() {
       currencyCode: "USD",
       totalPrice: 45.99,
       financialStatus: "PAID",
+      paymentStatus: "paid",
+      paidAt: "2024-09-20T14:16:00Z",
       fulfillmentStatus: "PARTIALLY_FULFILLED",
+      subscriptionIds: [],
       lines: [
         {
           id: "line_2",
@@ -761,11 +1112,28 @@ function mapOrder(order) {
     currencyCode: order.currencyCode,
     totalPrice: order.totalPrice,
     financialStatus: order.financialStatus,
+    // Defaulted rather than required so an older backend (which returns neither
+    // field) degrades to "settled, time unknown" instead of producing an Order
+    // with holes in it. Matches the endpoint's own fallback for an order it
+    // never tracked.
+    paymentStatus: order.paymentStatus ?? "paid",
+    paidAt: order.paidAt ?? null,
     fulfillmentStatus: order.fulfillmentStatus,
     lines: order.items.map(mapOrderLine),
-    customAttributes: order.customAttributes
+    customAttributes: order.customAttributes,
+    subscriptionIds: order.subscriptionIds ?? []
   };
 }
+function quoteSearchValue(value) {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function buildOrdersQuery(params) {
+  const callerQuery = (params == null ? void 0 : params.query) != null && params.query.trim() !== "" ? params.query : null;
+  const subscriptionTerm = (params == null ? void 0 : params.subscriptionId) != null ? `subscriptionId:${quoteSearchValue(params.subscriptionId)}` : null;
+  if (callerQuery == null) return subscriptionTerm;
+  if (subscriptionTerm == null) return callerQuery;
+  return `(${callerQuery}) AND ${subscriptionTerm}`;
+}
 function createApiOrderAdapter(fetcher) {
   return {
     async getOrders(params) {
@@ -773,9 +1141,10 @@ function createApiOrderAdapter(fetcher) {
       if ((params == null ? void 0 : params.limit) != null) query.set("limit", String(params.limit));
       if ((params == null ? void 0 : params.after) != null) query.set("after", params.after);
       if ((params == null ? void 0 : params.before) != null) query.set("before", params.before);
-      if ((params == null ? void 0 : params.query) != null) query.set("query", params.query);
       if ((params == null ? void 0 : params.includeOneTime) != null) query.set("includeOneTime", String(params.includeOneTime));
       if ((params == null ? void 0 : params.sort) != null) query.set("sort", params.sort);
+      const searchQuery = buildOrdersQuery(params);
+      if (searchQuery != null) query.set("query", searchQuery);
       const qs = query.toString();
       const res = await fetcher(`/customer/v1/orders${qs ? `?${qs}` : ""}`);
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
@@ -1064,6 +1433,13 @@ function mapVariant(variant, currencyCode) {
     } : {}
   };
 }
+const IDENTIFIER = String.raw`[a-zA-Z0-9]+(?:\.[a-zA-Z0-9]+)*`;
+const VALUE = String.raw`(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|${IDENTIFIER})`;
+const TERM = String.raw`(?:NOT\s+|-)?${IDENTIFIER}:(?:>=|<=|>|<)?${VALUE}`;
+const FILTER_QUERY = new RegExp(String.raw`^${TERM}(?:\s+(?:AND|OR)\s+${TERM})*$`);
+function isFilterQuery(query) {
+  return FILTER_QUERY.test(query);
+}
 function mapProduct(product, currencyCode) {
   return {
     id: product.id,
@@ -1116,7 +1492,11 @@ function createApiProductAdapter(fetcher, opts = { currencyCode: "USD" }) {
       try {
         const params = new URLSearchParams();
         if (opts2 == null ? void 0 : opts2.query) {
-          params.set("query", `"${opts2.query.trim().replace(/"/g, '\\"')}"`);
+          const trimmed = opts2.query.trim();
+          params.set(
+            "query",
+            isFilterQuery(trimmed) ? trimmed : `"${trimmed.replace(/"/g, '\\"')}"`
+          );
         }
         if (opts2 == null ? void 0 : opts2.pagination) {
           if ("after" in opts2.pagination)
@@ -1310,6 +1690,49 @@ const DISCOUNT_REJECTION_REASONS = [
 function toAttributeArray(next) {
   return Object.entries(next).map(([key, value]) => ({ key, value }));
 }
+const MOCK_SHIPPING_METHODS = [
+  {
+    handle: "standard-shipping",
+    title: "Standard shipping",
+    price: { amount: "0.00", currencyCode: "EUR" }
+  },
+  {
+    handle: "dhl-express",
+    title: "DHL Express",
+    price: { amount: "9.99", currencyCode: "EUR" }
+  },
+  {
+    handle: "next-day",
+    title: "Next day delivery",
+    price: { amount: "14.99", currencyCode: "EUR" }
+  }
+];
+function toShippingAddressBody(address) {
+  return {
+    firstName: address.firstName,
+    lastName: address.lastName,
+    address1: address.address1,
+    zip: address.zip,
+    city: address.city,
+    ...address.address2 ? { address2: address.address2 } : {},
+    ...address.province ? { province: address.province } : {},
+    ...address.phone ? { phone: address.phone } : {},
+    ...address.company ? { company: address.company } : {}
+  };
+}
+function isStaleSubscriptionMessage(message) {
+  return message ? message.toLowerCase().includes("changed since last fetch") : false;
+}
+function toNonEmptyAttributeArray(next) {
+  if (next == null) return [];
+  return toAttributeArray(next).filter(
+    ({ key, value }) => key !== "" && value !== ""
+  );
+}
+const MOCK_INSTANT_ORDER_MIN_ITEMS = 1;
+const MOCK_INSTANT_ORDER_MAX_ITEMS = 20;
+const MOCK_INSTANT_ORDER_MIN_QUANTITY = 1;
+const MOCK_INSTANT_ORDER_MAX_QUANTITY = 10;
 function createMockSubscriptionAdapter(options = {}) {
   const richBase = (id, itemId, renewalId) => ({
     id,
@@ -1373,7 +1796,24 @@ function createMockSubscriptionAdapter(options = {}) {
     renewal: { id: renewalId, isInActiveProcessState: false },
     lastPaymentStatus: "succeeded",
     pausePeriod: null,
-    isEditable: true
+    isEditable: true,
+    // Shaped like the v1 mapping produces it: one option slot filled, no
+    // presentmentTitle (v1 has no such field). Previews would otherwise render
+    // ContractSelect's address / method rows as "-".
+    deliveryMethod: {
+      address: {
+        firstName: "Ada",
+        lastName: "Lovelace",
+        address1: "Wilcza 12/4",
+        zip: "00-538",
+        city: "Warsaw",
+        country: "Poland",
+        countryCode: "PL"
+      },
+      shippingOption: { title: "Standard shipping" },
+      pickupOption: null,
+      localDeliveryOption: null
+    }
   });
   const mockSubscriptions = [
     {
@@ -1442,6 +1882,20 @@ function createMockSubscriptionAdapter(options = {}) {
       lastPaymentStatus: "succeeded",
       pausePeriod: null,
       isEditable: true,
+      deliveryMethod: {
+        address: {
+          firstName: "Ada",
+          lastName: "Lovelace",
+          address1: "Wilcza 12/4",
+          zip: "00-538",
+          city: "Warsaw",
+          country: "Poland",
+          countryCode: "PL"
+        },
+        shippingOption: { title: "DHL Express" },
+        pickupOption: null,
+        localDeliveryOption: null
+      },
       customAttributes: [
         { key: "subscription_tier", value: "premium" },
         { key: "gift_message", value: "Enjoy your skincare routine!" }
@@ -1473,6 +1927,14 @@ function createMockSubscriptionAdapter(options = {}) {
       frequency: "2 WEEK",
       createdAt: "2024-09-15T00:00:00Z",
       updatedAt: "2024-10-10T00:00:00Z",
+      // Pickup, with no address — the other branch of the option coalescing in
+      // ContractSelect's delivery-method label.
+      deliveryMethod: {
+        address: null,
+        shippingOption: null,
+        pickupOption: { title: "Pickup in store" },
+        localDeliveryOption: null
+      },
       customAttributes: []
     },
     // Per-status fixtures: groundwork for the deferred editor preview picker
@@ -1481,18 +1943,55 @@ function createMockSubscriptionAdapter(options = {}) {
     {
       ...richBase("sub_paused", "item_paused", "ren_paused"),
       status: "paused",
-      pausePeriod: { start: "2025-11-01T00:00:00Z", end: "2026-01-01T00:00:00Z" }
+      pausePeriod: { start: "2025-11-01T00:00:00Z", end: "2026-01-01T00:00:00Z" },
+      // BLIK with a non-recurring alias — the shape that gates the
+      // re-authorization prompt in RenewalSummary. Only the legacy-sourced
+      // payment method can express this, so previews would otherwise never
+      // exercise the branch.
+      customerPaymentMethod: {
+        id: "pm_blik",
+        instrument: { type: "blik", label: "my-blik-alias" },
+        active: true,
+        isRecurring: false
+      }
     },
     {
       ...richBase("sub_canceled", "item_canceled", "ren_canceled"),
       status: "canceled",
-      pausePeriod: null
+      pausePeriod: null,
+      // SEPA — identified by a masked IBAN rather than card digits.
+      customerPaymentMethod: {
+        id: "pm_sepa",
+        instrument: {
+          type: "sepa_direct_debit",
+          consumerName: "Ada Lovelace",
+          consumerBic: "ABCDEFGH",
+          consumerAccount: "DE12****6789"
+        },
+        active: true,
+        isRecurring: true
+      }
     },
     {
       ...richBase("sub_failed", "item_failed", "ren_failed"),
       status: "failed",
       lastPaymentStatus: "failed",
-      pausePeriod: null
+      pausePeriod: null,
+      // An expired card — pairs with the failed payment, and exercises
+      // getPaymentInstrumentExpiry's isExpired branch.
+      customerPaymentMethod: {
+        id: "pm_expired_card",
+        instrument: {
+          type: "credit_card",
+          brand: "mastercard",
+          maskedNumber: "************5100",
+          expiryMonth: 1,
+          expiryYear: 2024,
+          cardholderName: "Ada Lovelace"
+        },
+        active: true,
+        isRecurring: true
+      }
     },
     {
       ...richBase("sub_expired", "item_expired", "ren_expired"),
@@ -1518,6 +2017,60 @@ function createMockSubscriptionAdapter(options = {}) {
       description: "Lightweight daily sun protection"
     }
   ];
+  const mockInstantOrderImages = {
+    "io-product-1": "https://images.unsplash.com/photo-1447933601403-0c6688de566e?w=200",
+    "io-product-2": "https://images.unsplash.com/photo-1495474472287-4d71bcdd2085?w=200"
+  };
+  const mockInstantOrderProducts = [
+    {
+      id: "io-product-1",
+      title: "Single-Origin Espresso",
+      hasOnlyDefaultVariant: false,
+      featuredImage: {
+        url: mockInstantOrderImages["io-product-1"],
+        altText: "Single-Origin Espresso"
+      },
+      variants: {
+        items: [
+          {
+            id: "io-variant-1",
+            title: "250 g",
+            image: { url: mockInstantOrderImages["io-product-1"] },
+            price: { amount: "12.00", currencyCode: "USD" },
+            availableForSale: true
+          },
+          {
+            id: "io-variant-2",
+            title: "1 kg",
+            image: { url: mockInstantOrderImages["io-product-1"] },
+            price: { amount: "38.00", currencyCode: "USD" },
+            availableForSale: true
+          }
+        ]
+      }
+    },
+    {
+      id: "io-product-2",
+      title: "Ceramic Pour-Over Dripper",
+      hasOnlyDefaultVariant: true,
+      featuredImage: {
+        url: mockInstantOrderImages["io-product-2"],
+        altText: "Ceramic Pour-Over Dripper"
+      },
+      variants: {
+        items: [
+          {
+            id: "io-variant-3",
+            title: "Default Title",
+            image: { url: mockInstantOrderImages["io-product-2"] },
+            price: { amount: "24.50", currencyCode: "USD" },
+            availableForSale: true
+          }
+        ]
+      }
+    }
+  ];
+  let placedInstantOrders = 0;
   return {
     async getById(id) {
       await new Promise((resolve) => setTimeout(resolve, 300));
@@ -1588,8 +2141,11 @@ function createMockSubscriptionAdapter(options = {}) {
         ...variant && product && !product.hasOnlyDefaultVariant ? { variantTitle: variant.title } : {},
         ...(variant == null ? void 0 : variant.image) ? { variantImage: variant.image } : {},
         variantAvailableForSale: true,
-        billingPolicy: ((_f = subscription.items[0]) == null ? void 0 : _f.billingPolicy) ?? subscription.billingPolicy ?? null,
-        deliveryPolicy: ((_g = subscription.items[0]) == null ? void 0 : _g.deliveryPolicy) ?? subscription.deliveryPolicy ?? null
+        // An explicit per-line billingPolicy wins; otherwise inherit the plan's.
+        billingPolicy: item.billingPolicy ?? ((_f = subscription.items[0]) == null ? void 0 : _f.billingPolicy) ?? subscription.billingPolicy ?? null,
+        deliveryPolicy: ((_g = subscription.items[0]) == null ? void 0 : _g.deliveryPolicy) ?? subscription.deliveryPolicy ?? null,
+        ...item.recurringCycleLimit != null ? { recurringCycleLimit: item.recurringCycleLimit } : {},
+        ...item.customAttributes != null ? { customAttributes: toAttributeArray(item.customAttributes) } : {}
       });
       subscription.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       return { _tag: "Success", data: void 0 };
@@ -1617,6 +2173,9 @@ function createMockSubscriptionAdapter(options = {}) {
       if (update.variantId !== void 0) item.variantId = update.variantId;
       if (update.quantity !== void 0) item.quantity = update.quantity;
       if (update.billingPolicy !== void 0) item.billingPolicy = update.billingPolicy;
+      if (update.customAttributes !== void 0) {
+        item.customAttributes = toAttributeArray(update.customAttributes);
+      }
       subscription.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       return { _tag: "Success", data: void 0 };
     },
@@ -1703,6 +2262,92 @@ function createMockSubscriptionAdapter(options = {}) {
       subscription.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       return { _tag: "Success", data: { ...subscription } };
     },
+    async updateDeliveryAddress({
+      subscriptionId,
+      address
+    }) {
+      var _a;
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      const subscription = mockSubscriptions.find(
+        (sub) => sub.id === subscriptionId
+      );
+      if (!subscription) {
+        return { _tag: "Failure", error: { kind: "SUBSCRIPTION_NOT_FOUND" } };
+      }
+      const previous = (_a = subscription.deliveryMethod) == null ? void 0 : _a.address;
+      subscription.deliveryMethod = {
+        ...subscription.deliveryMethod,
+        address: {
+          firstName: address.firstName,
+          lastName: address.lastName,
+          address1: address.address1,
+          zip: address.zip,
+          city: address.city,
+          ...address.address2 ? { address2: address.address2 } : {},
+          ...address.province ? { province: address.province } : {},
+          ...address.phone ? { phone: address.phone } : {},
+          ...address.company ? { company: address.company } : {},
+          ...(previous == null ? void 0 : previous.country) != null ? { country: previous.country } : {},
+          ...(previous == null ? void 0 : previous.countryCode) != null ? { countryCode: previous.countryCode } : {}
+        }
+      };
+      subscription.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return { _tag: "Success", data: void 0 };
+    },
+    async getAvailableShippingMethods({
+      subscriptionId
+    }) {
+      var _a, _b, _c;
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      const subscription = mockSubscriptions.find(
+        (sub) => sub.id === subscriptionId
+      );
+      if (!subscription) {
+        return { _tag: "Failure", error: "Subscription not found" };
+      }
+      const currentTitle = (_b = (_a = subscription.deliveryMethod) == null ? void 0 : _a.shippingOption) == null ? void 0 : _b.title;
+      const currencyCode = ((_c = subscription.items[0]) == null ? void 0 : _c.price.currencyCode) ?? "EUR";
+      return {
+        _tag: "Success",
+        data: MOCK_SHIPPING_METHODS.map((method) => ({
+          ...method,
+          price: { ...method.price, currencyCode },
+          isActive: method.title === currentTitle
+        }))
+      };
+    },
+    async updateDeliveryMethod({
+      subscriptionId,
+      shippingMethodHandle
+    }) {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      const subscription = mockSubscriptions.find(
+        (sub) => sub.id === subscriptionId
+      );
+      if (!subscription) {
+        return { _tag: "Failure", error: { kind: "SUBSCRIPTION_NOT_FOUND" } };
+      }
+      const method = MOCK_SHIPPING_METHODS.find(
+        (m2) => m2.handle === shippingMethodHandle
+      );
+      if (!method) {
+        return {
+          _tag: "Failure",
+          error: {
+            kind: "UNKNOWN",
+            message: `Provided shipping method handle "${shippingMethodHandle}" is not available`
+          }
+        };
+      }
+      subscription.deliveryMethod = {
+        ...subscription.deliveryMethod,
+        shippingOption: { title: method.title },
+        pickupOption: null,
+        localDeliveryOption: null
+      };
+      subscription.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return { _tag: "Success", data: void 0 };
+    },
     async resume(params) {
       await new Promise((resolve) => setTimeout(resolve, 300));
       const subscription = mockSubscriptions.find(
@@ -1832,27 +2477,165 @@ function createMockSubscriptionAdapter(options = {}) {
     async addUpsellProduct() {
       await new Promise((resolve) => setTimeout(resolve, 400));
       return { _tag: "Success", data: void 0 };
+    },
+    async getInstantOrderProducts({
+      query
+    }) {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      const term = query == null ? void 0 : query.trim().toLowerCase();
+      const products = term ? mockInstantOrderProducts.filter(
+        (product) => product.title.toLowerCase().includes(term)
+      ) : [...mockInstantOrderProducts];
+      return {
+        _tag: "Success",
+        data: {
+          // Deliberately independent of `query`, mirroring the endpoint: a search
+          // that matches nothing must not read as "the feature is unavailable"
+          // and make a consumer hide its entry point mid-interaction.
+          available: mockInstantOrderProducts.length > 0,
+          requiresCheckout: false,
+          products,
+          hasNextPage: false,
+          endCursor: null
+        }
+      };
+    },
+    async placeInstantOrder({
+      items,
+      shippingMethodTitle
+    }) {
+      var _a;
+      await new Promise((resolve) => setTimeout(resolve, 400));
+      const malformed = items.length < MOCK_INSTANT_ORDER_MIN_ITEMS || items.length > MOCK_INSTANT_ORDER_MAX_ITEMS || items.some(
+        (item) => !Number.isInteger(item.quantity) || item.quantity < MOCK_INSTANT_ORDER_MIN_QUANTITY || item.quantity > MOCK_INSTANT_ORDER_MAX_QUANTITY
+      );
+      if (malformed) {
+        return {
+          _tag: "Failure",
+          error: {
+            kind: "INVALID_REQUEST",
+            message: "Malformed item list"
+          }
+        };
+      }
+      const variants = mockInstantOrderProducts.flatMap(
+        (product) => product.variants.items
+      );
+      const unknown = items.find(
+        (item) => !variants.some((variant) => variant.id === item.variantId)
+      );
+      if (unknown) {
+        return {
+          _tag: "Failure",
+          error: {
+            kind: "INVALID_REQUEST",
+            message: `Unknown variant ${unknown.variantId}`
+          }
+        };
+      }
+      const rate = MOCK_SHIPPING_METHODS.find(
+        (method) => method.title === shippingMethodTitle
+      );
+      if (shippingMethodTitle != null && rate == null) {
+        return {
+          _tag: "Failure",
+          error: {
+            kind: "INVALID_REQUEST",
+            message: `Shipping method "${shippingMethodTitle}" is not available for this order`
+          }
+        };
+      }
+      const total = items.reduce(
+        (sum, item) => {
+          const variant = variants.find((v3) => v3.id === item.variantId);
+          return sum + Number((variant == null ? void 0 : variant.price.amount) ?? 0) * item.quantity;
+        },
+        // Only when a rate was chosen: an instant order left on the
+        // subscription's own delivery method has no separate delivery price the
+        // mock catalog can know.
+        Number((rate == null ? void 0 : rate.price.amount) ?? 0)
+      );
+      placedInstantOrders += 1;
+      return {
+        _tag: "Success",
+        data: {
+          orderId: `io-order-${placedInstantOrders}`,
+          totalPrice: total.toFixed(2),
+          currencyCode: ((_a = variants[0]) == null ? void 0 : _a.price.currencyCode) ?? "USD",
+          status: "paid"
+        }
+      };
     }
   };
 }
-function normalizeInstrumentType(type) {
-  return type.replace(/-/g, "_");
+function mapV1Instrument(raw) {
+  return serializeV1PaymentInstrument(raw);
+}
+function mapV1BillingAddress(raw) {
+  if (raw == null || typeof raw !== "object") return null;
+  const address = {
+    firstName: raw.firstName ?? null,
+    lastName: raw.lastName ?? null,
+    address1: raw.address1 ?? null,
+    address2: raw.address2 ?? null,
+    zip: raw.zip ?? null,
+    city: raw.city ?? null,
+    country: raw.country ?? null,
+    countryCode: raw.countryCode ?? null,
+    province: raw.province ?? null,
+    provinceCode: raw.provinceCode ?? null,
+    phone: raw.phone ?? null,
+    company: raw.company ?? null
+  };
+  return Object.values(address).some((v3) => v3 != null) ? address : null;
+}
+function mapV1DeliveryAddress(raw) {
+  if (raw == null || typeof raw !== "object") return null;
+  const address = {
+    ...raw.firstName != null ? { firstName: raw.firstName } : {},
+    ...raw.lastName != null ? { lastName: raw.lastName } : {},
+    ...raw.address1 != null ? { address1: raw.address1 } : {},
+    ...raw.address2 != null ? { address2: raw.address2 } : {},
+    ...raw.zip != null ? { zip: raw.zip } : {},
+    ...raw.city != null ? { city: raw.city } : {},
+    ...raw.country != null ? { country: raw.country } : {},
+    ...raw.countryCode != null ? { countryCode: raw.countryCode } : {},
+    ...raw.province != null ? { province: raw.province } : {},
+    ...raw.provinceCode != null ? { provinceCode: raw.provinceCode } : {},
+    ...raw.phone != null ? { phone: raw.phone } : {},
+    ...raw.company != null ? { company: raw.company } : {}
+  };
+  return Object.keys(address).length > 0 ? address : null;
+}
+function mapV1DeliveryMethod(raw) {
+  const address = mapV1DeliveryAddress(raw == null ? void 0 : raw.deliveryAddress);
+  const method = raw == null ? void 0 : raw.deliveryMethod;
+  if (address == null && (method == null || typeof method !== "object")) {
+    return null;
+  }
+  const option = method != null && typeof method === "object" ? {
+    ...method.title != null ? { title: method.title } : {},
+    ...method.description != null ? { description: method.description } : {}
+  } : null;
+  return {
+    address,
+    shippingOption: (method == null ? void 0 : method.type) === "shipping" ? option : null,
+    pickupOption: (method == null ? void 0 : method.type) === "pickup" ? option : null,
+    localDeliveryOption: (method == null ? void 0 : method.type) === "local-delivery" ? option : null
+  };
 }
 function mapPaymentMethod(rawPm) {
   if (!rawPm) return null;
   if (typeof rawPm === "string") {
     return { id: rawPm };
   }
+  const instrument = mapV1Instrument(rawPm.instrument);
+  const billingAddress = mapV1BillingAddress(rawPm.billingAddress);
   return {
     id: rawPm.id ?? "",
-    ...rawPm.instrument != null ? {
-      instrument: {
-        ...rawPm.instrument,
-        type: normalizeInstrumentType(rawPm.instrument.type)
-      }
-    } : {},
-    ...rawPm.active != null ? { active: rawPm.active } : {},
-    ...rawPm.isRecurring != null ? { isRecurring: rawPm.isRecurring } : {}
+    ...instrument != null ? { instrument } : {},
+    // v1 is the ONLY customer-facing source of a billing address.
+    ...billingAddress != null ? { billingAddress } : {}
   };
 }
 function mapSubscription(raw) {
@@ -1906,6 +2689,8 @@ function mapSubscription(raw) {
     // Map customerPaymentMethod — expanded to an object (id + instrument) via the
     // adapter's ?expand=paymentMethod request; mapPaymentMethod tolerates a bare id too.
     customerPaymentMethod: mapPaymentMethod(raw.paymentMethod),
+    // v1 returns deliveryAddress + deliveryMethod on every read, no expand needed.
+    deliveryMethod: mapV1DeliveryMethod(raw),
     frequency,
     createdAt: raw.createdAt,
     updatedAt: raw.updatedAt,
@@ -1922,6 +2707,51 @@ async function readErrorBody(res) {
     return {};
   }
 }
+async function readErrorMessage(res) {
+  const body = await readErrorBody(res);
+  return typeof body.message === "string" ? body.message : void 0;
+}
+const PLACE_INSTANT_ORDER_ERROR_KINDS = {
+  400: "INVALID_REQUEST",
+  403: "REFUSED",
+  409: "DUPLICATE_REQUEST",
+  429: "RATE_LIMITED"
+};
+function mapInstantOrderProducts(body) {
+  const currencyCode = body.currencyCode;
+  const products = (body.products ?? []).map(
+    (product) => {
+      const image = product.featuredImage ? {
+        url: product.featuredImage.url,
+        ...product.featuredImage.altText != null ? { altText: product.featuredImage.altText } : {}
+      } : null;
+      return {
+        id: product.productId,
+        title: product.title,
+        // Shopify's own flag, not a count of the variants this response happens
+        // to carry — the two differ whenever some are filtered.
+        hasOnlyDefaultVariant: product.hasOnlyDefaultVariant,
+        featuredImage: image,
+        variants: {
+          items: (product.variants ?? []).map((variant) => ({
+            id: variant.id,
+            title: variant.title,
+            image,
+            price: { amount: variant.price, currencyCode },
+            availableForSale: variant.availableForSale
+          }))
+        }
+      };
+    }
+  );
+  return {
+    available: body.available,
+    requiresCheckout: body.requiresCheckout,
+    products,
+    hasNextPage: body.hasNextPage,
+    endCursor: body.endCursor ?? null
+  };
+}
 function createApiSubscriptionAdapter(fetcher) {
   const adapter = {
     async search(options) {
@@ -1977,14 +2807,33 @@ function createApiSubscriptionAdapter(fetcher) {
         return { _tag: "Failure", error: e };
       }
     },
+    // Uses the legacy POST /customer/subscriptions/{id}/lines rather than
+    // POST /customer/v1/subscriptions/{id}/items: only the legacy endpoint
+    // accepts a per-line `billingPolicy`. It answers 204 with no body.
+    // Behavioural differences vs the v1 route, both intentional here:
+    //   - it rejects membership subscriptions with 403 (v1 does not),
+    //   - it skips the availableForSale check (v1 enforces it), so callers are
+    //     responsible for only offering purchasable variants — which the
+    //     product picker already does.
     async addItem({ subscriptionId, item }) {
       try {
+        const attributes = toNonEmptyAttributeArray(item.customAttributes);
+        const body = {
+          productVariantId: item.variantId,
+          quantity: item.quantity,
+          // `!= null` on purpose: null means "inherit"/"no limit", and the
+          // endpoint rejects an explicit null on either field.
+          ...item.billingPolicy != null ? { billingPolicy: item.billingPolicy } : {},
+          ...item.recurringCycleLimit != null ? { renewalLimit: item.recurringCycleLimit } : {},
+          ...item.shippingMethodHandle != null ? { shippingMethodHandle: item.shippingMethodHandle } : {},
+          ...attributes.length > 0 ? { customAttributes: attributes } : {}
+        };
         const res = await fetcher(
-          `/customer/v1/subscriptions/${subscriptionId}/items`,
+          `/customer/subscriptions/${subscriptionId}/lines`,
           {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ variant: item.variantId, quantity: item.quantity })
+            body: JSON.stringify(body)
           }
         );
         if (!res.ok) return { _tag: "Failure", error: `HTTP ${res.status}` };
@@ -2011,7 +2860,11 @@ function createApiSubscriptionAdapter(fetcher) {
           ...update.variantId !== void 0 ? { productVariantId: update.variantId } : {},
           ...update.quantity !== void 0 ? { quantity: update.quantity } : {},
           ...update.billingPolicy !== void 0 ? { billingPolicy: update.billingPolicy } : {},
-          ...update.shippingMethodHandle !== void 0 ? { shippingMethodHandle: update.shippingMethodHandle } : {}
+          ...update.shippingMethodHandle !== void 0 ? { shippingMethodHandle: update.shippingMethodHandle } : {},
+          // Record shape (not the array the add-line endpoint takes). Guarded on
+          // `!== undefined` so `{}` — clear every customer-visible attribute —
+          // reaches the endpoint instead of being dropped as falsy.
+          ...update.customAttributes !== void 0 ? { customAttributes: update.customAttributes } : {}
         };
         const res = await fetcher(
           `/customer/subscriptions/${subscriptionId}/lines/${lineId}`,
@@ -2182,6 +3035,121 @@ function createApiSubscriptionAdapter(fetcher) {
         return { _tag: "Failure", error: e };
       }
     },
+    // Legacy endpoint on purpose — see SubscriptionAdapter.updateDeliveryAddress
+    // for why the documented v1 `deliveryAddress` patch is not used here.
+    async updateDeliveryAddress({ subscriptionId, address }) {
+      try {
+        const res = await fetcher(
+          `/customer/subscriptions/${subscriptionId}/shipping-address`,
+          {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(toShippingAddressBody(address))
+          }
+        );
+        if (!res.ok) {
+          if (res.status === 403) {
+            return { _tag: "Failure", error: { kind: "NOT_ALLOWED" } };
+          }
+          if (res.status === 404) {
+            return {
+              _tag: "Failure",
+              error: { kind: "SUBSCRIPTION_NOT_FOUND" }
+            };
+          }
+          if (res.status === 400) {
+            const body = await readErrorBody(res);
+            const message = typeof body.message === "string" ? body.message : void 0;
+            if (isStaleSubscriptionMessage(message)) {
+              return { _tag: "Failure", error: { kind: "STALE" } };
+            }
+            return {
+              _tag: "Failure",
+              error: {
+                kind: "INVALID_ADDRESS",
+                ...message ? { message } : {}
+              }
+            };
+          }
+          return {
+            _tag: "Failure",
+            error: { kind: "UNKNOWN", message: `HTTP ${res.status}` }
+          };
+        }
+        return { _tag: "Success", data: void 0 };
+      } catch (e) {
+        return {
+          _tag: "Failure",
+          error: {
+            kind: "NETWORK",
+            message: e instanceof Error ? e.message : void 0
+          }
+        };
+      }
+    },
+    // Legacy endpoint — no /customer/v1 equivalent exists yet.
+    async getAvailableShippingMethods({ subscriptionId }) {
+      try {
+        const res = await fetcher(
+          `/customer/subscriptions/${subscriptionId}/available-shipping-methods`
+        );
+        if (!res.ok) return { _tag: "Failure", error: `HTTP ${res.status}` };
+        const data = await res.json();
+        return { _tag: "Success", data };
+      } catch (e) {
+        return { _tag: "Failure", error: e };
+      }
+    },
+    // Legacy endpoint — no /customer/v1 equivalent exists yet. No `extra` is
+    // sent: pickup points are out of scope, and omitting it is what tells the
+    // endpoint to leave any existing parcel-locker attributes alone.
+    async updateDeliveryMethod({ subscriptionId, shippingMethodHandle }) {
+      try {
+        const res = await fetcher(
+          `/customer/subscriptions/${subscriptionId}/shipping-method`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ shippingMethodHandle })
+          }
+        );
+        if (!res.ok) {
+          if (res.status === 403) {
+            return { _tag: "Failure", error: { kind: "NOT_ALLOWED" } };
+          }
+          if (res.status === 404) {
+            return {
+              _tag: "Failure",
+              error: { kind: "SUBSCRIPTION_NOT_FOUND" }
+            };
+          }
+          if (res.status === 400) {
+            const body = await readErrorBody(res);
+            const message = typeof body.message === "string" ? body.message : void 0;
+            if (isStaleSubscriptionMessage(message)) {
+              return { _tag: "Failure", error: { kind: "STALE" } };
+            }
+            return {
+              _tag: "Failure",
+              error: { kind: "UNKNOWN", ...message ? { message } : {} }
+            };
+          }
+          return {
+            _tag: "Failure",
+            error: { kind: "UNKNOWN", message: `HTTP ${res.status}` }
+          };
+        }
+        return { _tag: "Success", data: void 0 };
+      } catch (e) {
+        return {
+          _tag: "Failure",
+          error: {
+            kind: "NETWORK",
+            message: e instanceof Error ? e.message : void 0
+          }
+        };
+      }
+    },
     async resume({ subscriptionId }) {
       try {
         const res = await fetcher(
@@ -2314,6 +3282,116 @@ function createApiSubscriptionAdapter(fetcher) {
       }
     },
     // Legacy endpoint — no /customer/v1 equivalent exists yet.
+    async getInstantOrderProducts({ subscriptionId, query, after, limit }) {
+      try {
+        const params = new URLSearchParams();
+        if (query) params.set("q", query);
+        if (after != null) params.set("after", after);
+        if (limit != null) params.set("limit", String(limit));
+        const search = params.toString() ? `?${params.toString()}` : "";
+        const res = await fetcher(
+          `/customer/subscriptions/${subscriptionId}/instant-orders/products${search}`
+        );
+        if (!res.ok) {
+          if (res.status === 404) {
+            return { _tag: "Failure", error: { kind: "SUBSCRIPTION_NOT_FOUND" } };
+          }
+          const message = await readErrorMessage(res);
+          return {
+            _tag: "Failure",
+            error: { kind: "UNKNOWN", message: message ?? `HTTP ${res.status}` }
+          };
+        }
+        const body = await res.json().catch(() => null);
+        if (body == null) {
+          return {
+            _tag: "Failure",
+            error: { kind: "UNKNOWN", message: "Malformed response" }
+          };
+        }
+        return { _tag: "Success", data: mapInstantOrderProducts(body) };
+      } catch (e) {
+        return {
+          _tag: "Failure",
+          error: {
+            kind: "NETWORK",
+            message: e instanceof Error ? e.message : void 0
+          }
+        };
+      }
+    },
+    // Legacy endpoint — no /customer/v1 equivalent exists yet.
+    //
+    // No X-Last-Updated-At header: an instant order never mutates the
+    // subscription, so the optimistic-lock preValidation (which only fires when
+    // the header is present) has nothing to guard here.
+    async placeInstantOrder({
+      subscriptionId,
+      requestKey,
+      items,
+      shippingMethodTitle
+    }) {
+      try {
+        const res = await fetcher(
+          `/customer/subscriptions/${subscriptionId}/instant-orders`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              requestKey,
+              // Narrowed to what the endpoint accepts: the rest of
+              // PostableSubscriptionItem describes a subscription line (its
+              // billing policy, its cycle limit), and an instant order is not one.
+              items: items.map(({ variantId, quantity }) => ({
+                variantId,
+                quantity
+              })),
+              // Basket-level, not per-line: the endpoint prices one delivery
+              // rate for the whole instant order.
+              ...shippingMethodTitle != null ? { shippingMethodTitle } : {}
+            })
+          }
+        );
+        if (!res.ok) {
+          if (res.status === 404) {
+            return { _tag: "Failure", error: { kind: "SUBSCRIPTION_NOT_FOUND" } };
+          }
+          const message = await readErrorMessage(res);
+          const kind = PLACE_INSTANT_ORDER_ERROR_KINDS[res.status] ?? "UNKNOWN";
+          return {
+            _tag: "Failure",
+            error: { kind, message: message ?? `HTTP ${res.status}` }
+          };
+        }
+        const body = await res.json().catch(() => null);
+        if (body == null) {
+          return {
+            _tag: "Failure",
+            error: { kind: "UNKNOWN", message: "Malformed response" }
+          };
+        }
+        return {
+          _tag: "Success",
+          data: {
+            orderId: body.orderId,
+            totalPrice: body.totalPrice ?? null,
+            currencyCode: body.currencyCode,
+            status: body.status,
+            ...body.paymentUrl != null ? { paymentUrl: body.paymentUrl } : {},
+            ...body.reason != null ? { reason: body.reason } : {}
+          }
+        };
+      } catch (e) {
+        return {
+          _tag: "Failure",
+          error: {
+            kind: "NETWORK",
+            message: e instanceof Error ? e.message : void 0
+          }
+        };
+      }
+    },
+    // Legacy endpoint — no /customer/v1 equivalent exists yet.
     async getLastOrder({ subscriptionId }) {
       try {
         const res = await fetcher(
@@ -3083,6 +4161,19 @@ function getCurrentSubscriptionId() {
   }
   return null;
 }
+async function countRatesTitled(adapter, subscriptionId, title) {
+  try {
+    const available = await adapter.getAvailableShippingMethods({
+      subscriptionId
+    });
+    if (available._tag !== "Success") {
+      return 0;
+    }
+    return available.data.filter((option) => option.title === title).length;
+  } catch {
+    return 0;
+  }
+}
 function createSubscriptionService(adapter) {
   const current = d(null);
   const hasPendingBilling = w(
@@ -3217,6 +4308,27 @@ function createSubscriptionService(adapter) {
     },
     reschedule: (subscriptionId, newDate) => adapter.reschedule({ subscriptionId, newDate }),
     updateCustomAttributes: (subscriptionId, customAttributes) => adapter.updateCustomAttributes({ subscriptionId, customAttributes }),
+    updateDeliveryAddress: async (subscriptionId, address) => {
+      const result = await adapter.updateDeliveryAddress({
+        subscriptionId,
+        address
+      });
+      if (result._tag === "Success") {
+        await reload();
+      }
+      return result;
+    },
+    getAvailableShippingMethods: (subscriptionId) => adapter.getAvailableShippingMethods({ subscriptionId }),
+    updateDeliveryMethod: async (subscriptionId, shippingMethodHandle) => {
+      const result = await adapter.updateDeliveryMethod({
+        subscriptionId,
+        shippingMethodHandle
+      });
+      if (result._tag === "Success") {
+        await reload();
+      }
+      return result;
+    },
     resume: (subscriptionId) => adapter.resume({ subscriptionId }),
     pause: (subscriptionId) => adapter.pause({ subscriptionId }),
     reactivate: (subscriptionId) => adapter.reactivate({ subscriptionId }),
@@ -3227,10 +4339,116 @@ function createSubscriptionService(adapter) {
     getAvailablePlans: (subscriptionId) => adapter.getAvailablePlans({ subscriptionId }),
     getDefaultSubscriptionId: () => adapter.getDefaultSubscriptionId(),
     getUpsellProducts: (params) => adapter.getUpsellProducts ? adapter.getUpsellProducts(params) : Promise.resolve({ _tag: "Success", data: [] }),
-    addUpsellProduct: (params) => adapter.addUpsellProduct ? adapter.addUpsellProduct(params) : Promise.resolve({ _tag: "Success", data: void 0 })
+    addUpsellProduct: (params) => adapter.addUpsellProduct ? adapter.addUpsellProduct(params) : Promise.resolve({ _tag: "Success", data: void 0 }),
+    getInstantOrderProducts: (subscriptionId, params) => adapter.getInstantOrderProducts ? adapter.getInstantOrderProducts({ subscriptionId, ...params }) : Promise.resolve({
+      _tag: "Success",
+      data: {
+        available: false,
+        requiresCheckout: false,
+        products: [],
+        hasNextPage: false,
+        endCursor: null
+      }
+    }),
+    placeInstantOrder: async (subscriptionId, requestKey, items, options) => {
+      const placeOrder = adapter.placeInstantOrder;
+      if (!placeOrder) {
+        return {
+          _tag: "Failure",
+          error: { kind: "UNSUPPORTED" }
+        };
+      }
+      const chosenTitle = options == null ? void 0 : options.shippingMethodTitle;
+      if (chosenTitle != null) {
+        const matches = await countRatesTitled(
+          adapter,
+          subscriptionId,
+          chosenTitle
+        );
+        if (matches > 1) {
+          return {
+            _tag: "Failure",
+            error: {
+              kind: "AMBIGUOUS_SHIPPING_METHOD",
+              message: `${matches} available shipping methods are titled "${chosenTitle}", so the title cannot say which one was chosen.`
+            }
+          };
+        }
+      }
+      return placeOrder({ subscriptionId, requestKey, items, ...options });
+    }
   };
   return service;
 }
+function isOneTimeLine(line) {
+  return line.isOneTime === true || line.recurringCycleLimit === 1;
+}
+function hasValue(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function hasIdentity(line) {
+  return hasValue(line.subscriptionId) && hasValue(line.subscriptionLineId);
+}
+function isSameLine(a2, b3) {
+  return hasValue(a2.subscriptionLineId) && a2.subscriptionLineId === b3.subscriptionLineId;
+}
+function belongsToSameSubscription(a2, b3) {
+  return hasValue(a2.subscriptionId) && a2.subscriptionId === b3.subscriptionId;
+}
+function parentLineFor(child, lines) {
+  if (!hasValue(child.parentLineId)) {
+    return void 0;
+  }
+  return lines.find(
+    (candidate) => belongsToSameSubscription(candidate, child) && (candidate.subscriptionLineId === child.parentLineId || candidate.id === child.parentLineId)
+  );
+}
+function productKey(line, lines) {
+  if (hasValue(line.parentProductId)) {
+    return `product:${line.parentProductId}`;
+  }
+  if (hasValue(line.parentLineId)) {
+    const parent = parentLineFor(line, lines);
+    if (hasValue(parent == null ? void 0 : parent.productId)) {
+      return `product:${parent.productId}`;
+    }
+    return `line:${line.parentLineId}`;
+  }
+  const lineIdentity = hasValue(line.subscriptionLineId) ? line.subscriptionLineId : line.id;
+  if (!hasValue(lineIdentity)) {
+    return null;
+  }
+  const isReferencedAsParent = lines.some(
+    (candidate) => belongsToSameSubscription(candidate, line) && (hasValue(line.productId) && candidate.parentProductId === line.productId || hasValue(candidate.parentLineId) && (candidate.parentLineId === line.subscriptionLineId || candidate.parentLineId === line.id))
+  );
+  if (isReferencedAsParent && hasValue(line.productId)) {
+    return `product:${line.productId}`;
+  }
+  return `line:${lineIdentity}`;
+}
+function remainingRecurringProductKeys(line, lines) {
+  const removedProductKey = productKey(line, lines);
+  return new Set(
+    lines.filter(
+      (item) => belongsToSameSubscription(item, line) && !isOneTimeLine(item)
+    ).map((item) => productKey(item, lines)).filter((key) => key != null && key !== removedProductKey)
+  );
+}
+function canRemoveLine(line, lines) {
+  if (!hasIdentity(line)) {
+    return false;
+  }
+  const targetExists = lines.some(
+    (item) => belongsToSameSubscription(item, line) && isSameLine(item, line)
+  );
+  if (!targetExists) {
+    return false;
+  }
+  if (isOneTimeLine(line)) {
+    return true;
+  }
+  return remainingRecurringProductKeys(line, lines).size > 0;
+}
 function getDefaultBlockForAction(actionType, actionConfig, blockId) {
   const blockName = `action:${actionType}`;
   const definedBlocks = getDefinedBlocks();
@@ -4206,8 +5424,12 @@ export {
   OrderServiceContext,
   OverlayServiceContext,
   P as PAGE_ROOT_SLOT,
+  PAYMENT_INSTRUMENT_TYPES,
   ProductServiceContext,
+  REFRESH_LOCK_NAME,
   RouterServiceContext,
+  SUPPORTED_UI_LANGUAGES,
+  SUPPORTED_UI_LANGUAGE_OPTIONS,
   SchedulesServiceContext,
   S as SelectedBlockContext,
   SettingsServiceContext,
@@ -4224,6 +5446,8 @@ export {
   c as backfillInstanceDefaults,
   b2 as buildGridLayout,
   j as buildLayoutCss,
+  buildOrdersQuery,
+  canRemoveLine,
   canvasMode,
   clampRect,
   k2 as classifyRowDividers,
@@ -4277,11 +5501,16 @@ export {
   emitLayoutSetRects,
   q2 as expandFillLayoutDocument,
   findFreeRect,
+  fromV1Customer,
   getActiveSurfaceContext,
   getDefaultBlockForAction,
   getDefinedBlocks,
   F as getDevtoolsBlockState,
   getLayoutModeAdapter,
+  getPaymentInstrumentDetail,
+  getPaymentInstrumentDigits,
+  getPaymentInstrumentExpiry,
+  getPaymentInstrumentName,
   gridV1Engine,
   hasDefaultBlockForAction,
   G as hasRenderedContent,
@@ -4289,6 +5518,9 @@ export {
   i as injectContext,
   insertRectRelative,
   H as isEditorPreview,
+  isFilterQuery,
+  isOneTimeLine,
+  isStaleSubscriptionMessage,
   b as isStubDefinition,
   t2 as layoutScopeSelector,
   I as layoutSystemEnabled,
@@ -4306,6 +5538,7 @@ export {
   resetBreakpoint,
   r as resolveLayout,
   k as serializeBlocks,
+  serializeV1PaymentInstrument,
   setActiveSurfaceContext,
   K as setDevtoolsBlockProp,
   setLayoutCommandDispatcher,
@@ -4313,7 +5546,9 @@ export {
   l as setLayoutSystemEnabled,
   d as signal,
   subscribeContext,
+  toLanguageSelectOptions,
   L as untracked,
   waitForDevBlocksUrl,
+  withRefreshLock,
   w2 as withWrapper
 };