@zappie/verify 0.1.3 → 0.2.2

package/dist/index.js

@@ -1,30 +1,25 @@
 import {
+  API_VERSION,
+  RestTransport,
   ZappieError,
-  asError,
+  apiError,
+  createZappie,
   format,
-  hours,
-  isBoolean,
-  isString,
-  list,
-  mapItem,
-  mapMenu,
-  mapMoney,
-  money,
-  multiplyMoney,
-  opt,
-  payloadKey,
-  record,
-  sumMoney,
-  text,
-  wireError
-} from "./chunk-WUWUDCYO.js";
+  previewItem,
+  requestWithRetry,
+  resolveSourceMenu,
+  stableErrorCode,
+  validateConfig,
+  validateLine
+} from "./chunk-47RIF6JW.js";
 
 // src/error.ts
 var VerifyError = class extends Error {
-  constructor(code, message, hint) {
+  constructor(code, message, hint, skip = false) {
     super(message);
     this.code = code;
     this.hint = hint;
+    this.skip = skip;
     this.name = "VerifyError";
   }
 };
@@ -33,6 +28,9 @@ function assertion(condition, code, message, hint) {
     throw new VerifyError(code, message, hint);
   }
 }
+function skipCheck(code, message, hint) {
+  throw new VerifyError(code, message, hint, true);
+}
 
 // src/local-preview.ts
 import { spawn } from "child_process";
@@ -291,6 +289,20 @@ async function debugValue(page, expression) {
 }
 var mobile = { width: 390, height: 844 };
 var desktop = { width: 1440, height: 900 };
+async function applyPhoneProfile(page, rate) {
+  const cdp = await page.context().newCDPSession(page);
+  await cdp.send("Network.enable");
+  await cdp.send("Network.setCacheDisabled", { cacheDisabled: true });
+  await cdp.send("Network.emulateNetworkConditions", {
+    offline: false,
+    latency: 150,
+    downloadThroughput: 2e5,
+    uploadThroughput: 1e5,
+    connectionType: "cellular3g"
+  });
+  await cdp.send("Emulation.setCPUThrottlingRate", { rate });
+  return cdp;
+}
 
 // src/checks/v01-routes.ts
 var v01 = {
@@ -360,2278 +372,277 @@ var v02 = {
   }
 };
 
-// ../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;
+// src/fixtures.ts
+async function installFault(page, fault) {
+  if (!fault) {
+    return;
   }
-  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;
+  if (fault === "hydration-delay") {
+    await page.route(/\.(?:js|mjs)(?:\?|$)/, async (route) => {
+      await new Promise((resolve) => setTimeout(resolve, 3500));
+      await route.continue();
+    });
   }
-}
-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" }
-      ])
-    ];
+  if (fault === "no-route-data" || fault === "no-prefetch") {
+    await page.route(
+      /\/item\/[^/]+\.data(?:\?|$)/,
+      (route) => route.request().headers()["sec-purpose"] === "prefetch" ? route.abort() : route.continue()
+    );
   }
-  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
-        )
-      );
-    }
+  if (fault === "no-prefetch") {
+    await page.route(/\/assets\/[^/]*item[^/]*\.js(?:\?|$)/, async (route) => {
+      await new Promise((resolve) => setTimeout(resolve, 1e4));
+      await route.continue();
+    });
   }
-  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
-        )
-      );
-    }
+  if (fault === "extra-h1") {
+    await page.addInitScript(() => {
+      new MutationObserver(() => {
+        const main = document.querySelector("main");
+        if (main && !document.querySelector("[data-verify-extra-h1]")) {
+          const heading = document.createElement("h1");
+          heading.setAttribute("data-verify-extra-h1", "");
+          heading.textContent = "Second heading";
+          main.append(heading);
+        }
+      }).observe(document, { childList: true, subtree: true });
+    });
   }
-  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
-        )
-      )
-    ];
+  if (fault === "overlay-markers") {
+    await page.addInitScript(() => {
+      new MutationObserver(() => {
+        for (const node of document.querySelectorAll(
+          "[data-zappie-cart-trigger]:not([data-zappie-overlay-trigger])"
+        )) {
+          node.setAttribute("data-zappie-overlay-trigger", "bag");
+        }
+        for (const node of document.querySelectorAll(
+          '[role="dialog"]:not([data-zappie-overlay])'
+        )) {
+          if (node.textContent?.includes("Your cart")) {
+            node.setAttribute("data-zappie-overlay", "bag");
+          }
+        }
+      }).observe(document, { childList: true, subtree: true });
+    });
   }
-  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
-        )
+  if (fault === "bag-on-tap") {
+    let release = () => {
+    };
+    let tapped = Promise.resolve();
+    const reset2 = () => {
+      release();
+      tapped = new Promise((resolve) => {
+        release = resolve;
+      });
+    };
+    reset2();
+    page.on("framenavigated", (frame) => {
+      if (frame === page.mainFrame()) {
+        reset2();
+      }
+    });
+    await page.exposeFunction("__verifyTapped", () => release());
+    await page.addInitScript(() => {
+      document.addEventListener(
+        "click",
+        () => {
+          void window.__verifyTapped?.();
+        },
+        { capture: true }
       );
-    }
-    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
-          )
-        );
+    });
+    await page.route(
+      /\/assets\/cart-drawer-[^/]*\.js(?:\?|$)/,
+      async (route) => {
+        await tapped;
+        await route.continue().catch(() => {
+        });
       }
-      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
+    );
+  }
+  if (fault === "one-slow-open") {
+    await page.addInitScript(() => {
+      document.addEventListener(
+        "click",
+        (event) => {
+          if (!(event.target instanceof Element) || !event.target.closest("[data-zappie-overlay-trigger]")) {
+            return;
+          }
+          const taps = Number(sessionStorage.getItem("__verifyTaps") ?? 0);
+          sessionStorage.setItem("__verifyTaps", String(taps + 1));
+          if (taps % 3 === 0) {
+            const until = performance.now() + 250;
+            while (performance.now() < until) {
+            }
+          }
+        },
+        { capture: true }
+      );
+    });
+  }
+  if (fault === "late-hydration") {
+    await page.route(
+      /\/assets\/entry\.client-[^/]*\.js(?:\?|$)/,
+      async (route) => {
+        const response = await route.fetch();
+        const headers = Object.fromEntries(
+          Object.entries(response.headers()).filter(
+            ([name]) => !["content-encoding", "content-length"].includes(name)
           )
         );
+        await route.fulfill({
+          response,
+          headers,
+          body: `await new Promise((resolve) => setTimeout(resolve, 2000));
+${await response.text()}`
+        });
       }
-    }
-  }
-  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");
+  if (fault === "late-idle") {
+    await page.addInitScript(() => {
+      const request = window.requestIdleCallback?.bind(window);
+      const cancel = window.cancelIdleCallback?.bind(window);
+      if (!request || !cancel) {
+        return;
       }
-      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
+      const handles = /* @__PURE__ */ new Map();
+      let next = 1;
+      window.requestIdleCallback = (callback, options) => {
+        const handle = next++;
+        handles.set(
+          handle,
+          window.setTimeout(() => {
+            handles.set(handle, -request(callback, options));
+          }, 1500)
+        );
+        return handle;
+      };
+      window.cancelIdleCallback = (handle) => {
+        const scheduled = handles.get(handle);
+        if (scheduled === void 0) {
+          return;
+        }
+        if (scheduled < 0) {
+          cancel(-scheduled);
+        } else {
+          window.clearTimeout(scheduled);
+        }
+        handles.delete(handle);
+      };
     });
-  });
-  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");
+  if (fault === "no-overlay-markers") {
+    await page.addInitScript(() => {
+      new MutationObserver(() => {
+        for (const node of document.querySelectorAll(
+          "[data-zappie-overlay-trigger], [data-zappie-overlay]"
+        )) {
+          node.removeAttribute("data-zappie-overlay-trigger");
+          node.removeAttribute("data-zappie-overlay");
+        }
+      }).observe(document, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        attributeFilter: ["data-zappie-overlay-trigger", "data-zappie-overlay"]
+      });
+    });
   }
-  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 } : {}
+  if (fault === "quick-add-via-item") {
+    await page.addInitScript(() => {
+      const removeQuickAdds = () => {
+        if (location.pathname !== "/") {
+          return;
+        }
+        for (const node of document.querySelectorAll(
+          '[data-zappie-item] [data-zappie-action="add-to-cart"]'
+        )) {
+          node.remove();
+        }
       };
-    }),
-    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;
+      new MutationObserver(removeQuickAdds).observe(document, {
+        childList: true,
+        subtree: true
+      });
+    });
   }
-  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].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;
-    }
+  if (fault === "no-sold-out") {
+    await page.addInitScript(() => {
+      let debug;
+      Object.defineProperty(window, "__zappie", {
+        configurable: true,
+        get: () => debug,
+        set(value) {
+          debug = value;
+          if (value) {
+            const catalogue = value.catalogue;
+            value.catalogue = async () => {
+              const result = await catalogue();
+              return {
+                ...result,
+                menu: {
+                  ...result.menu,
+                  items: Object.fromEntries(
+                    Object.entries(result.menu.items).filter(
+                      ([, item]) => item.isAvailable
+                    )
+                  )
+                }
+              };
+            };
+          }
+        }
+      });
+    });
   }
-  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);
+  if (fault === "add-stuck") {
+    await page.addInitScript(() => {
+      document.addEventListener(
+        "click",
+        (event) => {
+          const target2 = event.target;
+          if (target2?.closest('[data-zappie-action="add-to-cart"]')) {
+            event.stopImmediatePropagation();
+            event.preventDefault();
           }
-          return value;
         },
-        () => memory.get(key) ?? null
-      );
-    },
-    write(key, value) {
-      memory.set(key, value);
-      access(
-        (s) => s.setItem(key, value),
-        () => {
-        }
+        true
       );
-    },
-    remove(key) {
-      memory.delete(key);
-      access(
-        (s) => s.removeItem(key),
-        () => {
+    });
+  }
+  if (fault === "missing-issue-fix") {
+    await page.addInitScript(() => {
+      new MutationObserver(() => {
+        for (const node of document.querySelectorAll(
+          "[data-zappie-issue-fix]"
+        )) {
+          node.removeAttribute("data-zappie-issue-fix");
         }
-      );
-    },
-    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" ? {
-      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-6XJJHITL.js").then(
-    ({ createQuoteClient }) => quotes = createQuoteClient(deps.transport, deps.context),
-    (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 schedule = () => {
-    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();
-    schedule();
-  };
-  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();
-    schedule();
-  };
-  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();
-        schedule();
-      }
-    }
-  });
-  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 target2 = value.branches.find(
-          (b) => b.id === selected || b.slug === selected
-        ) ?? (!selected ? value.branches.find((b) => b.isDefault) ?? value.branches[0] : void 0);
-        if (!target2) {
-          throw new ZappieError(
-            "branch_not_found",
-            "Cart branch is unavailable"
-          );
-        }
-        let inputs = snapshot.lines;
-        if (!snapshot.isHydrated) {
-          const raw = readSaved(target2.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(
-          target2.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);
-              schedule();
-              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);
-                schedule();
-              }
-            }).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;
-        }
-        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(signal2) {
-  return signal2?.reason ?? new DOMException("The request was aborted", "AbortError");
-}
-function throwIfAborted(signal2) {
-  if (signal2?.aborted) {
-    throw abortReason(signal2);
-  }
-}
-function delay(ms, signal2) {
-  return new Promise((resolve, reject) => {
-    throwIfAborted(signal2);
-    const abort = () => {
-      clearTimeout(timer);
-      reject(abortReason(signal2));
-    };
-    const timer = setTimeout(() => {
-      signal2?.removeEventListener("abort", abort);
-      resolve();
-    }, ms);
-    signal2?.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, signal2) {
-    throwIfAborted(signal2);
-    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;
-        signal2?.removeEventListener("abort", abort);
-        current.users--;
-        callback();
-      };
-      const abort = () => {
-        finish(() => reject(abortReason(signal2)));
-        if (current.users === 0 && !current.keepAlive) {
-          current.controller.abort(abortReason(signal2));
-          if (this.flights.get(key) === current) {
-            this.flights.delete(key);
+      }).observe(document, { childList: true, subtree: true });
+    });
+  }
+  if (fault === "wrong-total") {
+    await page.addInitScript(() => {
+      new MutationObserver(() => {
+        for (const node of document.querySelectorAll("[data-zappie-total]")) {
+          if (node.textContent !== "Total \u20A61") {
+            node.textContent = "Total \u20A61";
           }
         }
-      };
-      signal2?.addEventListener("abort", abort, { once: true });
-      current.promise.then(
-        (value) => finish(() => resolve(value)),
-        (error) => finish(() => reject(error))
-      );
-      if (signal2?.aborted) {
-        abort();
-      }
+      }).observe(document, { childList: true, subtree: true });
     });
   }
-};
-
-// ../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/transport/rest.ts
-var MAX_RETRY_WAIT_MS = 5e3;
-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(path4, 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 + path4, {
-          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) {
-    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-KIO5RCZO.js").catch((cause) => {
-      throw new ZappieError(
-        "server_error",
-        "Could not load the storefront store mapper",
-        { cause }
-      );
-    });
-    const response = this.request("/store", ctx).then(
-      (value) => this.json(value)
-    );
-    const [{ mapStore }, raw] = await Promise.all([mapper, response]);
-    return mapStore(
-      raw,
-      record,
-      text,
-      list,
-      hours,
-      mapMoney,
-      money,
-      opt,
-      isString,
-      isBoolean
-    );
-  }
-  async getMenu(ctx) {
-    let cursor;
-    const seen = /* @__PURE__ */ new Set();
-    let output;
-    let etag;
-    do {
-      const query = new URLSearchParams({
-        branch: ctx.branchId,
-        ...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 = mapMenu(raw, ctx.branchId);
-      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-3GCAICBQ.js")).selectedMenu(
-      ctx,
-      (path4) => this.request(path4, ctx, ctx.ifNoneMatch),
-      (response) => this.json(response),
-      mapMenu,
-      () => new ZappieError("server_error", "Invalid selected menu")
-    );
-  }
-  async search(ctx) {
-    return (await import("./search-YIHT6CXN.js")).searchPage(
-      ctx,
-      async (path4) => this.json(await this.request(path4, 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-UBHOB5IN.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
-        )
-      )
-    );
-    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 = (signal2) => ({
-    key: config.key,
-    version: config.version,
-    ...signal2 ? { signal: signal2 } : {}
-  });
-  const store = {
-    get: (opts = {}) => cache.get(
-      "store",
-      async (signal2) => ({ value: await transport.getStore(ctx(signal2)) }),
-      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(
-        `menu:${branch.id}${opts.metadataOnly ? ":partial" : ""}`,
-        async (signal2, entry) => {
-          const response = await transport.getMenu({
-            ...ctx(signal2),
-            branchId: branch.id,
-            ...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
-      });
-    },
-    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
-        });
+async function applyPageFault(page, fault) {
+  if (fault === "quick-add-via-item") {
+    await page.locator('[data-zappie-item] [data-zappie-action="add-to-cart"]').evaluateAll((nodes) => {
+      for (const node of nodes) {
+        node.remove();
       }
-    }
-  };
-  const itemValues = /* @__PURE__ */ new Map();
-  const peekItem = (id, branch) => itemValues.get(`${branch}:${id}`);
-  const readItem = async (id, branch, fresh = false, signal2) => {
-    const complete = cache.snapshot(`menu:${branch}`).value;
-    if (!fresh && complete && Object.hasOwn(complete.items, id)) {
-      return complete.items[id];
-    }
-    const load = (requestSignal = signal2) => 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) }),
-        signal2
-      );
-      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-C3UDGUED.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 };
-}
-
-// src/fixtures.ts
-async function installFault(page, fault) {
-  if (!fault) {
-    return;
   }
-  if (fault === "no-sold-out") {
-    await page.addInitScript(() => {
-      let debug;
-      Object.defineProperty(window, "__zappie", {
-        configurable: true,
-        get: () => debug,
-        set(value) {
-          debug = value;
-          if (value) {
-            const catalogue = value.catalogue;
-            value.catalogue = async () => {
-              const result = await catalogue();
-              return {
-                ...result,
-                menu: {
-                  ...result.menu,
-                  items: Object.fromEntries(
-                    Object.entries(result.menu.items).filter(
-                      ([, item]) => item.isAvailable
-                    )
-                  )
-                }
-              };
-            };
-          }
-        }
-      });
-    });
-  }
-  if (fault === "add-stuck") {
-    await page.addInitScript(() => {
-      document.addEventListener(
-        "click",
-        (event) => {
-          const target2 = event.target;
-          if (target2?.closest('[data-zappie-action="add-to-cart"]')) {
-            event.stopImmediatePropagation();
-            event.preventDefault();
-          }
-        },
-        true
-      );
-    });
-  }
-  if (fault === "missing-issue-fix") {
-    await page.addInitScript(() => {
-      new MutationObserver(() => {
-        for (const node of document.querySelectorAll(
-          "[data-zappie-issue-fix]"
-        )) {
-          node.removeAttribute("data-zappie-issue-fix");
-        }
-      }).observe(document, { childList: true, subtree: true });
-    });
-  }
-  if (fault === "wrong-total") {
-    await page.addInitScript(() => {
-      new MutationObserver(() => {
-        for (const node of document.querySelectorAll("[data-zappie-total]")) {
-          if (node.textContent !== "Total \u20A61") {
-            node.textContent = "Total \u20A61";
-          }
-        }
-      }).observe(document, { childList: true, subtree: true });
-    });
-  }
-}
-async function applyPageFault(page, fault) {
   if (fault === "missing-marker") {
     await page.locator("[data-zappie-item]").evaluateAll((nodes) => {
       for (const node of nodes) {
@@ -2704,8 +715,8 @@ function menuCoverage(items, shownIds) {
     passes: available.length === 0 || shown / available.length >= 0.95
   };
 }
-function priceMatches(text2, formatted) {
-  return text2?.includes(formatted) ?? false;
+function priceMatches(text, formatted) {
+  return text?.includes(formatted) ?? false;
 }
 
 // src/checks/v03-menu.ts
@@ -2754,9 +765,9 @@ var v03 = {
       }
     }
     for (const item of available.slice(0, 2)) {
-      const text2 = await page.locator(`[data-zappie-item="${item.id}"]`).first().textContent();
+      const text = await page.locator(`[data-zappie-item="${item.id}"]`).first().textContent();
       assertion(
-        priceMatches(text2, format.money(item.price)),
+        priceMatches(text, format.money(item.price)),
         "price_mismatch",
         `${item.name} does not show ${format.money(item.price)}`,
         "Render prices with format.money from @zappie/sdk."
@@ -2775,6 +786,14 @@ var v04 = {
     await open(page);
     await applyPageFault(page, fault);
     const before = await debugValue(page, () => window.__zappie.cart().count);
+    await page.evaluate(() => {
+      window.__zappieV04Events = [];
+      window.addEventListener("zappie:event", (event2) => {
+        window.__zappieV04Events.push(
+          event2.detail
+        );
+      });
+    });
     const item = simpleItem(await readMenu(options));
     assertion(
       item,
@@ -2782,15 +801,43 @@ var v04 = {
       "The test menu has no available item without required options",
       "Keep one available item without required options in the test menu."
     );
-    const simple = page.locator(`[data-zappie-item="${item.id}"]`).locator('[data-zappie-action="add-to-cart"]');
-    assertion(
-      await simple.count(),
-      "simple_item_missing",
-      "The item has no quick-add button",
-      "Render an available item without required options and mark its add button."
-    );
+    let openedItem = false;
+    let simple = page.locator(`[data-zappie-item="${item.id}"]`).locator('[data-zappie-action="add-to-cart"]');
+    if (!await simple.count()) {
+      const itemLink = page.locator(
+        `[data-zappie-item="${item.id}"] a[href*="/item/"], a[data-zappie-item="${item.id}"], a[href*="/item/${item.id}"]`
+      ).first();
+      assertion(
+        await itemLink.count(),
+        "simple_item_missing",
+        "The item has no quick-add button or item link",
+        "Render a marked quick-add button, or link the product card to an item page with one."
+      );
+      await itemLink.click();
+      openedItem = true;
+      simple = page.locator(
+        '[role="dialog"] [data-zappie-item] [data-zappie-action="add-to-cart"]:visible, main [data-zappie-item] [data-zappie-action="add-to-cart"]:visible'
+      ).first();
+      await simple.waitFor({ state: "visible", timeout: 5e3 }).catch(() => {
+      });
+      assertion(
+        await simple.count(),
+        "simple_item_missing",
+        "The item page has no add button",
+        'Mark the item page add button with data-zappie-action="add-to-cart".'
+      );
+    }
     await simple.click();
-    const updated = await page.evaluate(
+    const updated = openedItem ? await page.waitForFunction(
+      () => window.__zappieV04Events.some(
+        (entry) => entry.name === "add_to_cart"
+      ),
+      void 0,
+      { timeout: 3e3 }
+    ).then(
+      () => true,
+      () => false
+    ) : await page.evaluate(
       (count) => new Promise((resolve) => {
         requestAnimationFrame(() => {
           resolve(window.__zappie.cart().count > count);
@@ -2801,12 +848,11 @@ var v04 = {
     assertion(
       updated,
       "cart_not_updated",
-      "The cart count did not change within one frame of Add",
-      "Connect the marked Add control to client.cart.add and update its count immediately."
+      openedItem ? "The item page did not add the item to the cart" : "The cart count did not change within one frame of Add",
+      "Connect the marked Add control to client.cart.add and update the cart immediately."
     );
-    const event = await debugValue(
-      page,
-      () => window.__zappie.events.some((entry) => entry.name === "add_to_cart")
+    const event = await page.evaluate(
+      () => window.__zappieV04Events.some((entry) => entry.name === "add_to_cart")
     );
     assertion(
       event,
@@ -3058,18 +1104,18 @@ var v07 = {
     await page.locator("[data-zappie-cart-trigger]").first().click();
     const codes = unavailable ? ["price_changed", "item_unavailable"] : ["price_changed"];
     for (const code of codes) {
-      const issue2 = page.locator(`[data-zappie-issue="${code}"]`).first();
-      await issue2.waitFor({ state: "visible" });
+      const issue = page.locator(`[data-zappie-issue="${code}"]`).first();
+      await issue.waitFor({ state: "visible" });
       assertion(
-        await issue2.isVisible(),
+        await issue.isVisible(),
         "quote_issue_missing",
         `The cart does not show ${code}`,
         "Render each quote issue with data-zappie-issue and its fixes with data-zappie-issue-fix."
       );
     }
     for (const code of codes) {
-      const issue2 = page.locator(`[data-zappie-issue="${code}"]`).first();
-      const fix = issue2.locator("[data-zappie-issue-fix]").first();
+      const issue = page.locator(`[data-zappie-issue="${code}"]`).first();
+      const fix = issue.locator("[data-zappie-issue-fix]").first();
       assertion(
         await fix.count(),
         "quote_fix_missing",
@@ -3077,7 +1123,7 @@ var v07 = {
         "Connect each marked issue fix to the SDK cart applyFix action."
       );
       await fix.click();
-      await issue2.waitFor({ state: "hidden" });
+      await issue.waitFor({ state: "hidden" });
     }
     await open(page, "/checkout");
     await page.waitForFunction(() => {
@@ -3142,73 +1188,6 @@ var v09 = {
   }
 };
 
-// ../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, signal2) {
-  signal2?.throwIfAborted();
-  return new Promise((resolve, reject) => {
-    const done = () => {
-      signal2?.removeEventListener("abort", aborted2);
-      resolve();
-    };
-    const timer = setTimeout(done, ms);
-    const aborted2 = () => {
-      clearTimeout(timer);
-      signal2?.removeEventListener("abort", aborted2);
-      reject(signal2?.reason ?? new DOMException("Aborted", "AbortError"));
-    };
-    signal2?.addEventListener("abort", aborted2, { 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 });
-}
-
 // ../sdk/src/places/error.ts
 var PlacesError = class extends ZappieError {
   constructor(status, apiCode, message, param, issues) {
@@ -3499,6 +1478,115 @@ var v10 = {
 
 // src/checks/v13-accessibility.ts
 import AxeBuilder from "@axe-core/playwright";
+
+// src/checks/semantics.ts
+var TOUCH_TARGET_PX = 44;
+async function semanticFindings(page, scope) {
+  return page.evaluate(
+    ({ scope: scope2, minimum }) => {
+      const findings = [];
+      const rendered = (element) => element.checkVisibility() && !element.closest('[aria-hidden="true"]');
+      const describe = (element) => {
+        const id = element.id ? `#${element.id}` : "";
+        const text = (element.textContent ?? "").trim().replace(/\s+/g, " ");
+        return `<${element.tagName.toLowerCase()}${id}>${text ? ` "${text.slice(0, 40)}"` : ""}`;
+      };
+      if (scope2.page) {
+        const main = [
+          ...document.querySelectorAll('main, [role="main"]')
+        ].filter(rendered);
+        if (main.length === 0) {
+          findings.push({
+            code: "main_landmark_missing",
+            message: "The page has no main landmark"
+          });
+        }
+        const headings = [
+          ...document.querySelectorAll('h1, [role="heading"][aria-level="1"]')
+        ].filter(
+          (element) => rendered(element) && !element.closest('[role="dialog"], dialog')
+        );
+        if (headings.length !== 1) {
+          findings.push({
+            code: "h1_count",
+            message: `The page has ${headings.length} h1 headings${headings.length > 1 ? `: ${headings.map(describe).join(", ")}` : ""}`
+          });
+        }
+      }
+      const named = (element) => {
+        const label2 = element.getAttribute("aria-label")?.trim();
+        if (label2) {
+          return true;
+        }
+        const ids = element.getAttribute("aria-labelledby")?.split(/\s+/) ?? [];
+        return ids.some(
+          (id) => Boolean(document.getElementById(id)?.textContent?.trim())
+        );
+      };
+      for (const dialog of document.querySelectorAll(
+        '[role="dialog"], [role="alertdialog"], dialog[open]'
+      )) {
+        if (rendered(dialog) && !named(dialog)) {
+          findings.push({
+            code: "dialog_name_missing",
+            message: `${describe(dialog)} has no accessible name`
+          });
+        }
+      }
+      for (const element of document.querySelectorAll("[tabindex]")) {
+        if (Number(element.getAttribute("tabindex")) > 0) {
+          findings.push({
+            code: "positive_tabindex",
+            message: `${describe(element)} has tabindex="${element.getAttribute("tabindex")}"`
+          });
+        }
+      }
+      if (scope2.phone) {
+        const controls = document.querySelectorAll(
+          'button, a[href], input:not([type="hidden"]), select, textarea, summary, [role="button"], [role="link"], [role="tab"], [role="checkbox"], [role="radio"], [role="switch"], [role="menuitem"], [role="option"]'
+        );
+        const small = [];
+        for (const element of controls) {
+          if (!rendered(element) || element.matches(":disabled") || // Inline text links sit in a line of text; WCAG exempts them.
+          element.matches("a") && getComputedStyle(element).display === "inline") {
+            continue;
+          }
+          const box = element.getBoundingClientRect();
+          const label2 = element.closest("label")?.getBoundingClientRect();
+          if (box.width <= 2 || box.height <= 2) {
+            if (!label2) {
+              continue;
+            }
+          }
+          const width = Math.max(box.width, label2?.width ?? 0);
+          const height = Math.max(box.height, label2?.height ?? 0);
+          if (width + 0.5 < minimum || height + 0.5 < minimum) {
+            small.push(
+              `${describe(element)} ${Math.round(width)}\xD7${Math.round(height)} px`
+            );
+          }
+        }
+        if (small.length > 0) {
+          findings.push({
+            code: "touch_target_too_small",
+            message: `Controls under ${minimum}\xD7${minimum} px on a phone: ${small.slice(0, 8).join(", ")}${small.length > 8 ? ` and ${small.length - 8} more` : ""}`
+          });
+        }
+      }
+      return findings;
+    },
+    { scope, minimum: TOUCH_TARGET_PX }
+  );
+}
+var semanticHints = {
+  main_landmark_missing: "Wrap the page's main content in a <main> element.",
+  h1_count: "Give each page exactly one h1 that names it.",
+  dialog_name_missing: "Name every dialog with aria-labelledby pointing at its title, or with aria-label.",
+  positive_tabindex: "Remove positive tabindex values. Use the DOM order, or tabindex 0 and -1.",
+  touch_target_too_small: "Make every menu control at least 44\xD744 px on a phone, with padding or a larger hit area."
+};
+
+// src/checks/v13-accessibility.ts
 async function severeViolations(page) {
   const analysis = await new AxeBuilder({ page }).analyze();
   return analysis.violations.filter(
@@ -3523,6 +1611,16 @@ async function controlsAreReachable(page, selectors) {
   }
   return false;
 }
+async function holdsFocus(target2) {
+  for (let attempt = 0; attempt < 20; attempt++) {
+    const inside = await target2.evaluate((node) => node.contains(document.activeElement)).catch(() => false);
+    if (inside) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  return false;
+}
 var v13 = {
   id: "V13",
   title: "Accessibility",
@@ -3532,6 +1630,10 @@ var v13 = {
     await open(page);
     await applyPageFault(page, fault);
     const violations = await severeViolations(page);
+    const semantics = await semanticFindings(page, {
+      page: true,
+      phone: viewport.width < 768
+    });
     const item = sortedItems(await readMenu(options)).find(
       (entry) => entry.isAvailable
     );
@@ -3541,11 +1643,25 @@ var v13 = {
       "No available item can be opened for accessibility checks",
       "Keep one available item in the test menu."
     );
-    await page.locator(`[data-zappie-item="${item.id}"]`).first().locator("xpath=..").getByRole("link", { name: "View details" }).click();
+    const card = page.locator(`[data-zappie-item="${item.id}"]`).first().locator("xpath=..");
+    await card.getByRole("link", { name: "View details" }).click();
     violations.push(...await severeViolations(page));
+    semantics.push(
+      ...await semanticFindings(page, { page: false, phone: false })
+    );
     await page.getByRole("button", { name: "Close item" }).click();
-    await page.locator("[data-zappie-cart-trigger]").first().click();
+    if (!await holdsFocus(card)) {
+      semantics.push({
+        code: "focus_not_returned",
+        message: "Focus did not return to the item card after the item closed"
+      });
+    }
+    const cartTrigger = page.locator("[data-zappie-cart-trigger]").first();
+    await cartTrigger.click();
     violations.push(...await severeViolations(page));
+    semantics.push(
+      ...await semanticFindings(page, { page: false, phone: false })
+    );
     const message = violations.flatMap(
       (entry) => entry.nodes.map((node) => `${entry.id}: ${node.target.join(" ")}`)
     ).join(", ");
@@ -3556,6 +1672,25 @@ var v13 = {
       "Fix every serious or critical axe violation in the menu, item dialog, cart and order page."
     );
     await page.keyboard.press("Escape");
+    if (!await holdsFocus(cartTrigger)) {
+      semantics.push({
+        code: "focus_not_returned",
+        message: "Focus did not return to the cart control after the cart closed"
+      });
+    }
+    const [semantic] = semantics;
+    assertion(
+      !semantic,
+      semantic?.code ?? "semantics",
+      semantics.map(({ message: message2 }) => message2).join(". "),
+      [
+        ...new Set(
+          semantics.map(
+            ({ code }) => semanticHints[code] ?? "Return focus to the control that opened an overlay when it closes."
+          )
+        )
+      ].join(" ")
+    );
     await context.addCookies([
       {
         name: "zappie_session",
@@ -3601,30 +1736,20 @@ var v14 = {
   id: "V14",
   title: "Performance budget",
   viewports: "mobile",
-  async run({ page, metrics, fault }, viewport) {
+  async run({ page, metrics, fault, cpuThrottlingRate: cpuThrottlingRate2 }, viewport) {
     await page.setViewportSize(viewport);
-    const cdp = await page.context().newCDPSession(page);
-    await cdp.send("Network.enable");
-    await cdp.send("Network.setCacheDisabled", { cacheDisabled: true });
-    await cdp.send("Network.emulateNetworkConditions", {
-      offline: false,
-      latency: 150,
-      downloadThroughput: 2e5,
-      uploadThroughput: 1e5,
-      connectionType: "cellular3g"
-    });
-    await cdp.send("Emulation.setCPUThrottlingRate", { rate: 4 });
+    const cdp = await applyPhoneProfile(page, cpuThrottlingRate2);
     await page.addInitScript(() => {
       const state = { lcp: 0, cls: 0 };
       Object.assign(window, { __zappiePerformance: state });
-      new PerformanceObserver((list2) => {
+      new PerformanceObserver((list) => {
         state.lcp = Math.max(
           state.lcp,
-          ...list2.getEntries().map((entry) => entry.startTime)
+          ...list.getEntries().map((entry) => entry.startTime)
         );
       }).observe({ type: "largest-contentful-paint", buffered: true });
-      new PerformanceObserver((list2) => {
-        state.cls += list2.getEntries().filter(
+      new PerformanceObserver((list) => {
+        state.cls += list.getEntries().filter(
           (entry) => !entry.hadRecentInput
         ).reduce(
           (sum, entry) => sum + (entry.value ?? 0),
@@ -3641,24 +1766,27 @@ var v14 = {
     await page.waitForTimeout(500);
     const values = await page.evaluate(async () => {
       const observed = window.__zappiePerformance ?? { lcp: 0, cls: 0 };
-      const scripts = performance.getEntriesByType("resource").filter((entry) => entry.name.endsWith(".js"));
-      const sizes = await Promise.all(
-        scripts.map(async (entry) => {
-          if (typeof CompressionStream === "undefined") {
-            const timing = entry;
-            return timing.encodedBodySize || timing.transferSize;
-          }
-          const response = await fetch(entry.name);
-          const compressed = response.body?.pipeThrough(
-            new CompressionStream("gzip")
-          );
-          return compressed ? (await new Response(compressed).arrayBuffer()).byteLength : 0;
-        })
-      );
-      const js = sizes.reduce((sum, size) => sum + size, 0);
-      return { ...observed, js };
+      const resources = performance.getEntriesByType("resource");
+      const gzipped = async (entry) => {
+        if (typeof CompressionStream === "undefined") {
+          const timing = entry;
+          return timing.encodedBodySize || timing.transferSize;
+        }
+        const response = await fetch(entry.name);
+        const compressed = response.body?.pipeThrough(
+          new CompressionStream("gzip")
+        );
+        return compressed ? (await new Response(compressed).arrayBuffer()).byteLength : 0;
+      };
+      const total = async (extension) => (await Promise.all(
+        resources.filter(
+          (entry) => new URL(entry.name).pathname.endsWith(extension)
+        ).map(gzipped)
+      )).reduce((sum, size) => sum + size, 0);
+      return { ...observed, js: await total(".js"), css: await total(".css") };
     });
     metrics.menuJsKbGz = Math.round(values.js / 1024 * 10) / 10;
+    metrics.menuCssKbGz = Math.round(values.css / 1024 * 10) / 10;
     metrics.lcpMs = Math.round(values.lcp);
     metrics.cls = Math.round(values.cls * 1e3) / 1e3;
     assertion(
@@ -3683,6 +1811,496 @@ var v14 = {
   }
 };
 
+// src/checks/v15-tappable-product-cards.ts
+var TAPPABLE_BUDGET_MS = 3e3;
+var OPEN_BUDGET_MS = 300;
+var v15 = {
+  id: "V15",
+  title: "Tappable product cards",
+  viewports: "mobile",
+  async run({ page, metrics, cpuThrottlingRate: cpuThrottlingRate2 }, viewport) {
+    await page.setViewportSize(viewport);
+    const cdp = await applyPhoneProfile(page, cpuThrottlingRate2);
+    try {
+      await page.goto("/", { waitUntil: "domcontentloaded" });
+      await cdp.send("Network.setCacheDisabled", { cacheDisabled: false });
+      const link = page.locator('a[href*="/item/"]').first();
+      await link.waitFor();
+      const href = await link.getAttribute("href");
+      assertion(
+        href !== null,
+        "product_card_link_missing",
+        "The first product card has no destination",
+        "Link the product card to its item page."
+      );
+      const itemPath = new URL(href, page.url()).pathname;
+      await page.waitForFunction(() => "__reactRouterManifest" in window, null, {
+        timeout: 8e3
+      }).catch(() => void 0);
+      const itemModule = await page.evaluate(itemRouteModule, itemPath);
+      const prefetched = page.waitForResponse(
+        (response) => {
+          const path4 = new URL(response.url()).pathname;
+          if (path4 === itemModule) {
+            return true;
+          }
+          return path4 === `${itemPath}.data` && response.request().headers()["sec-purpose"] === "prefetch";
+        },
+        { timeout: 8e3 }
+      ).then(async (response) => {
+        await response.finished();
+        return true;
+      }).catch(() => false);
+      await link.evaluate(
+        (node) => node.scrollIntoView({ block: "center", inline: "nearest" })
+      );
+      await page.waitForFunction(() => {
+        const candidate = document.querySelector('a[href*="/item/"]');
+        return candidate !== null && Object.keys(candidate).some(
+          (key) => key.startsWith("__reactProps$") || key.startsWith("__reactFiber$")
+        );
+      });
+      const tappableMs = await page.evaluate(() => performance.now());
+      metrics.productCardTappableMs = Math.round(tappableMs);
+      assertion(
+        tappableMs <= TAPPABLE_BUDGET_MS,
+        "product_card_tappable_too_late",
+        `The first product card became tappable in ${Math.round(tappableMs)} ms`,
+        "Reduce critical scripts, fonts and high-priority images until product cards become tappable within 3 seconds."
+      );
+      assertion(
+        await prefetched,
+        "product_card_prefetch_missing",
+        "The first product card did not prefetch its item page",
+        'Prefetch item links with prefetch="viewport".'
+      );
+      await page.waitForLoadState("networkidle");
+      await page.evaluate(() => {
+        document.addEventListener(
+          "click",
+          (event) => {
+            const target2 = event.target;
+            if (target2?.closest('a[href*="/item/"]')) {
+              window.__zappieTapAt = performance.now();
+            }
+          },
+          { capture: true, once: true }
+        );
+      });
+      await link.click({ noWaitAfter: true });
+      await Promise.race([
+        page.waitForURL((url) => /\/item\//.test(url.pathname)),
+        page.locator('[role="dialog"] [data-zappie-item]').waitFor({ state: "visible" })
+      ]);
+      const openMs = await page.evaluate(
+        () => performance.now() - (window.__zappieTapAt ?? 0)
+      );
+      metrics.productCardOpenMs = Math.round(openMs);
+      assertion(
+        openMs <= OPEN_BUDGET_MS,
+        "product_card_open_too_slow",
+        `The first product card opened in ${Math.round(openMs)} ms`,
+        'Set routeDiscovery to initial and prefetch item links with prefetch="viewport" so the item surface opens within 300 ms.'
+      );
+    } finally {
+      await cdp.detach();
+    }
+  }
+};
+function itemRouteModule(itemPath) {
+  const manifest = window.__reactRouterManifest;
+  if (!manifest) {
+    return void 0;
+  }
+  const segments = (path4) => path4.split("/").filter(Boolean);
+  const fullPath = (route2) => {
+    const parts = [];
+    for (let current = route2; current; current = current.parentId ? manifest.routes[current.parentId] : void 0) {
+      if (current.path) {
+        parts.unshift(current.path);
+      }
+    }
+    return segments(parts.join("/"));
+  };
+  const wanted = segments(itemPath);
+  const route = Object.values(manifest.routes).find((entry) => {
+    if (!entry.path) {
+      return false;
+    }
+    const pattern = fullPath(entry);
+    return pattern.length === wanted.length && pattern.every(
+      (part, index) => part.startsWith(":") || part === wanted[index]
+    );
+  });
+  return route ? new URL(route.module, location.href).pathname : void 0;
+}
+
+// src/checks/overlays.ts
+var OVERLAY_NAMES = ["bag", "branch", "search", "item"];
+var IDLE_FALLBACK_MS = 2e3;
+var NETWORK_QUIET_MS = 500;
+var SETTLE_ROUNDS = 3;
+var SETTLE_TIMEOUT_MS = 15e3;
+var triggerSelector = (name) => `[data-zappie-overlay-trigger="${name}"]`;
+var overlaySelector = (name) => `[data-zappie-overlay="${name}"]`;
+var markersHint = 'Add data-zappie-overlay-trigger="bag", "branch", "search" or "item" to each control that opens that overlay, and data-zappie-overlay with the same name on its role="dialog" element. Until the menu has them, this check is skipped.';
+async function overlayTriggers(page) {
+  const found = [];
+  for (const name of OVERLAY_NAMES) {
+    const trigger = page.locator(`${triggerSelector(name)}:visible`).first();
+    if (await trigger.count() > 0) {
+      found.push({ name, trigger });
+    }
+  }
+  return found;
+}
+function skipWithoutTriggers(found) {
+  if (found.length === 0) {
+    skipCheck(
+      "overlay_markers_missing",
+      "The menu has no data-zappie-overlay-trigger controls",
+      markersHint
+    );
+  }
+}
+function armOverlayTimer(page, name, timeoutMs) {
+  return page.evaluate(
+    ({ selector, timeout }) => {
+      const state = {};
+      Object.assign(window, { __zappieOverlayTimer: state });
+      const visible = () => {
+        const node = document.querySelector(selector);
+        if (!(node instanceof HTMLElement)) {
+          return false;
+        }
+        const box = node.getBoundingClientRect();
+        return box.width > 0 && box.height > 0 && node.checkVisibility();
+      };
+      document.addEventListener(
+        "click",
+        (event) => {
+          const started = event.timeStamp;
+          const frame = () => {
+            if (visible()) {
+              requestAnimationFrame(() => {
+                state.ms = performance.now() - started;
+              });
+              return;
+            }
+            if (performance.now() - started > timeout) {
+              state.ms = -1;
+              return;
+            }
+            requestAnimationFrame(frame);
+          };
+          requestAnimationFrame(frame);
+        },
+        { capture: true, once: true }
+      );
+    },
+    { selector: overlaySelector(name), timeout: timeoutMs }
+  );
+}
+async function readOverlayTimer(page) {
+  const handle = await page.waitForFunction(
+    () => window.__zappieOverlayTimer?.ms
+  );
+  const ms = await handle.jsonValue();
+  return ms < 0 ? void 0 : ms;
+}
+async function overlayIsOpen(page, name) {
+  return page.locator(`${overlaySelector(name)}:visible`).first().isVisible().catch(() => false);
+}
+function watchNetwork(page) {
+  const inflight = /* @__PURE__ */ new Set();
+  const activity = { at: Date.now(), requests: 0 };
+  const started = (request) => {
+    inflight.add(request);
+    activity.at = Date.now();
+    activity.requests++;
+  };
+  const ended = (request) => {
+    inflight.delete(request);
+    activity.at = Date.now();
+  };
+  page.on("request", started);
+  page.on("requestfinished", ended);
+  page.on("requestfailed", ended);
+  return {
+    get requests() {
+      return activity.requests;
+    },
+    /** Resolves once no request has been in flight for 500 ms, or at the deadline. */
+    async quiet(deadline) {
+      for (; ; ) {
+        const now = Date.now();
+        if (now >= deadline) {
+          return;
+        }
+        if (inflight.size === 0 && now - activity.at >= NETWORK_QUIET_MS) {
+          return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 50));
+      }
+    },
+    /** Starts the quiet window again from now. */
+    restart() {
+      activity.at = Date.now();
+    },
+    stop() {
+      page.off("request", started);
+      page.off("requestfinished", ended);
+      page.off("requestfailed", ended);
+    }
+  };
+}
+function hydrated() {
+  const nodes = [
+    document.querySelector("[data-zappie-item]"),
+    ...document.querySelectorAll("[data-zappie-overlay-trigger]")
+  ];
+  return nodes.every(
+    (node) => node !== null && Object.keys(node).some(
+      (key) => key.startsWith("__reactProps$") || key.startsWith("__reactFiber$")
+    )
+  );
+}
+async function openSettledMenu(page) {
+  const network = watchNetwork(page);
+  try {
+    await page.goto("/", { waitUntil: "domcontentloaded" });
+    await page.locator("[data-zappie-item]").first().waitFor();
+    const deadline = Date.now() + SETTLE_TIMEOUT_MS;
+    const remaining = () => Math.max(deadline - Date.now(), 1);
+    await page.waitForFunction(hydrated, null, { timeout: remaining() }).catch(() => void 0);
+    await page.waitForLoadState("load", { timeout: remaining() }).catch(() => void 0);
+    network.restart();
+    await network.quiet(deadline);
+    for (let round = 0; round < SETTLE_ROUNDS; round++) {
+      const before = network.requests;
+      await page.evaluate(
+        ({ fallback, remaining: remaining2 }) => new Promise((resolve) => {
+          window.setTimeout(resolve, remaining2);
+          const idle = (then) => {
+            if (typeof window.requestIdleCallback === "function") {
+              window.requestIdleCallback(() => then());
+            } else {
+              window.setTimeout(then, fallback);
+            }
+          };
+          idle(() => idle(resolve));
+        }),
+        { fallback: IDLE_FALLBACK_MS, remaining: remaining() }
+      );
+      await network.quiet(deadline);
+      if (network.requests === before || Date.now() >= deadline) {
+        return;
+      }
+    }
+  } finally {
+    network.stop();
+  }
+}
+
+// src/checks/v16-overlays-open-quickly.ts
+var OVERLAY_OPEN_BUDGET_MS = 100;
+var OVERLAY_OPEN_SAMPLES = 3;
+var OPEN_TIMEOUT_MS = 5e3;
+var median = (values) => {
+  const sorted = [...values].sort((a, b) => a - b);
+  return sorted[Math.floor(sorted.length / 2)];
+};
+var v16 = {
+  id: "V16",
+  title: "Overlays open quickly",
+  viewports: "mobile",
+  async run({ page, metrics, cpuThrottlingRate: cpuThrottlingRate2 }, viewport) {
+    await page.setViewportSize(viewport);
+    const cdp = await applyPhoneProfile(page, cpuThrottlingRate2);
+    try {
+      await openSettledMenu(page);
+      const names = (await overlayTriggers(page)).map(({ name }) => name);
+      skipWithoutTriggers(names);
+      await cdp.send("Network.setCacheDisabled", { cacheDisabled: false });
+      const timings = {};
+      const samples = {};
+      const unopened = [];
+      for (const name of names) {
+        const opens = [];
+        for (let sample = 0; sample < OVERLAY_OPEN_SAMPLES; sample++) {
+          await openSettledMenu(page);
+          const trigger = page.locator(`${triggerSelector(name)}:visible`).first();
+          await trigger.evaluate(
+            (node) => node.scrollIntoView({ block: "center", inline: "nearest" })
+          );
+          await armOverlayTimer(page, name, OPEN_TIMEOUT_MS);
+          await trigger.click({ noWaitAfter: true });
+          const ms = await readOverlayTimer(page);
+          if (ms === void 0) {
+            break;
+          }
+          opens.push(Math.round(ms));
+        }
+        if (opens.length < OVERLAY_OPEN_SAMPLES) {
+          unopened.push(name);
+        } else {
+          samples[name] = opens;
+          timings[name] = median(opens);
+        }
+      }
+      metrics.overlayOpenMs = timings;
+      metrics.overlayOpenSamplesMs = samples;
+      assertion(
+        unopened.length === 0,
+        "overlay_not_opened",
+        `No data-zappie-overlay painted after tapping ${unopened.map((name) => `the ${name} trigger`).join(", ")}`,
+        `Put data-zappie-overlay with the trigger's name on the role="dialog" element that the trigger opens.`
+      );
+      const slow = Object.entries(timings).filter(
+        ([, ms]) => ms > OVERLAY_OPEN_BUDGET_MS
+      );
+      assertion(
+        slow.length === 0,
+        "overlay_open_too_slow",
+        `Overlays took longer than ${OVERLAY_OPEN_BUDGET_MS} ms to paint, as the median of ${OVERLAY_OPEN_SAMPLES} opens: ${slow.map(([name, ms]) => `${name} ${ms} ms (${samples[name].join(", ")} ms)`).join(", ")}`,
+        "Load overlay code with deferred() from @zappie/foundations, spread useIntentPreload on the trigger, and keep work out of the first render so the overlay paints within 100 ms of the tap."
+      );
+    } finally {
+      await cdp.detach();
+    }
+  }
+};
+
+// src/checks/v17-overlay-focus.ts
+var focusInside = (page, name) => page.evaluate(
+  (selector) => Boolean(document.activeElement?.closest(selector)) || // A native modal dialog keeps focus in its top layer even when the element itself is the dialog.
+  document.activeElement === document.querySelector(selector),
+  overlaySelector(name)
+);
+async function eventually(check, timeoutMs = 1e3) {
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    if (await check()) {
+      return true;
+    }
+    if (Date.now() > deadline) {
+      return false;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+}
+var settlesInside = (page, name) => eventually(() => focusInside(page, name), 300);
+var scrollLocked = (page) => page.evaluate(() => {
+  const root = document.scrollingElement ?? document.documentElement;
+  if (root.scrollHeight <= window.innerHeight) {
+    return true;
+  }
+  const held = (element) => {
+    const style = getComputedStyle(element);
+    return ["hidden", "clip"].includes(style.overflowY) || ["hidden", "clip"].includes(style.overflow) || style.position === "fixed";
+  };
+  return held(document.documentElement) || held(document.body);
+});
+async function checkOverlay(page, name) {
+  await openSettledMenu(page);
+  const trigger = page.locator(`${triggerSelector(name)}:visible`).first();
+  await trigger.focus();
+  await page.keyboard.press("Enter");
+  if (!await eventually(() => overlayIsOpen(page, name), 5e3)) {
+    return [
+      {
+        code: "overlay_not_opened",
+        message: `Enter on the ${name} trigger did not open its data-zappie-overlay`,
+        hint: "Open the overlay from the keyboard as well as by tap, and mark its dialog with data-zappie-overlay."
+      }
+    ];
+  }
+  const findings = [];
+  if (!await eventually(() => focusInside(page, name))) {
+    findings.push({
+      code: "overlay_focus_not_moved",
+      message: `Focus stayed outside the ${name} overlay after it opened`,
+      hint: "Move focus into the overlay when it opens. Overlay from @zappie/foundations does this."
+    });
+  } else {
+    const stops = await page.locator(overlaySelector(name)).first().evaluate(
+      (node) => node.querySelectorAll(
+        'a[href], button:not([disabled]), input:not([disabled]):not([type="hidden"]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])'
+      ).length
+    );
+    let escaped = false;
+    for (let index = 0; index < Math.min(stops + 2, 30) && !escaped; index++) {
+      await page.keyboard.press("Tab");
+      escaped = !await settlesInside(page, name);
+    }
+    if (!escaped) {
+      await page.keyboard.press("Shift+Tab");
+      escaped = !await settlesInside(page, name);
+    }
+    if (escaped) {
+      findings.push({
+        code: "overlay_focus_escaped",
+        message: `Tab moved focus out of the open ${name} overlay`,
+        hint: "Keep Tab and Shift+Tab inside the overlay while it is open. Overlay from @zappie/foundations traps focus."
+      });
+    }
+  }
+  if (!await scrollLocked(page)) {
+    findings.push({
+      code: "overlay_scroll_unlocked",
+      message: `The page behind the open ${name} overlay can still scroll`,
+      hint: "Lock page scroll while the overlay is open. Overlay from @zappie/foundations does this."
+    });
+  }
+  await page.keyboard.press("Escape");
+  if (!await eventually(async () => !await overlayIsOpen(page, name))) {
+    findings.push({
+      code: "overlay_escape_ignored",
+      message: `Escape did not close the ${name} overlay`,
+      hint: "Close the overlay on Escape."
+    });
+    return findings;
+  }
+  const returned = await eventually(
+    () => page.evaluate(
+      (selector) => Boolean(document.activeElement?.closest(selector)),
+      triggerSelector(name)
+    )
+  );
+  if (!returned) {
+    findings.push({
+      code: "overlay_focus_not_returned",
+      message: `Focus did not return to the ${name} trigger after the overlay closed`,
+      hint: "Return focus to the control that opened the overlay when it closes. Overlay from @zappie/foundations does this."
+    });
+  }
+  return findings;
+}
+var v17 = {
+  id: "V17",
+  title: "Overlays manage focus",
+  viewports: "mobile",
+  async run({ page }, viewport) {
+    await page.setViewportSize(viewport);
+    await page.goto("/", { waitUntil: "domcontentloaded" });
+    await page.locator("[data-zappie-item]").first().waitFor();
+    const names = (await overlayTriggers(page)).map(({ name }) => name);
+    skipWithoutTriggers(names);
+    const findings = [];
+    for (const name of names) {
+      findings.push(...await checkOverlay(page, name));
+    }
+    const [first] = findings;
+    if (first) {
+      throw new VerifyError(
+        first.code,
+        findings.map(({ message }) => message).join(". "),
+        [...new Set(findings.map(({ hint }) => hint))].join(" ")
+      );
+    }
+  }
+};
+
 // src/checks/index.ts
 var checks = [
   v01,
@@ -3695,7 +2313,10 @@ var checks = [
   v09,
   v10,
   v13,
-  v14
+  v14,
+  v15,
+  v16,
+  v17
 ];
 var blocked = [
   [
@@ -3741,6 +2362,60 @@ function skippedChecks(suite) {
   ];
 }
 
+// src/cpu.ts
+var REFERENCE_CPU_BENCHMARK = 26e3;
+var REFERENCE_CPU_THROTTLING_RATE = 4;
+var MIN_RATE = 1;
+var MAX_RATE = 8;
+var ROUNDS = 5;
+var ROUND_MS = 100;
+function cpuThrottlingRate(benchmark) {
+  if (!Number.isFinite(benchmark) || benchmark <= 0) {
+    return REFERENCE_CPU_THROTTLING_RATE;
+  }
+  const rate = REFERENCE_CPU_THROTTLING_RATE * benchmark / REFERENCE_CPU_BENCHMARK;
+  return Math.round(Math.min(Math.max(rate, MIN_RATE), MAX_RATE) * 10) / 10;
+}
+async function benchmarkCpu(browser) {
+  const context = await browser.newContext();
+  try {
+    const page = await context.newPage();
+    return await page.evaluate(
+      ({ rounds, roundMs }) => {
+        const work = () => {
+          let text = "";
+          for (let index = 0; index < 500; index++) {
+            text += String.fromCharCode(97 + index % 26);
+          }
+          const values = Array.from(
+            { length: 500 },
+            (_, index) => index * 7919 % 500
+          );
+          values.sort((a, b) => a - b);
+          return text.length + values[0];
+        };
+        const scores = [];
+        let sink = 0;
+        for (let round = 0; round < rounds; round++) {
+          const started = performance.now();
+          let iterations = 0;
+          while (performance.now() - started < roundMs) {
+            sink += work();
+            iterations++;
+          }
+          scores.push(iterations * 1e3 / (performance.now() - started));
+        }
+        scores.sort((a, b) => a - b);
+        window.__verifySink = sink;
+        return Math.round(scores[Math.floor(scores.length / 2)]);
+      },
+      { rounds: ROUNDS, roundMs: ROUND_MS }
+    );
+  } finally {
+    await context.close();
+  }
+}
+
 // src/report.ts
 import { createPrivateKey, randomUUID, sign } from "crypto";
 var REPORT_SCHEMA = "https://registry.zappie.ai/v1/schema/verify-report.json";
@@ -3827,7 +2502,7 @@ async function reset(options) {
 }
 
 // src/version.ts
-var PACKAGE_VERSION = true ? "0.1.3" : "0.0.0-development";
+var PACKAGE_VERSION = true ? "0.2.2" : "0.0.0-development";
 
 // src/runner.ts
 var VERSION = PACKAGE_VERSION;
@@ -3876,7 +2551,7 @@ async function execute(check, run2) {
       message: failure instanceof Error ? failure.message : String(failure),
       hint: `Fix the failure in ${check.id} (${check.title.toLowerCase()}) and rerun verify.`
     };
-    if (error.code === "dependency_blocked") {
+    if (error.code === "dependency_blocked" || failure instanceof VerifyError && failure.skip) {
       return {
         id: check.id,
         title: check.title,
@@ -3918,12 +2593,29 @@ async function runVerify(options, fault) {
   }
   const started = Date.now();
   const browser = await chromium.launch();
+  const cpuBenchmark = await benchmarkCpu(browser).catch(() => void 0);
+  const throttlingRate = cpuBenchmark === void 0 ? REFERENCE_CPU_THROTTLING_RATE : cpuThrottlingRate(cpuBenchmark);
   const context = await browser.newContext(browserOptions(options));
   if (options.standInForPlatform) {
     await context.route(
       "**/_zappie/view",
       (route) => route.fulfill({ status: 204 })
     );
+    await context.route(
+      (url) => url.pathname === "/_zappie/session",
+      async (route) => {
+        const cookie = await route.request().headerValue("cookie") ?? "";
+        const signedIn = cookie.split(";").some((part) => part.trim() === "zappie_session=signed");
+        await route.fulfill({
+          status: 200,
+          contentType: "application/json",
+          headers: { "cache-control": "no-store" },
+          body: JSON.stringify({
+            customer: signedIn ? { id: "customer_verify", given_name: "Test" } : null
+          })
+        });
+      }
+    );
   }
   await context.tracing.start({ screenshots: true, snapshots: true });
   const page = await context.newPage();
@@ -3936,6 +2628,7 @@ async function runVerify(options, fault) {
     context,
     page,
     metrics,
+    cpuThrottlingRate: throttlingRate,
     ...fault ? { fault } : {}
   };
   const results = [await reset(options)];
@@ -3964,7 +2657,9 @@ async function runVerify(options, fault) {
         runner: options.runner ?? "cli",
         verifyVersion: VERSION,
         sdkVersion,
-        browser: `chromium ${browser.version()}`
+        browser: `chromium ${browser.version()}`,
+        ...cpuBenchmark === void 0 ? {} : { cpuBenchmark },
+        cpuThrottlingRate: throttlingRate
       },
       startedAt: new Date(started).toISOString(),
       durationMs: Date.now() - started,
@@ -4036,12 +2731,64 @@ function normalizeUrl(value) {
   }
 }
 
+// src/regression.ts
+var DEFAULT_REGRESSION_THRESHOLDS = {
+  menuJsKbGz: { relative: 0.05, absolute: 2 },
+  menuCssKbGz: { relative: 0.05, absolute: 1 },
+  lcpMs: { relative: 0.1, absolute: 150 },
+  cls: { relative: 0, absolute: 0.02 },
+  productCardTappableMs: { relative: 0.1, absolute: 150 },
+  productCardOpenMs: { relative: 0.15, absolute: 30 },
+  overlayOpenMs: { relative: 0.15, absolute: 20 }
+};
+function flatten(metrics) {
+  const values = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(metrics)) {
+    if (key === "overlayOpenMs" && value && typeof value === "object") {
+      for (const [name, ms] of Object.entries(value)) {
+        if (Number.isFinite(ms)) {
+          values.set(`overlayOpenMs.${name}`, {
+            kind: "overlayOpenMs",
+            value: ms
+          });
+        }
+      }
+    } else if (key in DEFAULT_REGRESSION_THRESHOLDS && typeof value === "number" && Number.isFinite(value)) {
+      values.set(key, { kind: key, value });
+    }
+  }
+  return values;
+}
+function findRegressions(baseline, head, thresholds = {}) {
+  const limits = { ...DEFAULT_REGRESSION_THRESHOLDS, ...thresholds };
+  const current = flatten(head.metrics);
+  const regressions = [];
+  for (const [metric, { kind, value: base }] of flatten(baseline.metrics)) {
+    const { relative, absolute } = limits[kind];
+    const allowed = base + Math.max(absolute, relative * base);
+    const value = current.get(metric)?.value;
+    if (value === void 0 || value > allowed) {
+      regressions.push({
+        metric,
+        base,
+        head: value,
+        allowed: Math.round(allowed * 1e3) / 1e3
+      });
+    }
+  }
+  return regressions.sort(
+    (left, right) => left.metric.localeCompare(right.metric)
+  );
+}
+
 // src/index.ts
 function verify(options) {
   return runVerify(options);
 }
 export {
+  DEFAULT_REGRESSION_THRESHOLDS,
   VerifyError,
+  findRegressions,
   printSummary,
   verify,
   verifyProject