@zappie/verify 0.1.3 → 0.2.2

package/dist/chunk-47RIF6JW.js

@@ -0,0 +1,2807 @@
+// ../sdk/src/errors.ts
+var codes = [
+  "network_error",
+  "timeout",
+  "rate_limited",
+  "unauthorized",
+  "forbidden_origin",
+  "not_found",
+  "store_not_found",
+  "branch_not_found",
+  "item_not_found",
+  "cart_invalid",
+  "invalid_request",
+  "version_unsupported",
+  "server_error"
+];
+var ZappieError = class extends Error {
+  constructor(code, message, details = {}) {
+    super(message, { cause: details.cause });
+    this.code = code;
+    this.name = "ZappieError";
+    if (details.status !== void 0) {
+      this.status = details.status;
+    }
+    if (details.param !== void 0) {
+      this.param = details.param;
+    }
+    if (details.requestId !== void 0) {
+      this.requestId = details.requestId;
+    }
+    this.docUrl = details.docUrl ?? `https://docs.zappie.ai/errors#${code}`;
+    this.retryable = details.retryable ?? ["network_error", "timeout", "rate_limited", "server_error"].includes(
+      code
+    );
+  }
+};
+function isZappieError(error) {
+  return error instanceof ZappieError;
+}
+function asError(error) {
+  return isZappieError(error) ? error : new ZappieError("network_error", "The storefront request failed", {
+    cause: error
+  });
+}
+function wireError(value, status, requestId) {
+  const envelope = value && typeof value === "object" ? value : {};
+  const e = envelope.error && typeof envelope.error === "object" ? envelope.error : {};
+  const fallback = status === 401 ? "unauthorized" : status === 403 ? "forbidden_origin" : status === 404 ? "not_found" : status === 429 ? "rate_limited" : status >= 500 ? "server_error" : "invalid_request";
+  const known = typeof e.code === "string" && codes.includes(e.code);
+  const code = known ? e.code : e.code ? "server_error" : fallback;
+  const message = typeof e.message === "string" ? e.message : "The storefront request failed";
+  return new ZappieError(
+    code,
+    !known && e.code ? `${String(e.code)}: ${message}` : message,
+    {
+      status,
+      ...requestId ? { requestId } : {},
+      ...typeof e.param === "string" ? { param: e.param } : {},
+      ...typeof e.doc_url === "string" ? { docUrl: e.doc_url } : {}
+    }
+  );
+}
+
+// ../sdk/src/money.ts
+var ZERO_DIGIT_CURRENCIES = " AFN ALL BIF CLP DJF GNF IQD IRR ISK JPY KMF KPW KRW LAK LBP MGA MMK PYG RSD RWF SLL SOS SYP UGX UYI VND VUV XAF XOF XPF YER ";
+var THREE_DIGIT_CURRENCIES = " BHD JOD KWD LYD OMR TND ";
+var FOUR_DIGIT_CURRENCIES = " CLF UYW ";
+var API_ONLY_CURRENCIES = " BOV CHE CHW CLF COU MXV USN UYI UYW VED ";
+var contains = (codes2, currency) => codes2.includes(` ${currency} `);
+var intlCurrencies;
+function isCurrency(code) {
+  if (!/^[A-Z]{3}$/.test(code)) {
+    return false;
+  }
+  if (typeof Intl.supportedValuesOf !== "function") {
+    return true;
+  }
+  intlCurrencies ??= new Set(Intl.supportedValuesOf("currency"));
+  return contains(API_ONLY_CURRENCIES, code) || intlCurrencies.has(code);
+}
+function currencyDigits(currency) {
+  if (contains(ZERO_DIGIT_CURRENCIES, currency)) {
+    return 0;
+  }
+  if (contains(THREE_DIGIT_CURRENCIES, currency)) {
+    return 3;
+  }
+  return contains(FOUR_DIGIT_CURRENCIES, currency) ? 4 : 2;
+}
+function money(amountMinor, currency) {
+  const normalized = typeof currency === "string" ? currency.trim().toUpperCase() : "";
+  if (!Number.isSafeInteger(amountMinor) || !isCurrency(normalized)) {
+    throw new ZappieError(
+      "invalid_request",
+      "Money requires safe integer minor units and a valid ISO 4217 currency"
+    );
+  }
+  return Object.freeze({ amountMinor, currency: normalized });
+}
+var format = {
+  money(value, opts = {}) {
+    const normalized = money(value.amountMinor, value.currency);
+    const locale = normalized.currency === "NGN" ? "en-NG" : "en";
+    const digits = currencyDigits(normalized.currency);
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: normalized.currency,
+      currencyDisplay: "narrowSymbol",
+      minimumFractionDigits: opts.showZeroDecimals || normalized.amountMinor % 10 ** digits !== 0 ? digits : 0,
+      maximumFractionDigits: digits,
+      notation: opts.compact ? "compact" : "standard",
+      signDisplay: opts.sign ?? "auto"
+    }).format(normalized.amountMinor / 10 ** digits);
+  }
+};
+
+// ../sdk/src/internal/money-math.ts
+function sumMoney(values, zero) {
+  let amount = zero.amountMinor;
+  for (const value of values) {
+    if (value.currency !== zero.currency) {
+      throw new ZappieError(
+        "invalid_request",
+        "Cannot combine different currencies"
+      );
+    }
+    amount = money(amount + value.amountMinor, zero.currency).amountMinor;
+  }
+  return money(amount, zero.currency);
+}
+function multiplyMoney(value, quantity) {
+  if (!Number.isSafeInteger(quantity)) {
+    throw new ZappieError(
+      "invalid_request",
+      "Money requires an integer quantity"
+    );
+  }
+  return money(value.amountMinor * quantity, value.currency);
+}
+
+// ../sdk/src/cart/errors.ts
+var ZappieCartError = class extends ZappieError {
+  constructor(issues) {
+    super("cart_invalid", issues[0]?.message ?? "The cart needs attention");
+    this.issues = issues;
+    this.name = "ZappieCartError";
+  }
+};
+
+// ../sdk/src/cart/price.ts
+function estimateUnitPrice(item, line) {
+  const variant = line.variantId ? item.variants.find((v) => v.id === line.variantId) : void 0;
+  if (line.variantId && !variant) {
+    throw new ZappieError("invalid_request", "The selected variant is missing");
+  }
+  const extras = line.choices.flatMap((selected) => {
+    const group = item.optionGroups.find((g) => g.id === selected.groupId);
+    const choice = group?.choices.find((c) => c.id === selected.choiceId);
+    if (!group || !choice) {
+      throw new ZappieError(
+        "invalid_request",
+        "The selected option is missing"
+      );
+    }
+    return group.isAttribute ? [] : [multiplyMoney(choice.price, Math.max(selected.quantity, 1))];
+  });
+  return sumMoney(extras, variant?.price ?? item.price);
+}
+
+// ../sdk/src/cart/source-menu.ts
+function resolveSourceMenu(menu, itemId, menuId) {
+  const categories = menu.categories.filter((c) => c.itemIds.includes(itemId));
+  const sources = menu.menus ?? [
+    { id: menu.id, categoryIds: menu.categories.map((c) => c.id) }
+  ];
+  const placements = menu.items[itemId]?.placements;
+  const candidates = sources.filter(
+    (source) => (!placements || placements.some(
+      (p) => p.menuId === source.id && source.categoryIds.includes(p.categoryId)
+    )) && source.categoryIds.some((id) => categories.some((c) => c.id === id))
+  );
+  if (menuId !== void 0) {
+    return typeof menuId === "string" && menuId.trim().length > 0 && menuId.length <= 256 && candidates.some((source) => source.id === menuId) ? menuId : void 0;
+  }
+  return candidates.length === 1 ? candidates[0].id : void 0;
+}
+
+// ../sdk/src/cart/validate.ts
+function issue(code, message, fixes = [], groupId) {
+  return {
+    code,
+    severity: "blocking",
+    message,
+    fixes,
+    source: "local",
+    ...groupId ? { groupId } : {}
+  };
+}
+function effectiveGroups(item, input) {
+  const selected = /* @__PURE__ */ new Map();
+  for (const choice of input.choices ?? []) {
+    const ids = selected.get(choice.groupId) ?? /* @__PURE__ */ new Set();
+    ids.add(choice.choiceId);
+    selected.set(choice.groupId, ids);
+  }
+  return item.optionGroups.map((group) => {
+    let required = group.required;
+    let { min, max } = group.selection;
+    for (const rule of group.conditions ?? []) {
+      const chosen = selected.get(rule.groupId) ?? /* @__PURE__ */ new Set();
+      const matches = rule.count ? rule.count.op === "eq" ? chosen.size === rule.count.value : rule.count.op === "gte" ? chosen.size >= rule.count.value : chosen.size <= rule.count.value : chosen.size > 0 && rule.choiceIds.length > 0 && (rule.match === "all" ? rule.choiceIds.every((id) => chosen.has(id)) : rule.choiceIds.some((id) => chosen.has(id)));
+      if (!matches) {
+        continue;
+      }
+      required = rule.setRequired ?? required;
+      min = rule.setMin ?? min;
+      if (rule.setMax != null) {
+        max = rule.setMax > 0 ? rule.setMax : void 0;
+      }
+    }
+    return {
+      ...group,
+      required,
+      selection: { min, ...max !== void 0 ? { max } : {} }
+    };
+  });
+}
+function normalizeInput(item, input) {
+  const inactive = new Set(
+    item.optionGroups.filter((g) => g.isAvailable === false).map((g) => g.id)
+  );
+  return {
+    ...input,
+    quantity: input.quantity ?? item.quantity.min,
+    choices: (input.choices ?? []).filter((c) => !inactive.has(c.groupId)).map((c) => ({ ...c, quantity: c.quantity ?? 1 })),
+    inputs: Object.fromEntries(
+      Object.entries(input.inputs ?? {}).filter(([id]) => !inactive.has(id))
+    )
+  };
+}
+function resolveVariant(item, input) {
+  const attrs = item.optionGroups.filter((g) => g.isAttribute);
+  const matches = item.variants.filter(
+    (variant) => (!input.variantId || variant.id === input.variantId) && attrs.every((group) => {
+      const selected = input.choices?.filter((c) => c.groupId === group.id) ?? [];
+      return selected.length === 1 && variant.attributeChoices[group.id] === selected[0].choiceId;
+    })
+  );
+  return matches.length === 1 ? matches[0] : void 0;
+}
+function validInput(kind, value) {
+  switch (kind) {
+    case "number":
+      return Number.isFinite(Number(value));
+    case "date":
+      return /^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value;
+    case "time":
+      return /^([01]\d|2[0-3]):[0-5]\d(:[0-5]\d)?$/.test(value);
+    case "toggle":
+      return ["true", "false"].includes(value.toLowerCase());
+    default:
+      return true;
+  }
+}
+function validateLine(item, raw, ctx) {
+  if (!item || item.id !== raw.itemId || !Object.hasOwn(ctx.menu.items, raw.itemId)) {
+    return [
+      issue("item_unavailable", "This item is no longer on the menu", [
+        { action: "remove_line" }
+      ])
+    ];
+  }
+  const issues = [];
+  if (!resolveSourceMenu(ctx.menu, raw.itemId, raw.menuId)) {
+    issues.push(
+      issue(
+        "item_unavailable",
+        raw.menuId === void 0 ? `${item.name} is on more than one menu. Remove it and add it again from the menu you want.` : `${item.name} is no longer on the menu it was added from.`,
+        [{ action: "remove_line" }]
+      )
+    );
+  }
+  if (!item.isAvailable) {
+    issues.push(
+      issue("item_unavailable", `${item.name} is unavailable`, [
+        { action: "remove_line" }
+      ])
+    );
+  }
+  const input = normalizeInput(item, raw);
+  const quantity = input.quantity;
+  const { min, step } = item.quantity;
+  const max = Math.min(item.quantity.max ?? 99, 99);
+  if (!Number.isInteger(quantity) || quantity < min || quantity > max || quantity % step !== 0) {
+    const lower = Math.ceil(min / step) * step;
+    const upper = Math.floor(max / step) * step;
+    const nearest = Math.max(
+      lower,
+      Math.min(
+        upper,
+        Math.round((Number.isFinite(quantity) ? quantity : min) / step) * step
+      )
+    );
+    issues.push(
+      issue(
+        "quantity_limit",
+        `Choose a valid quantity of ${item.name} (${min}\u2013${max}, step ${step})`,
+        lower <= upper ? [{ action: "set_quantity", quantity: nearest }] : []
+      )
+    );
+  }
+  if ((input.note?.length ?? 0) > 280) {
+    issues.push(issue("option_limit", "Notes must be at most 280 characters"));
+  }
+  for (const choice of input.choices ?? []) {
+    if (!item.optionGroups.some((g) => g.id === choice.groupId)) {
+      issues.push(
+        issue(
+          "option_unavailable",
+          "This option group no longer exists",
+          [{ action: "remove_line" }],
+          choice.groupId
+        )
+      );
+    }
+  }
+  for (const id of Object.keys(input.inputs ?? {})) {
+    if (!item.optionGroups.some((g) => g.id === id)) {
+      issues.push(
+        issue(
+          "option_unavailable",
+          "This input group no longer exists",
+          [{ action: "remove_line" }],
+          id
+        )
+      );
+    }
+  }
+  const groups = effectiveGroups(item, input);
+  const missing = groups.filter(
+    (g) => g.isAvailable !== false && g.required && !(input.choices ?? []).some((c) => c.groupId === g.id) && !(input.inputs?.[g.id] ?? "").trim()
+  );
+  if (missing.length) {
+    return [
+      ...issues,
+      ...missing.map(
+        (g) => issue(
+          "option_required",
+          `Choose ${g.name}`,
+          [{ action: "choose_option", groupId: g.id }],
+          g.id
+        )
+      )
+    ];
+  }
+  for (const group of groups) {
+    if (group.isAvailable === false) {
+      continue;
+    }
+    const choices = input.choices?.filter((c) => c.groupId === group.id) ?? [];
+    const text2 = input.inputs?.[group.id] ?? "";
+    const value = text2.trim();
+    const hybrid = group.isInformational && group.kind === "select";
+    const isInput = group.kind !== "select" || hybrid && !group.choices.length;
+    const fix = [{ action: "choose_option", groupId: group.id }];
+    if (group.required && !choices.length && !value) {
+      issues.push(
+        issue("option_required", `Choose ${group.name}`, fix, group.id)
+      );
+    }
+    if (value && (!isInput && !hybrid || choices.length > 0)) {
+      issues.push(
+        issue(
+          "option_limit",
+          `Choose either an option or a response for ${group.name}`,
+          fix,
+          group.id
+        )
+      );
+    }
+    if ((isInput || hybrid) && (text2.length > (group.input?.maxLength ?? 500) || value && !validInput(group.kind, value))) {
+      issues.push(
+        issue(
+          "option_limit",
+          `Enter a valid response for ${group.name}`,
+          fix,
+          group.id
+        )
+      );
+    }
+    const count = choices.reduce((sum, c) => sum + (c.quantity ?? 1), 0);
+    if (choices.length && (isInput || count < group.selection.min || count > (group.selection.max ?? Infinity) || new Set(choices.map((c) => c.choiceId)).size !== choices.length)) {
+      issues.push(
+        issue(
+          "option_limit",
+          `Check the number of options for ${group.name}`,
+          fix,
+          group.id
+        )
+      );
+    }
+    for (const selected of choices) {
+      const choice = group.choices.find((c) => c.id === selected.choiceId);
+      if (!choice?.isAvailable) {
+        issues.push(
+          issue(
+            "option_unavailable",
+            `An option in ${group.name} is unavailable`,
+            [
+              { action: "choose_other_option", groupId: group.id },
+              { action: "remove_line" }
+            ],
+            group.id
+          )
+        );
+      }
+      const n = selected.quantity ?? 1;
+      if (!Number.isInteger(n) || n < (choice?.quantity?.min ?? 1) || n > (choice?.quantity?.max ?? 99)) {
+        issues.push(
+          issue(
+            "option_limit",
+            `Check the option quantity for ${group.name}`,
+            fix,
+            group.id
+          )
+        );
+      }
+    }
+  }
+  const variant = resolveVariant(item, input);
+  if (!variant?.isAvailable) {
+    const groupId = item.optionGroups.find((g) => g.isAttribute)?.id;
+    issues.push(
+      issue(
+        "option_limit",
+        "Choose an available variant",
+        groupId ? [{ action: "choose_option", groupId }] : [{ action: "remove_line" }],
+        groupId
+      )
+    );
+  }
+  return issues;
+}
+
+// ../sdk/src/cart/reconcile.ts
+function lineInput(line) {
+  return {
+    itemId: line.itemId,
+    ...line.menuId !== void 0 ? { menuId: line.menuId } : {},
+    quantity: line.quantity,
+    choices: line.choices.map((c) => ({ ...c })),
+    inputs: { ...line.inputs },
+    ...line.variantId ? { variantId: line.variantId } : {},
+    ...line.note !== void 0 ? { note: line.note } : {}
+  };
+}
+function freezeLine(line) {
+  return Object.freeze({
+    ...line,
+    choices: Object.freeze(line.choices.map((c) => Object.freeze({ ...c }))),
+    inputs: Object.freeze({ ...line.inputs })
+  });
+}
+function reconcile(lines, menu, branch, currency, previous = []) {
+  const issues = [];
+  let priced = true;
+  const result = lines.map((old) => {
+    const item = Object.hasOwn(menu.items, old.itemId) ? menu.items[old.itemId] : void 0;
+    const raw = {
+      ...old,
+      choices: old.choices?.map((c) => ({ ...c })),
+      inputs: { ...old.inputs }
+    };
+    const input = item ? normalizeInput(item, raw) : raw;
+    issues.push(
+      ...validateLine(item, input, { menu, branch }).map((i) => ({
+        ...i,
+        lineId: old.id
+      }))
+    );
+    const variantId = input.variantId ?? (item ? resolveVariant(item, input)?.id : void 0);
+    let unitPrice = money(0, currency);
+    let linePriced = true;
+    try {
+      if (!item) {
+        throw new Error("Missing item");
+      }
+      unitPrice = estimateUnitPrice(item, {
+        choices: (input.choices ?? []).map((c) => ({
+          ...c,
+          quantity: c.quantity ?? 1
+        })),
+        ...variantId ? { variantId } : {}
+      });
+    } catch {
+      priced = false;
+      linePriced = false;
+    }
+    if (old.unitPrice && old.unitPrice.amountMinor !== unitPrice.amountMinor && item && linePriced) {
+      issues.push({
+        ...issue(
+          "price_changed",
+          `${item.name} is now ${format.money(unitPrice)}`,
+          [{ action: "accept_price" }, { action: "remove_line" }]
+        ),
+        severity: "warning",
+        lineId: old.id,
+        data: { previous: old.unitPrice, current: unitPrice }
+      });
+    }
+    return freezeLine({
+      id: old.id,
+      itemId: old.itemId,
+      ...input.menuId !== void 0 ? { menuId: input.menuId } : {},
+      name: item?.name ?? old.name,
+      quantity: input.quantity ?? 1,
+      choices: (input.choices ?? []).map((c) => ({
+        ...c,
+        quantity: c.quantity ?? 1
+      })),
+      inputs: input.inputs ?? {},
+      ...variantId ? { variantId } : {},
+      ...input.note !== void 0 ? { note: input.note } : {},
+      unitPrice,
+      lineSubtotal: multiplyMoney(unitPrice, input.quantity ?? 1),
+      addedAt: old.addedAt
+    });
+  });
+  for (const pending of previous) {
+    if (pending.code === "price_changed" && result.some((l) => l.id === pending.lineId) && !issues.some(
+      (i) => i.code === pending.code && i.lineId === pending.lineId
+    )) {
+      issues.push(pending);
+    }
+  }
+  return { lines: Object.freeze(result), issues, priced };
+}
+
+// ../sdk/src/cart/storage.ts
+function storedMoney(value) {
+  try {
+    return value && money(value.amountMinor, value.currency);
+  } catch {
+    return void 0;
+  }
+}
+function parseCart(raw) {
+  const v = JSON.parse(raw);
+  if (!v || v.v !== 1 || !Array.isArray(v.lines) || v.lines.length > 100 || !Number.isFinite(v.updatedAt) || typeof v.menuVersion !== "string" || v.promoCode !== null && typeof v.promoCode !== "string") {
+    throw new Error("Invalid saved cart");
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const line of v.lines) {
+    if (!line || typeof line.id !== "string" || ids.has(line.id) || typeof line.itemId !== "string" || typeof line.name !== "string" || !Number.isFinite(Date.parse(line.addedAt)) || !Number.isInteger(line.quantity) || line.quantity < 1 || line.quantity > 99 || line.note !== void 0 && (typeof line.note !== "string" || line.note.length > 280) || line.menuId !== void 0 && (typeof line.menuId !== "string" || !line.menuId.trim() || line.menuId.length > 256) || line.variantId !== void 0 && typeof line.variantId !== "string") {
+      throw new Error("Invalid saved cart line");
+    }
+    ids.add(line.id);
+    if (!Array.isArray(line.choices) || line.choices.length > 1e3 || line.choices.some(
+      (c) => !c || typeof c.groupId !== "string" || typeof c.choiceId !== "string" || !Number.isInteger(c.quantity) || c.quantity < 1 || c.quantity > 99
+    )) {
+      throw new Error("Invalid saved choices");
+    }
+    if (!line.inputs || typeof line.inputs !== "object" || Array.isArray(line.inputs) || Object.values(line.inputs).some((t) => typeof t !== "string")) {
+      throw new Error("Invalid saved inputs");
+    }
+  }
+  if (v.fulfilment !== null && !validFulfilment(v.fulfilment)) {
+    throw new Error("Invalid saved fulfilment");
+  }
+  return {
+    v: 1,
+    lines: v.lines.map((l) => {
+      const unitPrice = storedMoney(l.unitPrice);
+      return {
+        id: l.id,
+        itemId: l.itemId,
+        ...l.menuId !== void 0 ? { menuId: l.menuId } : {},
+        name: l.name,
+        addedAt: l.addedAt,
+        ...unitPrice ? { unitPrice } : {},
+        quantity: l.quantity,
+        choices: l.choices,
+        inputs: l.inputs,
+        ...l.variantId ? { variantId: l.variantId } : {},
+        ...l.note !== void 0 ? { note: l.note } : {}
+      };
+    }),
+    fulfilment: v.fulfilment,
+    promoCode: v.promoCode,
+    menuVersion: v.menuVersion,
+    updatedAt: v.updatedAt
+  };
+}
+function validFulfilment(f) {
+  if (!f || !["pickup", "delivery", "dine_in"].includes(f.type) || typeof f.branchId !== "string") {
+    return false;
+  }
+  if ("scheduledFor" in f && f.scheduledFor !== void 0 && !Number.isFinite(Date.parse(f.scheduledFor))) {
+    return false;
+  }
+  if (f.type === "delivery") {
+    const a = f.address;
+    if (!a || typeof a.line1 !== "string" || !a.line1.trim()) {
+      return false;
+    }
+    if ([a.line2, a.city, a.placeId, a.instructions, f.deliveryRegionId].some(
+      (s) => s !== void 0 && typeof s !== "string"
+    )) {
+      return false;
+    }
+    if (a.coordinates && (!Number.isFinite(a.coordinates.lat) || !Number.isFinite(a.coordinates.lng) || Math.abs(a.coordinates.lat) > 90 || Math.abs(a.coordinates.lng) > 180)) {
+      return false;
+    }
+  }
+  return f.type !== "dine_in" || f.table === void 0 || typeof f.table === "string";
+}
+function createCartStorage(provided, warn) {
+  let storage;
+  let initialized = false;
+  let failed = false;
+  let warned = false;
+  const memory = /* @__PURE__ */ new Map();
+  const warning = (message) => {
+    if (!warned) {
+      warned = true;
+      warn(message);
+    }
+  };
+  const access = (fn, fallback) => {
+    try {
+      if (!initialized) {
+        initialized = true;
+        storage = provided ?? (typeof window === "undefined" ? void 0 : window.localStorage);
+      }
+      if (storage && !failed) {
+        return fn(storage);
+      }
+    } catch {
+      failed = true;
+      warning("Cart storage unavailable; using memory for this client");
+    }
+    return fallback();
+  };
+  return {
+    warning,
+    read(key) {
+      return access(
+        (s) => {
+          const value = s.getItem(key);
+          if (value !== null) {
+            memory.set(key, value);
+          } else {
+            memory.delete(key);
+          }
+          return value;
+        },
+        () => memory.get(key) ?? null
+      );
+    },
+    write(key, value) {
+      memory.set(key, value);
+      access(
+        (s) => s.setItem(key, value),
+        () => {
+        }
+      );
+    },
+    remove(key) {
+      memory.delete(key);
+      access(
+        (s) => s.removeItem(key),
+        () => {
+        }
+      );
+    },
+    accepts(area) {
+      return !failed && (!area || area === storage);
+    },
+    sweep(prefix, current, ttl) {
+      access(
+        (s) => {
+          const keys = Array.from(
+            { length: s.length ?? 0 },
+            (_, index) => s.key?.(index)
+          );
+          for (const key of keys) {
+            if (!key || key === current || !key.startsWith(prefix)) {
+              continue;
+            }
+            try {
+              const raw = s.getItem(key);
+              if (raw && Date.now() - parseCart(raw).updatedAt > ttl) {
+                s.removeItem(key);
+              }
+            } catch {
+              s.removeItem(key);
+            }
+          }
+        },
+        () => {
+        }
+      );
+    }
+  };
+}
+
+// ../sdk/src/cart/wire.ts
+function wireLine(line) {
+  return {
+    line_id: line.id,
+    item_id: line.itemId,
+    ...line.menuId !== void 0 ? { menu_id: line.menuId } : {},
+    quantity: line.quantity,
+    ...line.variantId ? { variant_id: line.variantId } : {},
+    options: line.choices.map((c) => ({
+      group_id: c.groupId,
+      choice_id: c.choiceId,
+      quantity: c.quantity
+    })),
+    inputs: { ...line.inputs },
+    ...line.note !== void 0 ? { note: line.note } : {}
+  };
+}
+function wireFulfilment(f) {
+  return {
+    type: f.type,
+    ..."scheduledFor" in f && f.scheduledFor ? { scheduled_for: f.scheduledFor } : {},
+    ...f.type === "dine_in" && f.table ? { table: f.table } : {},
+    ...f.type === "delivery" ? {
+      ...f.deliveryRegionId !== void 0 ? { delivery_region_id: f.deliveryRegionId } : {},
+      address: {
+        line1: f.address.line1,
+        ...f.address.line2 ? { line2: f.address.line2 } : {},
+        ...f.address.city ? { city: f.address.city } : {},
+        ...f.address.placeId ? { place_id: f.address.placeId } : {},
+        ...f.address.instructions ? { instructions: f.address.instructions } : {},
+        ...f.address.coordinates ? {
+          lat: f.address.coordinates.lat,
+          lng: f.address.coordinates.lng
+        } : {}
+      }
+    } : {}
+  };
+}
+
+// ../sdk/src/cart/index.ts
+var EMPTY_CART = Object.freeze({
+  lines: Object.freeze([]),
+  count: 0,
+  subtotal: null,
+  fulfilment: null,
+  promoCode: null,
+  state: { status: "ready" },
+  issues: Object.freeze([]),
+  isHydrated: false
+});
+function deepFreeze(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value)) {
+      deepFreeze(child);
+    }
+  }
+  return value;
+}
+function identity(input) {
+  return JSON.stringify([
+    input.itemId,
+    input.menuId,
+    input.variantId,
+    input.note ?? "",
+    [...input.choices ?? []].sort(
+      (a, b) => a.groupId.localeCompare(b.groupId) || a.choiceId.localeCompare(b.choiceId)
+    ),
+    Object.entries(input.inputs ?? {}).sort(([a], [b]) => a.localeCompare(b))
+  ]);
+}
+function createCart(deps) {
+  const { config, menu: menus, store, events } = deps;
+  const ttl = config.cart?.ttl ?? 7 * 24 * 60 * 60 * 1e3;
+  if (!Number.isFinite(ttl) || ttl <= 0) {
+    throw new ZappieError(
+      "invalid_request",
+      "Cart ttl must be positive milliseconds"
+    );
+  }
+  let snapshot = EMPTY_CART;
+  let menu;
+  let branch;
+  let selected = config.branch;
+  let updatedAt = 0;
+  let timer;
+  let revision = 0;
+  let quoteRevision = 0;
+  let moveSequence = 0;
+  let refreshSequence = 0;
+  let mounted = 0;
+  let detach;
+  let hydration;
+  let lifecycle = 0;
+  let legacy;
+  const listeners = /* @__PURE__ */ new Set();
+  const prefix = `zappie:cart:v1:${config.store}:`;
+  const scope = config.cart?.storageScope;
+  const keyFor = (id) => `${prefix}${id}${scope ? `:${scope}` : ""}`;
+  const key = () => keyFor(branch.id);
+  const storage = createCartStorage(
+    config.storage,
+    (message) => events.emit("warning", { message })
+  );
+  const readSaved = (id) => {
+    let raw = storage.read(keyFor(id));
+    if (raw === null && scope) {
+      raw = storage.read(prefix + id);
+      if (raw !== null) {
+        storage.remove(prefix + id);
+        storage.write(keyFor(id), raw);
+      }
+    }
+    return raw;
+  };
+  let quotes;
+  let loadingQuotes;
+  const quoteClient = () => loadingQuotes ??= import("./quote-client-4RUY3TKQ.js").then(
+    ({ createQuoteClient }) => quotes = createQuoteClient(deps.transport, deps.context, config),
+    (error) => {
+      loadingQuotes = void 0;
+      throw error;
+    }
+  );
+  const publish = (patch) => {
+    snapshot = deepFreeze({
+      ...snapshot,
+      ...patch,
+      branchId: branch?.id
+    });
+    for (const fn of [...listeners]) {
+      try {
+        fn();
+      } catch (error) {
+        events.emit("error", { error: asError(error) });
+      }
+    }
+  };
+  const attention = (issues, quote) => issues.some((i) => i.severity !== "info") ? { status: "needs_attention", issues, ...quote ? { quote } : {} } : quote ? { status: "quoted", quote } : { status: "ready" };
+  const cancel = () => {
+    revision++;
+    quoteRevision++;
+    clearTimeout(timer);
+    quotes?.cancel();
+  };
+  const persist = () => {
+    const value = {
+      v: 1,
+      lines: snapshot.lines.map((line) => ({
+        ...lineInput(line),
+        id: line.id,
+        name: line.name,
+        addedAt: line.addedAt,
+        unitPrice: line.unitPrice
+      })),
+      fulfilment: snapshot.fulfilment,
+      promoCode: snapshot.promoCode,
+      menuVersion: menu.version,
+      updatedAt
+    };
+    storage.write(key(), JSON.stringify(value));
+  };
+  const schedule2 = () => {
+    clearTimeout(timer);
+    if (snapshot.lines.length) {
+      timer = setTimeout(() => {
+        void cart.quote().catch(() => {
+        });
+      }, 300);
+    }
+  };
+  const recompute = (lines, pending = snapshot.issues.filter((i) => i.source === "local"), patch = {}) => {
+    const currency = store.peek().currency;
+    const result = reconcile(lines, menu, branch, currency, pending);
+    const subtotal = result.priced ? sumMoney(
+      result.lines.map((l) => l.lineSubtotal),
+      money(0, currency)
+    ) : null;
+    publish({
+      ...patch,
+      lines: result.lines,
+      count: result.lines.reduce((n, l) => n + l.quantity, 0),
+      subtotal,
+      issues: result.issues,
+      state: attention(result.issues)
+    });
+    for (const i of result.issues) {
+      events.emit("cart_issue", { code: i.code });
+    }
+  };
+  const changed = (lines = snapshot.lines, patch = {}) => {
+    cancel();
+    recompute(lines, void 0, patch);
+    updatedAt = Date.now();
+    persist();
+    schedule2();
+  };
+  const choose = (value) => {
+    const found = store.peek()?.branches.find((b) => b.id === value.branchId);
+    if (!found) {
+      throw new ZappieError(
+        "branch_not_found",
+        "Load the storefront branch before using its cart"
+      );
+    }
+    menu = value;
+    branch = found;
+    selected = found.id;
+  };
+  const load = (raw, writeBack = true) => {
+    cancel();
+    let saved;
+    try {
+      saved = raw ? parseCart(raw) : void 0;
+      if (saved && Date.now() - saved.updatedAt > ttl) {
+        saved = void 0;
+        storage.remove(key());
+        events.emit("cart_expired", { branchId: branch.id });
+      }
+    } catch {
+      storage.remove(key());
+      storage.warning("Invalid saved cart discarded");
+    }
+    updatedAt = saved?.updatedAt ?? Date.now();
+    const idle = Date.now() - updatedAt;
+    let fulfilment = saved?.fulfilment ?? null;
+    if (fulfilment?.branchId !== branch.id || idle > 864e5 && fulfilment.type === "delivery") {
+      fulfilment = null;
+    }
+    if (fulfilment && "scheduledFor" in fulfilment && fulfilment.scheduledFor && Date.parse(fulfilment.scheduledFor) < Date.now()) {
+      fulfilment = { ...fulfilment };
+      delete fulfilment.scheduledFor;
+    }
+    const lines = (saved?.lines ?? []).map((line) => ({
+      ...line,
+      ...idle > 864e5 ? { inputs: {} } : {}
+    }));
+    const result = reconcile(lines, menu, branch, store.peek().currency);
+    recompute(result.lines, result.issues, {
+      fulfilment,
+      promoCode: saved?.promoCode ?? null,
+      isHydrated: true
+    });
+    if (raw !== null && writeBack) {
+      persist();
+    }
+    storage.sweep(prefix, key(), ttl);
+  };
+  const ensure = () => {
+    const id = branch?.id ?? store.peek()?.branches.find(
+      (b) => b.id === selected || b.slug === selected || !selected && b.isDefault
+    )?.id ?? (!selected ? store.peek()?.branches[0]?.id : void 0);
+    if (snapshot.isHydrated) {
+      return;
+    }
+    const loaded = menu ?? (id ? deps.workingSet.peek(id, []) : void 0);
+    if (!loaded || !store.peek()) {
+      throw new ZappieError(
+        "invalid_request",
+        "Load the store and menu before editing the cart"
+      );
+    }
+    choose(loaded);
+    const raw = readSaved(branch.id);
+    let migrated = [];
+    if (raw === null && legacy) {
+      try {
+        migrated = legacy(storage.read);
+      } catch {
+        storage.warning("Invalid legacy cart discarded");
+      }
+    }
+    load(raw);
+    if (raw === null && legacy) {
+      persist();
+    }
+    for (const input of migrated.slice(0, 100)) {
+      try {
+        cart.add(input.itemId, input);
+      } catch {
+        events.emit("cart_issue", { code: "item_unavailable" });
+      }
+    }
+  };
+  const refresh = async () => {
+    const id = branch?.id;
+    const seq = moveSequence;
+    const request = ++refreshSequence;
+    const rev = revision;
+    if (!id || !menu) {
+      return;
+    }
+    if (!snapshot.lines.length) {
+      return;
+    }
+    if (menu.completeness !== "partial") {
+      const version = await deps.transport.getMenuVersion({
+        ...deps.context(),
+        branchId: id
+      });
+      if (version.version === menu.version) {
+        return;
+      }
+    }
+    const value = await deps.workingSet.read(
+      id,
+      snapshot.lines.map((l) => l.itemId),
+      true
+    );
+    if (seq !== moveSequence || request !== refreshSequence || rev !== revision || JSON.stringify(value) === JSON.stringify(menu)) {
+      return;
+    }
+    menu = value;
+    cancel();
+    recompute(snapshot.lines);
+    persist();
+    schedule2();
+  };
+  const current = (itemId) => {
+    const candidate = deps.workingSet.peek(branch.id, [
+      ...snapshot.lines.map((l) => l.itemId),
+      itemId
+    ]);
+    if (candidate.items[itemId]) {
+      menu = candidate;
+    }
+  };
+  const validated = (raw, id, addedAt) => {
+    current(raw.itemId);
+    const item = Object.hasOwn(menu.items, raw.itemId) ? menu.items[raw.itemId] : void 0;
+    const problems = validateLine(item, raw, { menu, branch });
+    if (problems.length || !item) {
+      throw new ZappieCartError(problems);
+    }
+    const input = normalizeInput(item, raw);
+    const variant = resolveVariant(item, input);
+    const choices = (input.choices ?? []).map((c) => ({
+      ...c,
+      quantity: c.quantity ?? 1
+    }));
+    const unitPrice = estimateUnitPrice(item, {
+      choices,
+      variantId: variant.id
+    });
+    return freezeLine({
+      id: id ?? `line_${Array.from(globalThis.crypto.getRandomValues(new Uint8Array(10)), (byte) => "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz-"[byte & 63]).join("")}`,
+      itemId: item.id,
+      ...input.menuId !== void 0 ? { menuId: input.menuId } : {},
+      name: item.name,
+      quantity: input.quantity,
+      choices,
+      inputs: input.inputs ?? {},
+      variantId: variant.id,
+      ...input.note !== void 0 ? { note: input.note } : {},
+      unitPrice,
+      lineSubtotal: multiplyMoney(unitPrice, input.quantity),
+      addedAt: addedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    });
+  };
+  const offMenu = events.on("menu:updated", ({ branchId, version }) => {
+    if (branch?.id === branchId) {
+      const value = menus.peek(branchId);
+      if (value && value.completeness !== "partial" && value.version === version && value.version !== menu?.version) {
+        refreshSequence++;
+        menu = value;
+        cancel();
+        recompute(snapshot.lines);
+        persist();
+        schedule2();
+      }
+    }
+  });
+  const cart = {
+    get branchId() {
+      return snapshot.branchId;
+    },
+    get lines() {
+      return snapshot.lines;
+    },
+    get count() {
+      return snapshot.count;
+    },
+    get subtotal() {
+      return snapshot.subtotal;
+    },
+    get fulfilment() {
+      return snapshot.fulfilment;
+    },
+    get promoCode() {
+      return snapshot.promoCode;
+    },
+    get state() {
+      return snapshot.state;
+    },
+    get issues() {
+      return snapshot.issues;
+    },
+    get isHydrated() {
+      return snapshot.isHydrated;
+    },
+    getSnapshot: () => snapshot,
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    },
+    async hydrate() {
+      if (snapshot.isHydrated) {
+        return refresh();
+      }
+      const life = lifecycle;
+      hydration ??= (async () => {
+        const value = await store.get();
+        const target = value.branches.find(
+          (b) => b.id === selected || b.slug === selected
+        ) ?? (!selected ? value.branches.find((b) => b.isDefault) ?? value.branches[0] : void 0);
+        if (!target) {
+          throw new ZappieError(
+            "branch_not_found",
+            "Cart branch is unavailable"
+          );
+        }
+        let inputs = snapshot.lines;
+        if (!snapshot.isHydrated) {
+          const raw = readSaved(target.id);
+          try {
+            const saved = raw ? parseCart(raw) : void 0;
+            inputs = saved && Date.now() - saved.updatedAt <= ttl ? saved.lines : raw === null ? legacy?.(storage.read) ?? [] : [];
+          } catch {
+            inputs = [];
+          }
+        }
+        const loaded = await deps.workingSet.read(
+          target.id,
+          inputs.map((l) => l.itemId)
+        );
+        if (life !== lifecycle) {
+          return;
+        }
+        choose(loaded);
+        ensure();
+        if (loaded.completeness !== "partial") {
+          await refresh();
+        }
+      })().finally(() => {
+        hydration = void 0;
+      });
+      return hydration;
+    },
+    mount() {
+      mounted++;
+      if (!detach && typeof window !== "undefined") {
+        const onStorage = (event) => {
+          if (branch && event.key === key() && storage.accepts(event.storageArea)) {
+            const raw = event.newValue;
+            let ids;
+            try {
+              ids = raw ? parseCart(raw).lines.map((l) => l.itemId) : [];
+            } catch {
+              load(raw, false);
+              return;
+            }
+            const cached = deps.workingSet.peek(branch.id, ids);
+            if (cached.completeness !== "partial" || ids.every((id) => cached.items[id])) {
+              menu = cached;
+              load(raw, false);
+              schedule2();
+              return;
+            }
+            const rev = revision;
+            const request = ++refreshSequence;
+            const life = lifecycle;
+            void deps.workingSet.read(branch.id, ids).then((value) => {
+              if (life === lifecycle && rev === revision && request === refreshSequence) {
+                menu = value;
+                load(raw, false);
+                schedule2();
+              }
+            }).catch(
+              (error) => events.emit("error", { error: asError(error) })
+            );
+          }
+        };
+        const onFocus = () => {
+          void refresh().catch(
+            (error) => events.emit("error", { error: asError(error) })
+          );
+        };
+        window.addEventListener("storage", onStorage);
+        window.addEventListener("focus", onFocus);
+        detach = () => {
+          window.removeEventListener("storage", onStorage);
+          window.removeEventListener("focus", onFocus);
+        };
+      }
+      if (mounted === 1) {
+        void cart.hydrate().catch(
+          (error) => events.emit("error", { error: asError(error) })
+        );
+      }
+      let active = true;
+      return () => {
+        if (active) {
+          active = false;
+          mounted--;
+          if (mounted === 0) {
+            detach?.();
+            detach = void 0;
+            cancel();
+          }
+        }
+      };
+    },
+    dispose() {
+      lifecycle++;
+      moveSequence++;
+      offMenu();
+      cancel();
+      detach?.();
+      detach = void 0;
+      listeners.clear();
+    },
+    validate(input) {
+      ensure();
+      current(input.itemId);
+      const problems = validateLine(
+        Object.hasOwn(menu.items, input.itemId) ? menu.items[input.itemId] : void 0,
+        input,
+        { menu, branch }
+      );
+      return problems.length ? { ok: false, issues: problems } : { ok: true };
+    },
+    add(item, input = {}) {
+      ensure();
+      let line = validated({
+        ...input,
+        itemId: typeof item === "string" ? item : item.id
+      });
+      const existing = snapshot.lines.find(
+        (l) => identity(lineInput(l)) === identity(lineInput(line))
+      );
+      if (existing) {
+        line = validated(
+          { ...lineInput(line), quantity: existing.quantity + line.quantity },
+          existing.id,
+          existing.addedAt
+        );
+      } else if (snapshot.lines.length >= 100) {
+        throw new ZappieCartError([
+          issue("quantity_limit", "A cart can contain at most 100 lines")
+        ]);
+      }
+      changed(
+        existing ? snapshot.lines.map((l) => l.id === existing.id ? line : l) : [...snapshot.lines, line]
+      );
+      events.emit("add_to_cart", {
+        itemId: line.itemId,
+        quantity: line.quantity - (existing?.quantity ?? 0),
+        value: multiplyMoney(
+          line.unitPrice,
+          line.quantity - (existing?.quantity ?? 0)
+        )
+      });
+      return line;
+    },
+    update(lineId, patch) {
+      ensure();
+      const old = snapshot.lines.find((l) => l.id === lineId);
+      if (!old) {
+        throw new ZappieCartError([
+          issue("item_not_found", "Cart line not found")
+        ]);
+      }
+      const input = { ...lineInput(old), ...patch };
+      if (patch.choices && !patch.variantId) {
+        delete input.variantId;
+      }
+      let line = validated(input, old.id, old.addedAt);
+      const duplicate = snapshot.lines.find(
+        (l) => l.id !== lineId && identity(lineInput(l)) === identity(lineInput(line))
+      );
+      if (duplicate) {
+        line = validated(
+          { ...lineInput(line), quantity: line.quantity + duplicate.quantity },
+          old.id,
+          old.addedAt
+        );
+      }
+      changed(
+        snapshot.lines.filter((l) => l.id !== duplicate?.id).map((l) => l.id === lineId ? line : l)
+      );
+      events.emit("update_cart_line", {
+        lineId,
+        itemId: line.itemId,
+        quantity: line.quantity
+      });
+      return line;
+    },
+    remove(lineId) {
+      ensure();
+      const line = snapshot.lines.find((l) => l.id === lineId);
+      changed(snapshot.lines.filter((l) => l.id !== lineId));
+      if (line) {
+        events.emit("remove_from_cart", {
+          itemId: line.itemId,
+          quantity: line.quantity,
+          value: line.lineSubtotal
+        });
+      }
+    },
+    clear() {
+      ensure();
+      changed([], { fulfilment: null, promoCode: null });
+    },
+    setFulfilment(value) {
+      ensure();
+      if (!validFulfilment(value) || value.branchId !== branch.id) {
+        throw new ZappieCartError([
+          issue(
+            "fulfilment_unavailable",
+            "Select fulfilment for the cart's branch"
+          )
+        ]);
+      }
+      changed(snapshot.lines, { fulfilment: structuredClone(value) });
+    },
+    setPromoCode(code) {
+      ensure();
+      changed(snapshot.lines, { promoCode: code?.trim() || null });
+    },
+    async moveTo(branchId) {
+      ensure();
+      const seq = ++moveSequence;
+      cancel();
+      publish({ state: attention(snapshot.issues) });
+      const value = await deps.workingSet.read(
+        branchId,
+        snapshot.lines.map((l) => l.itemId)
+      );
+      if (seq !== moveSequence) {
+        return;
+      }
+      const oldKey = key();
+      const oldLines = snapshot.lines;
+      choose(value);
+      const kept = oldLines.filter(
+        (line) => !validateLine(value.items[line.itemId], lineInput(line), {
+          menu: value,
+          branch
+        }).length
+      );
+      changed(kept, { fulfilment: null, promoCode: null });
+      const dropped = oldLines.filter((line) => !kept.includes(line)).map((line) => ({
+        ...issue(
+          "item_unavailable",
+          `${line.name} is unavailable at this branch`
+        ),
+        severity: "warning",
+        lineId: line.id
+      }));
+      const issues = [...snapshot.issues, ...dropped];
+      publish({ issues, state: attention(issues) });
+      if (oldKey !== key()) {
+        storage.remove(oldKey);
+      }
+    },
+    async quote(opts = {}) {
+      ensure();
+      clearTimeout(timer);
+      if (opts.force) {
+        events.emit("view_cart", {});
+      }
+      const body = {
+        branch_id: branch.id,
+        lines: snapshot.lines.map(wireLine),
+        ...snapshot.fulfilment ? { fulfilment: wireFulfilment(snapshot.fulfilment) } : {},
+        ...snapshot.promoCode ? { promo_code: snapshot.promoCode } : {},
+        menu_version: menu.version
+      };
+      const seq = revision;
+      const attempt = ++quoteRevision;
+      publish({ state: { status: "quoting" } });
+      try {
+        const client = await quoteClient();
+        return await client.get(body, opts.force ?? false, (quote) => {
+          if (seq !== revision) {
+            return;
+          }
+          const local = snapshot.issues.filter((i) => i.source === "local");
+          const remote = quote.issues.filter(
+            (q) => !local.some(
+              (l) => l.code === q.code && l.lineId === q.lineId && l.groupId === q.groupId
+            )
+          );
+          const issues = [...local, ...remote];
+          publish({ issues, state: attention(issues, quote) });
+          for (const i of remote) {
+            events.emit("cart_issue", { code: i.code });
+          }
+          if (quote.menuVersion !== menu.version || quote.issues.some((i) => i.code === "menu_version_stale")) {
+            void refresh().catch(
+              (error) => events.emit("error", { error: asError(error) })
+            );
+          }
+        });
+      } catch (error) {
+        if (seq === revision && attempt === quoteRevision) {
+          const local = snapshot.issues.filter((i) => i.source === "local");
+          publish({ issues: local, state: attention(local) });
+          events.emit("quote_failed", { code: asError(error).code });
+        }
+        throw error instanceof Error && error.name === "AbortError" ? error : asError(error);
+      }
+    },
+    applyFix(problem, fix = problem.fixes[0]) {
+      if (!snapshot.issues.includes(problem) || !fix || !problem.fixes.some((f) => JSON.stringify(f) === JSON.stringify(fix))) {
+        throw new ZappieError(
+          "invalid_request",
+          "Choose a current cart issue and one of its fixes"
+        );
+      }
+      switch (fix.action) {
+        case "remove_line": {
+          if (problem.lineId) {
+            cart.remove(problem.lineId);
+          }
+          return;
+        }
+        case "remove_promo":
+          cart.setPromoCode(null);
+          return;
+        case "set_quantity": {
+          if (problem.lineId) {
+            cart.update(problem.lineId, { quantity: fix.quantity });
+          }
+          return;
+        }
+        case "accept_price": {
+          quotes?.accept(problem);
+          const issues = snapshot.issues.filter((i) => i !== problem);
+          const quote = "quote" in snapshot.state ? snapshot.state.quote : void 0;
+          const accepted = quote ? {
+            ...quote,
+            issues: quote.issues.filter(
+              (i) => !(i.code === problem.code && i.lineId === problem.lineId)
+            )
+          } : void 0;
+          publish({ issues, state: attention(issues, accepted) });
+          return;
+        }
+        case "choose_region":
+          throw new ZappieError(
+            "invalid_request",
+            "Choose a delivery region and call setFulfilment with deliveryRegionId"
+          );
+        default:
+          throw new ZappieError(
+            "invalid_request",
+            `${fix.action} needs the shopper's selection; use update or setFulfilment`
+          );
+      }
+    },
+    toCheckoutPayload() {
+      ensure();
+      const blocking = snapshot.issues.filter((i) => i.severity === "blocking");
+      if (!snapshot.lines.length || !snapshot.fulfilment) {
+        blocking.push(
+          issue(
+            "fulfilment_unavailable",
+            "Add items and select fulfilment before checkout"
+          )
+        );
+      }
+      if (blocking.length) {
+        throw new ZappieCartError(blocking);
+      }
+      return {
+        lines: snapshot.lines.map(wireLine),
+        fulfilment: structuredClone(snapshot.fulfilment),
+        ...snapshot.promoCode ? { promo_code: snapshot.promoCode } : {},
+        menu_version: menu.version
+      };
+    }
+  };
+  return {
+    cart: Object.freeze(cart),
+    cartCatalogue: () => menu,
+    setLegacyReader(reader) {
+      legacy = reader;
+    }
+  };
+}
+
+// ../sdk/src/cart/working-set.ts
+function createWorkingSet(deps) {
+  const compose = (branchId, ids, metadata) => {
+    const source = metadata ?? deps.menu.peek(branchId);
+    const items = Object.fromEntries(
+      [...new Set(ids)].flatMap((id) => {
+        const item = deps.peekItem(id, branchId) ?? source?.items[id];
+        return item ? [[id, item]] : [];
+      })
+    );
+    return {
+      id: `branch:${branchId}`,
+      name: "Cart working set",
+      branchId,
+      version: "",
+      ...source,
+      kind: "working-set",
+      completeness: "partial",
+      items,
+      categories: (source?.categories ?? []).map((category) => ({
+        ...category,
+        itemIds: Object.values(items).filter(
+          (item) => item.placements ? item.placements.some(
+            (p) => p.categoryId === category.id && (source?.menus ?? [
+              { id: source?.id, categoryIds: [category.id] }
+            ]).some(
+              (m) => m.id === p.menuId && m.categoryIds.includes(category.id)
+            )
+          ) : category.itemIds.includes(item.id)
+        ).map((item) => item.id)
+      }))
+    };
+  };
+  const peek = (branchId, ids) => {
+    const value = deps.menu.peek(branchId);
+    return value && value.completeness !== "partial" ? value : compose(branchId, ids);
+  };
+  return {
+    peek,
+    async read(branchId, ids, fresh = false) {
+      const cached = peek(branchId, ids);
+      if (!ids.length || !fresh && cached.completeness !== "partial") {
+        return cached;
+      }
+      const response = fresh ? await deps.transport.getMenu({
+        ...deps.context(),
+        branchId,
+        metadataOnly: true
+      }) : void 0;
+      const metadata = response && "menu" in response ? response.menu : await deps.menu.get({ branch: branchId, metadataOnly: true });
+      if (metadata.branchId !== branchId) {
+        throw new ZappieError(
+          "server_error",
+          "Cart metadata belongs to another branch"
+        );
+      }
+      deps.menu.hydrate(metadata);
+      if (metadata.completeness !== "partial") {
+        return metadata;
+      }
+      await Promise.all(
+        [...new Set(ids)].map(async (id) => {
+          try {
+            await deps.readItem(id, branchId, fresh);
+          } catch (error) {
+            if (error.code !== "item_not_found") {
+              throw error;
+            }
+          }
+        })
+      );
+      return compose(branchId, ids, metadata);
+    }
+  };
+}
+
+// ../sdk/src/config.ts
+var API_VERSION = "2026-10-01";
+function validateConfig(config, secret = false) {
+  if (!config.store?.trim()) {
+    throw new ZappieError("invalid_request", "A storefront slug is required");
+  }
+  if (secret && typeof window !== "undefined") {
+    throw new ZappieError(
+      "invalid_request",
+      "Secret keys cannot be used in a browser"
+    );
+  }
+  const pattern = secret ? /^sk_(test|live)_.+$/ : /^pk_(test|live)_.+$/;
+  const match = pattern.exec(config.key);
+  if (!match) {
+    throw new ZappieError(
+      "invalid_request",
+      secret ? "A secret sk_test_ or sk_live_ key is required" : "Use a publishable pk_test_ or pk_live_ key; secret keys are never accepted by createZappie"
+    );
+  }
+  return match[1];
+}
+
+// ../sdk/src/internal/abort.ts
+function abortReason(signal) {
+  return signal?.reason ?? new DOMException("The request was aborted", "AbortError");
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw abortReason(signal);
+  }
+}
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    throwIfAborted(signal);
+    const abort = () => {
+      clearTimeout(timer);
+      reject(abortReason(signal));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+
+// ../sdk/src/internal/cache.ts
+var REFRESH_BACKOFF_MS = 1e4;
+var EMPTY = Object.freeze({
+  fetchedAt: 0,
+  loading: false
+});
+var Cache = class {
+  constructor(onError) {
+    this.onError = onError;
+    this.entries = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.flights = /* @__PURE__ */ new Map();
+    this.subscribe = (fn) => {
+      this.listeners.add(fn);
+      return () => {
+        this.listeners.delete(fn);
+      };
+    };
+  }
+  snapshot(key) {
+    return this.entries.get(key) ?? EMPTY;
+  }
+  notify() {
+    for (const fn of [...this.listeners]) {
+      fn();
+    }
+  }
+  set(key, value, etag) {
+    this.entries.set(key, {
+      value,
+      fetchedAt: Date.now(),
+      loading: false,
+      ...etag !== void 0 ? { etag } : {}
+    });
+    this.notify();
+  }
+  stale(key) {
+    const entry = this.snapshot(key);
+    return entry.value !== void 0 && Date.now() - entry.fetchedAt >= 6e4;
+  }
+  async get(key, loader, signal) {
+    throwIfAborted(signal);
+    const entry = this.snapshot(key);
+    const age = Date.now() - entry.fetchedAt;
+    if (entry.value !== void 0 && age < 6e4) {
+      return entry.value;
+    }
+    const background = entry.value !== void 0 && age < 6e5;
+    if (background && entry.failedAt !== void 0 && Date.now() - entry.failedAt < REFRESH_BACKOFF_MS) {
+      return entry.value;
+    }
+    let flight = this.flights.get(key);
+    if (!flight) {
+      const controller = new AbortController();
+      flight = {
+        controller,
+        users: 0,
+        keepAlive: background,
+        promise: Promise.resolve()
+      };
+      const current2 = flight;
+      this.flights.set(key, current2);
+      const loading = { ...entry, loading: true };
+      this.entries.set(key, loading);
+      this.notify();
+      current2.promise = Promise.resolve().then(() => {
+        throwIfAborted(controller.signal);
+        return loader(controller.signal, entry);
+      }).then((result) => {
+        if (this.entries.get(key) === loading && !controller.signal.aborted) {
+          this.set(key, result.value, result.etag);
+          result.onStored?.();
+        }
+        return result.value;
+      }).catch((error) => {
+        if (this.entries.get(key) === loading) {
+          this.entries.set(
+            key,
+            controller.signal.aborted ? { ...entry, loading: false } : {
+              ...entry,
+              loading: false,
+              error: asError(error),
+              failedAt: Date.now()
+            }
+          );
+          this.notify();
+          if (!controller.signal.aborted) {
+            this.onError(asError(error));
+          }
+        }
+        throw controller.signal.aborted ? abortReason(controller.signal) : asError(error);
+      }).finally(() => {
+        if (this.flights.get(key) === current2) {
+          this.flights.delete(key);
+        }
+      });
+    }
+    if (background) {
+      flight.keepAlive = true;
+      void flight.promise.catch(() => {
+      });
+      return entry.value;
+    }
+    const current = flight;
+    current.users++;
+    return new Promise((resolve, reject) => {
+      let done = false;
+      const finish = (callback) => {
+        if (done) {
+          return;
+        }
+        done = true;
+        signal?.removeEventListener("abort", abort);
+        current.users--;
+        callback();
+      };
+      const abort = () => {
+        finish(() => reject(abortReason(signal)));
+        if (current.users === 0 && !current.keepAlive) {
+          current.controller.abort(abortReason(signal));
+          if (this.flights.get(key) === current) {
+            this.flights.delete(key);
+          }
+        }
+      };
+      signal?.addEventListener("abort", abort, { once: true });
+      current.promise.then(
+        (value) => finish(() => resolve(value)),
+        (error) => finish(() => reject(error))
+      );
+      if (signal?.aborted) {
+        abort();
+      }
+    });
+  }
+};
+
+// ../sdk/src/internal/emitter.ts
+function createEmitter() {
+  const listeners = /* @__PURE__ */ new Map();
+  return {
+    on(event, fn) {
+      const set = listeners.get(event) ?? /* @__PURE__ */ new Set();
+      listeners.set(event, set);
+      set.add(fn);
+      return () => {
+        set.delete(fn);
+      };
+    },
+    emit(event, payload) {
+      for (const fn of [...listeners.get(event) ?? []]) {
+        try {
+          fn(payload);
+        } catch (error) {
+          console.error("Zappie event listener failed", error);
+        }
+      }
+    }
+  };
+}
+
+// ../sdk/src/internal/digest.ts
+async function payloadKey(payload) {
+  const digest = await globalThis.crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(payload)
+  );
+  return Array.from(
+    new Uint8Array(digest),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
+}
+
+// ../sdk/src/transport/mappers.ts
+var UnsupportedValue = class extends Error {
+};
+function record(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ZappieError("server_error", "Invalid storefront response object");
+  }
+  return value;
+}
+function text(value) {
+  if (typeof value !== "string") {
+    throw new ZappieError("server_error", "Invalid storefront response string");
+  }
+  return value;
+}
+function list(value) {
+  if (!Array.isArray(value)) {
+    throw new ZappieError("server_error", "Invalid storefront response list");
+  }
+  return value;
+}
+function number(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new ZappieError("server_error", "Invalid storefront response number");
+  }
+  return value;
+}
+function nonnegative(value) {
+  const result = number(value);
+  if (result < 0) {
+    throw new ZappieError(
+      "server_error",
+      "Negative selection or quantity bound"
+    );
+  }
+  return result;
+}
+function bounds(value) {
+  const input = record(value);
+  const min = nonnegative(input.min);
+  if (input.max == null) {
+    return { min };
+  }
+  const max = nonnegative(input.max);
+  if (max < min) {
+    throw new ZappieError(
+      "server_error",
+      "Maximum quantity is below its minimum"
+    );
+  }
+  return { min, max };
+}
+var isString = (value) => typeof value === "string";
+var isBoolean = (value) => typeof value === "boolean";
+function opt(key, value, is) {
+  return is(value) ? { [key]: value } : {};
+}
+function mapMoney(value) {
+  const v = record(value);
+  return money(number(v.amount_minor), text(v.currency));
+}
+function hours(value) {
+  return list(value ?? []).map((slot) => {
+    const v = record(slot);
+    const day = number(v.day);
+    if (!Number.isInteger(day) || day < 0 || day > 6) {
+      throw new ZappieError("server_error", "Invalid opening day");
+    }
+    return {
+      day,
+      opens: text(v.open),
+      closes: text(v.close),
+      ...opt("disabled", v.disabled, isBoolean)
+    };
+  });
+}
+function schedule(v) {
+  if (v.hours === void 0 && v.preorder === void 0) {
+    return void 0;
+  }
+  const preorder = v.preorder === void 0 ? void 0 : record(v.preorder);
+  return {
+    openingTimes: hours(v.hours),
+    ...preorder ? {
+      preorder: true,
+      preorderNoticeHours: number(preorder.notice_hours),
+      preorderMaxDays: number(preorder.max_days)
+    } : {}
+  };
+}
+function mapGroup(value) {
+  const g = record(value);
+  const selection = { min: g.min, max: g.max };
+  const isAttribute = g.kind === "attribute";
+  const kind = text(g.kind);
+  if (!["attribute", "choice", "text"].includes(kind)) {
+    throw new UnsupportedValue(`option input kind "${kind}"`);
+  }
+  return {
+    id: text(g.id),
+    name: text(g.name),
+    kind: kind === "text" ? "text" : "select",
+    required: typeof g.required === "boolean" ? g.required : number(selection.min) > 0,
+    selection: bounds(selection),
+    isAttribute,
+    choices: list(g.choices ?? []).map((raw) => {
+      const c = record(raw);
+      const price = mapMoney(c.price);
+      return {
+        id: text(c.id),
+        name: text(c.name),
+        price: isAttribute ? money(0, price.currency) : price,
+        ...isAttribute && c.price_hint !== void 0 ? { priceHint: mapMoney(c.price_hint) } : {},
+        isAvailable: c.available === true,
+        ...c.variable_quantity === true ? {
+          quantity: bounds({
+            min: c.min_quantity ?? 1,
+            max: c.max_quantity
+          })
+        } : {}
+      };
+    }),
+    ...opt("helpText", g.help_text, isString),
+    ...isString(g.placeholder) ? { input: { placeholder: g.placeholder } } : {},
+    ...g.conditions ? {
+      conditions: list(g.conditions).map((raw) => {
+        const c = record(raw);
+        const count = c.count ? record(c.count) : void 0;
+        if (count && !["eq", "gte", "lte"].includes(text(count.op))) {
+          throw new UnsupportedValue(
+            `option count operator "${text(count.op)}"`
+          );
+        }
+        if (c.match !== void 0 && c.match !== "any" && c.match !== "all") {
+          throw new UnsupportedValue(
+            `option match operator "${String(c.match)}"`
+          );
+        }
+        if (c.set_required != null && typeof c.set_required !== "boolean") {
+          throw new ZappieError(
+            "server_error",
+            "Invalid conditional required flag"
+          );
+        }
+        return {
+          groupId: text(c.group_id),
+          choiceIds: list(c.choice_ids ?? []).map(text),
+          match: c.match === "all" ? "all" : "any",
+          ...count ? {
+            count: {
+              op: text(count.op),
+              value: nonnegative(count.value)
+            }
+          } : {},
+          ...c.set_required !== void 0 ? { setRequired: c.set_required } : {},
+          ...c.set_min !== void 0 ? { setMin: c.set_min === null ? null : nonnegative(c.set_min) } : {},
+          ...c.set_max !== void 0 ? { setMax: c.set_max === null ? null : nonnegative(c.set_max) } : {}
+        };
+      })
+    } : {}
+  };
+}
+function mapPromo(value) {
+  const p = record(value);
+  return { name: text(p.name) };
+}
+function mapItem(value) {
+  const v = record(value);
+  const id = text(v.id);
+  const optionGroups = [];
+  let unsupported = false;
+  for (const raw of list(v.option_groups ?? [])) {
+    try {
+      optionGroups.push(mapGroup(raw));
+    } catch (error) {
+      if (!(error instanceof UnsupportedValue)) {
+        throw error;
+      }
+      unsupported = true;
+      console.warn(
+        `Zappie item ${id} uses an ${error.message} this SDK can't validate; it is shown as unavailable`
+      );
+    }
+  }
+  let unresolved = false;
+  const variants = list(v.variants).map((raw) => {
+    const x = record(raw);
+    const seen = /* @__PURE__ */ new Set();
+    return {
+      id: text(x.id),
+      attributeChoices: Object.fromEntries(
+        list(x.choice_ids).map((rawId) => {
+          const choiceId = text(rawId);
+          const groups = optionGroups.filter(
+            (group) => group.isAttribute && group.choices.some((choice) => choice.id === choiceId)
+          );
+          if (groups.length !== 1 || seen.has(groups[0].id)) {
+            unresolved = true;
+            return ["", choiceId];
+          }
+          seen.add(groups[0].id);
+          return [groups[0].id, choiceId];
+        }).filter(([groupId]) => groupId)
+      ),
+      price: mapMoney(x.price),
+      ...opt("lowStock", x.low_stock, isBoolean),
+      isAvailable: x.available === true
+    };
+  });
+  if (unresolved) {
+    console.warn(
+      `Zappie item ${id} has a variant whose choices don't match its attributes; it is shown as unavailable`
+    );
+  }
+  if (unsupported || unresolved) {
+    for (const variant of variants) {
+      variant.isAvailable = false;
+    }
+  }
+  if (!variants.length) {
+    throw new ZappieError(
+      "server_error",
+      "An item must carry at least one exact variant"
+    );
+  }
+  const quantity = { min: v.min_quantity ?? 1, max: v.max_quantity };
+  if (new Set(variants.map((variant) => variant.id)).size !== variants.length) {
+    throw new ZappieError("server_error", "Duplicate variant identity");
+  }
+  return {
+    ...v.placements !== void 0 ? {
+      placements: list(v.placements).map((raw) => {
+        const placement = record(raw);
+        return {
+          menuId: text(placement.menu_id),
+          categoryId: text(placement.category_id)
+        };
+      })
+    } : {},
+    id,
+    name: text(v.name),
+    images: list(v.images ?? []).map(text),
+    price: mapMoney(v.price),
+    isAvailable: !unsupported && !unresolved && v.available === true,
+    quantity: { ...bounds(quantity), step: 1 },
+    variants,
+    optionGroups,
+    tags: list(v.tags ?? []).map(text),
+    ...v.fulfilment !== void 0 ? { fulfilment: list(v.fulfilment).map(text) } : {},
+    ...opt("stockLabel", v.stock_label, isString),
+    ...v.promo !== void 0 ? { promo: mapPromo(v.promo) } : {},
+    ...opt("description", v.description, isString),
+    ...v.previous_price ? { compareAtPrice: mapMoney(v.previous_price) } : {}
+  };
+}
+function mapMenu(value, branchId) {
+  const v = record(value);
+  const sources = list(v.menus);
+  if (v.completeness !== void 0 && v.completeness !== "partial" && v.completeness !== "complete") {
+    throw new ZappieError("server_error", "Invalid catalogue completeness");
+  }
+  const categories = /* @__PURE__ */ new Map();
+  const menus = sources.map((raw) => {
+    const m = record(raw);
+    if (m.placement_count !== void 0 && (!Number.isSafeInteger(m.placement_count) || Number(m.placement_count) < 0) || m.paginated !== void 0 && typeof m.paginated !== "boolean") {
+      throw new ZappieError("server_error", "Invalid menu loading metadata");
+    }
+    const categoryIds = list(m.categories ?? []).map((rawCategory) => {
+      const c = record(rawCategory);
+      const id = text(c.id);
+      const previous = categories.get(id);
+      const itemIds = [
+        .../* @__PURE__ */ new Set([
+          ...previous?.itemIds ?? [],
+          ...list(c.item_ids ?? []).map(text)
+        ])
+      ];
+      categories.set(id, {
+        id,
+        name: text(c.name),
+        itemIds
+      });
+      return id;
+    });
+    const s = schedule(m);
+    return {
+      id: text(m.id),
+      name: text(m.name),
+      categoryIds,
+      ...m.fulfilment !== void 0 ? { fulfilment: list(m.fulfilment).map(text) } : {},
+      ...m.placement_count !== void 0 ? { placementCount: m.placement_count } : {},
+      ...opt("paginated", m.paginated, isBoolean),
+      ...s ? { schedule: s } : {},
+      ...opt("infoBanner", m.info_banner, isString)
+    };
+  });
+  const items = Object.fromEntries(
+    Object.entries(record(v.items)).map(([id, item]) => {
+      const mapped = mapItem(item);
+      if (mapped.id !== id) {
+        throw new ZappieError(
+          "server_error",
+          "Item map key does not match its identity"
+        );
+      }
+      return [id, mapped];
+    })
+  );
+  if (v.branch_id !== void 0 && v.branch_id !== branchId) {
+    throw new ZappieError("server_error", "Menu branch mismatch");
+  }
+  return {
+    id: menus.length === 1 ? menus[0].id : `branch:${branchId}`,
+    branchId,
+    ...v.completeness === "partial" ? { completeness: "partial" } : {},
+    name: menus.length === 1 ? menus[0].name : "Catalogue",
+    version: text(v.menu_version),
+    categories: [...categories.values()],
+    items,
+    menus,
+    ...menus.length === 1 && menus[0].schedule ? { schedule: menus[0].schedule } : {}
+  };
+}
+function mapSeo(value) {
+  const seo = record(value);
+  if (typeof seo.hidden !== "boolean") {
+    throw new ZappieError("server_error", "Invalid store search visibility");
+  }
+  return {
+    titlePattern: text(seo.title_pattern),
+    description: text(seo.description),
+    shareImageUrl: text(seo.share_image_url),
+    searchConsoleToken: text(seo.search_console_token),
+    hidden: seo.hidden,
+    redirects: list(seo.redirects).map((raw) => {
+      const redirect = record(raw);
+      return { from: text(redirect.from), to: text(redirect.to) };
+    })
+  };
+}
+
+// ../sdk/src/transport/rest.ts
+var MAX_RETRY_WAIT_MS = 5e3;
+var wireFulfilment2 = (value) => value === "dineIn" ? "dine_in" : value;
+var presentationError = () => new ZappieError("server_error", "Invalid storefront presentation");
+var RestTransport = class {
+  constructor(opts = {}) {
+    const url = new URL(opts.baseUrl ?? "https://api.zappie.ai/storefront/v1");
+    if (url.username || url.password || url.search || url.hash || url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) {
+      throw new ZappieError(
+        "invalid_request",
+        "REST baseUrl requires HTTPS, or HTTP on localhost"
+      );
+    }
+    this.baseUrl = url.href.replace(/\/$/, "");
+    this.fetcher = opts.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  }
+  async request(path, ctx, etag, body) {
+    if (typeof window !== "undefined" && ctx.key.startsWith("sk_")) {
+      throw new ZappieError(
+        "invalid_request",
+        "Secret keys cannot be sent from a browser"
+      );
+    }
+    for (let attempt = 0; ; attempt++) {
+      throwIfAborted(ctx.signal);
+      let response;
+      try {
+        response = await this.fetcher(this.baseUrl + path, {
+          method: body ? "POST" : "GET",
+          ...body ? { body: JSON.stringify(body) } : {},
+          // Workers reject redirect: "error"; a redirect is still refused below
+          // as a non-OK response (a 3xx, or opaqueredirect in browsers).
+          redirect: "manual",
+          headers: {
+            ...body ? { "Content-Type": "application/json" } : {},
+            ...ctx.idempotencyKey ? { "Idempotency-Key": ctx.idempotencyKey } : {},
+            Authorization: `Bearer ${ctx.key}`,
+            "Zappie-Version": ctx.version,
+            ...etag ? { "If-None-Match": etag } : {}
+          },
+          ...ctx.signal ? { signal: ctx.signal } : {}
+        });
+      } catch (error) {
+        throwIfAborted(ctx.signal);
+        if (attempt >= 2) {
+          throw new ZappieError(
+            "network_error",
+            "Could not reach the storefront service",
+            { cause: error }
+          );
+        }
+        await delay(100 * 2 ** attempt + Math.random() * 100, ctx.signal);
+        continue;
+      }
+      if (response.ok || response.status === 304) {
+        return response;
+      }
+      const retry = response.headers.get("Retry-After");
+      const seconds = retry !== null ? Number(retry) : NaN;
+      const wait2 = retry !== null ? Number.isFinite(seconds) ? Math.max(0, seconds * 1e3) : Math.max(0, Date.parse(retry) - Date.now()) : NaN;
+      const tooLong = Number.isFinite(wait2) && wait2 > MAX_RETRY_WAIT_MS;
+      if (attempt < 2 && !tooLong && (response.status === 429 || response.status >= 500)) {
+        await response.body?.cancel();
+        await delay(
+          Number.isFinite(wait2) ? wait2 : 100 * 2 ** attempt + Math.random() * 100,
+          ctx.signal
+        );
+        continue;
+      }
+      const errorBody = await response.json().catch(() => ({}));
+      throw wireError(
+        errorBody,
+        response.status,
+        response.headers.get("Zappie-Request-Id") ?? void 0
+      );
+    }
+  }
+  async json(response) {
+    try {
+      return await response.json();
+    } catch (cause) {
+      if (cause instanceof Error && cause.name === "AbortError") {
+        throw cause;
+      }
+      throw new ZappieError(
+        "server_error",
+        "The storefront service returned invalid JSON",
+        { status: response.status, cause }
+      );
+    }
+  }
+  async quote(ctx, body) {
+    body = (await import("./quote-body-S5LELT7L.js")).quoteBody(body);
+    const request = {
+      ...ctx,
+      idempotencyKey: ctx.idempotencyKey ?? await payloadKey(JSON.stringify(body))
+    };
+    const raw = await this.json(
+      await this.request("/quote", request, void 0, body)
+    );
+    return raw;
+  }
+  async getStore(ctx) {
+    const mapper = import("./store-OPM3OFLC.js").catch((cause) => {
+      throw new ZappieError(
+        "server_error",
+        "Could not load the storefront store mapper",
+        { cause }
+      );
+    });
+    const presentation = import("./presentation-TKOXOILG.js");
+    const response = this.request("/store", ctx).then(
+      (value) => this.json(value)
+    );
+    const [{ mapStore }, { presentStore }, raw] = await Promise.all([
+      mapper,
+      presentation,
+      response
+    ]);
+    const store = mapStore(
+      raw,
+      record,
+      text,
+      list,
+      hours,
+      mapMoney,
+      money,
+      opt,
+      isString,
+      isBoolean,
+      mapSeo
+    );
+    return presentStore(store, raw, presentationError);
+  }
+  async getMenu(ctx) {
+    const presentation = import("./presentation-TKOXOILG.js");
+    let cursor;
+    const seen = /* @__PURE__ */ new Set();
+    let output;
+    let etag;
+    do {
+      const query = new URLSearchParams({
+        branch: ctx.branchId,
+        ...ctx.fulfilment ? { fulfilment: wireFulfilment2(ctx.fulfilment) } : {},
+        ...ctx.metadataOnly ? { metadata_only: "true" } : {},
+        ...cursor ? { cursor } : {}
+      });
+      const response = await this.request(
+        `/menus?${query}`,
+        ctx,
+        cursor ? void 0 : ctx.ifNoneMatch
+      );
+      if (response.status === 304) {
+        if (cursor) {
+          throw new ZappieError(
+            "server_error",
+            "Unexpected 304 on a continuation page"
+          );
+        }
+        return {
+          notModified: true,
+          ...response.headers.get("ETag") ? { etag: response.headers.get("ETag") } : {}
+        };
+      }
+      const raw = record(await this.json(response));
+      const page = (await presentation).presentMenu(
+        mapMenu(raw, ctx.branchId),
+        raw,
+        presentationError
+      );
+      if (ctx.metadataOnly) {
+        if (Object.keys(page.items).length || raw.next_cursor) {
+          throw new ZappieError("server_error", "Invalid metadata response");
+        }
+        return { menu: { ...page, completeness: "partial" } };
+      }
+      if (!output) {
+        output = page;
+        etag = response.headers.get("ETag") ?? void 0;
+      } else {
+        if (page.version !== output.version) {
+          throw new ZappieError(
+            "server_error",
+            "Menu changed while fetching pages; retry the read"
+          );
+        }
+        Object.assign(output.items, page.items);
+        for (const category of page.categories) {
+          const existing = output.categories.find((c) => c.id === category.id);
+          if (existing) {
+            existing.itemIds = [
+              .../* @__PURE__ */ new Set([...existing.itemIds, ...category.itemIds])
+            ];
+          } else {
+            output.categories.push(category);
+          }
+        }
+        for (const section of page.menus ?? []) {
+          const existing = output.menus?.find((m) => m.id === section.id);
+          if (existing) {
+            existing.categoryIds = [
+              .../* @__PURE__ */ new Set([...existing.categoryIds, ...section.categoryIds])
+            ];
+          } else {
+            output.menus?.push(section);
+          }
+        }
+      }
+      cursor = typeof raw.next_cursor === "string" && raw.next_cursor ? raw.next_cursor : void 0;
+      if (cursor) {
+        if (seen.has(cursor)) {
+          throw new ZappieError(
+            "server_error",
+            "Repeated menu pagination cursor"
+          );
+        }
+        seen.add(cursor);
+      }
+    } while (cursor);
+    if (output.menus && output.menus.length > 1) {
+      output.id = `branch:${ctx.branchId}`;
+      output.name = "Catalogue";
+      delete output.schedule;
+    }
+    for (const category of output.categories) {
+      for (const id of category.itemIds) {
+        if (!Object.prototype.hasOwnProperty.call(output.items, id)) {
+          throw new ZappieError(
+            "server_error",
+            "Category refers to a missing item"
+          );
+        }
+      }
+    }
+    if (Object.keys(output.items).length > 2e3) {
+      console.warn("Zappie menu contains more than 2,000 items");
+    }
+    return { menu: output, ...etag ? { etag } : {} };
+  }
+  async getSelectedMenu(ctx) {
+    return (await import("./selected-menu-AQHWDELR.js")).selectedMenu(
+      ctx,
+      (path) => this.request(path, ctx, ctx.ifNoneMatch),
+      (response) => this.json(response),
+      mapMenu,
+      () => new ZappieError("server_error", "Invalid selected menu")
+    );
+  }
+  async search(ctx) {
+    return (await import("./search-OF62VKI3.js")).searchPage(
+      ctx,
+      async (path) => this.json(await this.request(path, ctx)),
+      mapMenu,
+      () => new ZappieError("server_error", "Invalid search page")
+    );
+  }
+  async getCategoryPage(ctx) {
+    const query = new URLSearchParams({
+      branch: ctx.branchId,
+      ...ctx.cursor ? { cursor: ctx.cursor } : {}
+    });
+    const raw = await this.json(
+      await this.request(
+        `/menus/${encodeURIComponent(ctx.menuId)}/categories/${encodeURIComponent(ctx.categoryId)}/items?${query}`,
+        ctx
+      )
+    );
+    return (await import("./category-page-I3HDIAJA.js")).categoryPage(
+      record(raw),
+      ctx,
+      mapMenu,
+      () => new ZappieError("server_error", "Invalid category page")
+    );
+  }
+  async getMenuVersion(ctx) {
+    const value = record(
+      await this.json(
+        await this.request(
+          `/menus/version?${new URLSearchParams({
+            branch: ctx.branchId,
+            ...ctx.fulfilment ? { fulfilment: wireFulfilment2(ctx.fulfilment) } : {}
+          })}`,
+          ctx
+        )
+      )
+    );
+    if (typeof value.menu_version !== "string" || typeof value.availability_hash !== "string") {
+      throw new ZappieError("server_error", "Invalid menu version response");
+    }
+    return {
+      version: value.menu_version,
+      availabilityHash: value.availability_hash
+    };
+  }
+  async getItem(ctx) {
+    const item = mapItem(
+      await this.json(
+        await this.request(
+          `/items/${encodeURIComponent(ctx.itemId)}?${new URLSearchParams({ branch: ctx.branchId })}`,
+          ctx
+        )
+      )
+    );
+    if (item.id !== ctx.itemId) {
+      throw new ZappieError(
+        "server_error",
+        "Item response identity does not match the request"
+      );
+    }
+    return item;
+  }
+};
+
+// ../sdk/src/client.ts
+function buildClient(input, secret = false) {
+  const mode = validateConfig(input, secret);
+  const config = Object.freeze({
+    ...input,
+    version: input.version ?? API_VERSION,
+    telemetry: input.telemetry ?? true
+  });
+  const transport = input.transport ?? new RestTransport({
+    ...input.baseUrl ? { baseUrl: input.baseUrl } : {},
+    ...input.fetch ? { fetch: input.fetch } : {}
+  });
+  const events = createEmitter();
+  const cache = new Cache((error) => events.emit("error", { error }));
+  const ctx = (signal) => ({
+    key: config.key,
+    version: config.version,
+    ...signal ? { signal } : {}
+  });
+  const store = {
+    get: (opts = {}) => cache.get(
+      "store",
+      async (signal) => ({ value: await transport.getStore(ctx(signal)) }),
+      opts.signal
+    ),
+    peek: () => cache.snapshot("store").value
+  };
+  const resolveBranch = (value, requested) => {
+    const selected = requested ?? config.branch;
+    const branch = selected ? value.branches.find((b) => b.id === selected || b.slug === selected) : value.branches.find((b) => b.isDefault) ?? value.branches[0];
+    if (!branch) {
+      throw new ZappieError(
+        "branch_not_found",
+        "No matching storefront branch",
+        { param: "branch" }
+      );
+    }
+    return branch;
+  };
+  let hydratedBranch;
+  const branchKey = (requested) => {
+    const value = store.peek();
+    if (value) {
+      return resolveBranch(value, requested).id;
+    }
+    const selected = requested ?? config.branch;
+    if (hydratedBranch && (selected === void 0 || selected === config.branch || selected === hydratedBranch)) {
+      return hydratedBranch;
+    }
+    return selected ?? "default";
+  };
+  const menuKey = (requested) => `menu:${branchKey(requested)}`;
+  const menu = {
+    async search(query, opts = {}) {
+      if (!transport.search) {
+        throw new ZappieError(
+          "invalid_request",
+          "Transport does not support search"
+        );
+      }
+      const branch = resolveBranch(await store.get(opts), opts.branch);
+      return transport.search({
+        ...ctx(opts.signal),
+        branchId: branch.id,
+        query,
+        ...opts.cursor ? { cursor: opts.cursor } : {}
+      });
+    },
+    async get(opts = {}) {
+      const branch = resolveBranch(await store.get(opts), opts.branch);
+      return cache.get(
+        `${menuKey(branch.id)}${opts.fulfilment ? `:${opts.fulfilment}` : ""}${opts.metadataOnly ? ":partial" : ""}`,
+        async (signal, entry) => {
+          const response = await transport.getMenu({
+            ...ctx(signal),
+            branchId: branch.id,
+            fulfilment: opts.fulfilment,
+            ...opts.metadataOnly ? { metadataOnly: true } : {},
+            ...entry.etag ? { ifNoneMatch: entry.etag } : {}
+          });
+          if ("notModified" in response) {
+            if (!entry.value) {
+              throw new ZappieError(
+                "server_error",
+                "Received 304 without a cached menu"
+              );
+            }
+            return {
+              value: entry.value,
+              ...response.etag ?? entry.etag ? { etag: response.etag ?? entry.etag } : {}
+            };
+          }
+          if (!opts.metadataOnly && response.menu.completeness === "partial") {
+            throw new ZappieError(
+              "server_error",
+              "Partial catalogue cannot satisfy a complete read"
+            );
+          }
+          if (response.menu.branchId !== branch.id) {
+            throw new ZappieError(
+              "server_error",
+              "Menu belongs to a different branch"
+            );
+          }
+          return {
+            value: response.menu,
+            etag: response.etag ?? response.menu.version,
+            onStored: () => {
+              if (entry.value && entry.value.version !== response.menu.version) {
+                events.emit("menu:updated", {
+                  branchId: branch.id,
+                  version: response.menu.version
+                });
+              }
+            }
+          };
+        },
+        opts.signal
+      );
+    },
+    peek: (branch) => cache.snapshot(menuKey(branch)).value ?? cache.snapshot(`${menuKey(branch)}:partial`).value,
+    async page(menuId, categoryId, opts = {}) {
+      if (!transport.getCategoryPage) {
+        throw new ZappieError(
+          "invalid_request",
+          "Transport does not support category pages"
+        );
+      }
+      const branch = resolveBranch(await store.get(opts), opts.branch);
+      return transport.getCategoryPage({
+        ...ctx(opts.signal),
+        branchId: branch.id,
+        menuId,
+        categoryId,
+        ...opts.cursor ? { cursor: opts.cursor } : {}
+      });
+    },
+    async version(opts = {}) {
+      const branch = resolveBranch(await store.get(opts), opts.branch);
+      return transport.getMenuVersion({
+        ...ctx(opts.signal),
+        branchId: branch.id,
+        fulfilment: opts.fulfilment
+      });
+    },
+    async item(id, opts = {}) {
+      const branch = resolveBranch(await store.get(opts), opts.branch);
+      if (!menu.peek(branch.id) || menu.peek(branch.id)?.completeness === "partial") {
+        await menu.get({ ...opts, metadataOnly: true });
+      }
+      return readItem(id, branch.id, false, opts.signal);
+    },
+    hydrate(value) {
+      hydratedBranch ??= value.branchId;
+      const previous = cache.snapshot(`menu:${value.branchId}`).value;
+      cache.set(
+        `menu:${value.branchId}${value.completeness === "partial" ? ":partial" : ""}`,
+        value,
+        value.version
+      );
+      if (previous && previous.version !== value.version) {
+        events.emit("menu:updated", {
+          branchId: value.branchId,
+          version: value.version
+        });
+      }
+    }
+  };
+  const itemValues = /* @__PURE__ */ new Map();
+  const peekItem = (id, branch) => itemValues.get(`${branch}:${id}`);
+  const readItem = async (id, branch, fresh = false, signal) => {
+    const complete = cache.snapshot(`menu:${branch}`).value;
+    if (!fresh && complete && Object.hasOwn(complete.items, id)) {
+      return complete.items[id];
+    }
+    const load = (requestSignal = signal) => transport.getItem({
+      ...ctx(requestSignal),
+      branchId: branch,
+      itemId: id
+    });
+    try {
+      const value = fresh ? await load() : await cache.get(
+        `item:${branch}:${id}`,
+        async (requestSignal) => ({ value: await load(requestSignal) }),
+        signal
+      );
+      if (fresh) {
+        cache.set(`item:${branch}:${id}`, value);
+      }
+      itemValues.set(`${branch}:${id}`, value);
+      return value;
+    } catch (error) {
+      if (error.code === "item_not_found") {
+        itemValues.delete(`${branch}:${id}`);
+        cache.set(`item:${branch}:${id}`, void 0);
+      }
+      throw error;
+    }
+  };
+  const workingSet = createWorkingSet({
+    menu,
+    store,
+    transport,
+    context: ctx,
+    peekItem,
+    readItem
+  });
+  const { cart, setLegacyReader, cartCatalogue } = createCart({
+    workingSet,
+    config,
+    menu,
+    store,
+    transport,
+    context: ctx,
+    events
+  });
+  return Object.freeze({
+    cart,
+    config,
+    mode,
+    store,
+    menu,
+    format,
+    on: events.on,
+    _internal: {
+      cartCatalogue,
+      setLegacyReader,
+      transport,
+      cache,
+      emit: events.emit,
+      menuKey,
+      hydrateStore: (value) => cache.set("store", value)
+    }
+  });
+}
+function createZappie(config) {
+  const client = buildClient(config);
+  if (client.mode === "test" && typeof window !== "undefined") {
+    void import("./debug-LOXPIQRS.js").then(({ installDebug }) => installDebug(client));
+  }
+  return client;
+}
+
+// ../sdk/src/cart/preview.ts
+function previewQuantity(value) {
+  return Number.isInteger(value) && value >= 0 && value <= 99 ? value : 0;
+}
+function previewItem(item, raw) {
+  const input = normalizeInput(item, raw);
+  const groups = effectiveGroups(item, input).filter(
+    (group) => group.isAvailable !== false
+  );
+  const variantId = resolveVariant(item, input)?.id;
+  const choices = (input.choices ?? []).filter(
+    ({ groupId, choiceId }) => groups.some(
+      (group) => group.id === groupId && group.choices.some((choice) => choice.id === choiceId)
+    )
+  ).map((selection) => ({
+    ...selection,
+    quantity: previewQuantity(selection.quantity)
+  }));
+  const unitPrice = estimateUnitPrice(item, {
+    choices,
+    ...variantId ? { variantId } : {}
+  });
+  const total = multiplyMoney(unitPrice, previewQuantity(input.quantity));
+  return { groups, unitPrice, total };
+}
+
+// ../sdk/src/internal/customer-http.ts
+function stableErrorCode(status) {
+  if (status === 400 || status === 422) {
+    return "invalid_request";
+  }
+  if (status === 401) {
+    return "unauthorized";
+  }
+  if (status === 404) {
+    return "not_found";
+  }
+  if (status === 429) {
+    return "rate_limited";
+  }
+  return "server_error";
+}
+async function apiError(response, fallback) {
+  const body = await response.json().catch(() => ({}));
+  const envelope = body && typeof body === "object" ? body : {};
+  const value = "error" in envelope && envelope.error && typeof envelope.error === "object" ? envelope.error : {};
+  return {
+    apiCode: "code" in value && typeof value.code === "string" ? value.code : "server_error",
+    message: "message" in value && typeof value.message === "string" ? value.message : fallback,
+    ..."param" in value && typeof value.param === "string" ? { param: value.param } : {},
+    ..."issues" in value ? { issues: value.issues } : {}
+  };
+}
+function wait(ms, signal) {
+  signal?.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const done = () => {
+      signal?.removeEventListener("abort", aborted);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    const aborted = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", aborted);
+      reject(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    signal?.addEventListener("abort", aborted, { once: true });
+  });
+}
+async function requestWithRetry(fetcher, input, init, message) {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      return await fetcher(input, {
+        ...init,
+        credentials: "same-origin",
+        headers: { Accept: "application/json", ...init.headers }
+      });
+    } catch (cause) {
+      if (init.signal?.aborted) {
+        throw init.signal.reason ?? cause;
+      }
+      if (attempt === 1) {
+        throw new ZappieError("network_error", message, {
+          cause,
+          retryable: true
+        });
+      }
+      await wait(400, init.signal ?? void 0);
+    }
+  }
+  throw new ZappieError("network_error", message, { retryable: true });
+}
+
+export {
+  ZappieError,
+  wireError,
+  money,
+  format,
+  sumMoney,
+  resolveSourceMenu,
+  validateLine,
+  stableErrorCode,
+  apiError,
+  requestWithRetry,
+  payloadKey,
+  record,
+  mapMoney,
+  API_VERSION,
+  validateConfig,
+  RestTransport,
+  createZappie,
+  previewItem
+};
+//# sourceMappingURL=chunk-47RIF6JW.js.map