@zappie/verify 0.2.2 → 0.2.4

package/dist/index.js

@@ -269,10 +269,69 @@ async function readStore(cwd) {
 }
 
 // src/runner.ts
-import { chromium, errors } from "@playwright/test";
+import {
+  chromium,
+  errors
+} from "@playwright/test";
 import { mkdir } from "fs/promises";
 import path3 from "path";
 
+// 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;
+}
+function benchmarkPage(page) {
+  return 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 }
+  );
+}
+async function benchmarkCpu(browser) {
+  const context = await browser.newContext();
+  try {
+    return await benchmarkPage(await context.newPage());
+  } finally {
+    await context.close();
+  }
+}
+
 // src/checks/common.ts
 async function open(page, path4 = "/") {
   const response = await page.goto(path4, { waitUntil: "domcontentloaded" });
@@ -289,7 +348,10 @@ async function debugValue(page, expression) {
 }
 var mobile = { width: 390, height: 844 };
 var desktop = { width: 1440, height: 900 };
-async function applyPhoneProfile(page, rate) {
+async function applyPhoneProfile(page, fallbackRate) {
+  await page.goto("about:blank");
+  const benchmark = await benchmarkPage(page).catch(() => void 0);
+  const rate = benchmark === void 0 ? fallbackRate : cpuThrottlingRate(benchmark);
   const cdp = await page.context().newCDPSession(page);
   await cdp.send("Network.enable");
   await cdp.send("Network.setCacheDisabled", { cacheDisabled: true });
@@ -301,7 +363,143 @@ async function applyPhoneProfile(page, rate) {
     connectionType: "cellular3g"
   });
   await cdp.send("Emulation.setCPUThrottlingRate", { rate });
-  return cdp;
+  return { cdp, rate };
+}
+var ITEM_DIALOG = '[data-zappie-overlay="item"], [role="dialog"]';
+async function itemOpener(page, itemId) {
+  const marked = `[data-zappie-item="${itemId}"]`;
+  await page.locator(marked).first().waitFor();
+  const own = page.locator(
+    [
+      `a[href]${marked}`,
+      `button${marked}`,
+      `[role="link"]${marked}`,
+      `[role="button"]${marked}`
+    ].join(", ")
+  ).filter({ visible: true }).first();
+  if (await own.count()) {
+    return { opener: own, focusTarget: own };
+  }
+  const card = page.locator(marked).filter({ visible: true }).first();
+  const inner = card.locator('a[href], [role="link"]').first();
+  if (await inner.count()) {
+    return { opener: inner, focusTarget: card };
+  }
+  const cell = card.locator("xpath=..");
+  return {
+    opener: cell.locator('a[href], [role="link"]').first(),
+    focusTarget: cell
+  };
+}
+async function openItem(page, itemId) {
+  const found = await itemOpener(page, itemId);
+  await found.opener.click();
+  await itemShown(page);
+  return found;
+}
+async function itemShown(page) {
+  await Promise.race([
+    page.waitForURL((url) => /\/item\//.test(url.pathname)),
+    page.locator(ITEM_DIALOG).filter({ visible: true }).first().waitFor()
+  ]);
+}
+async function closeItem(page) {
+  const dialog = page.locator(ITEM_DIALOG).filter({ visible: true }).last();
+  if (!await dialog.count()) {
+    await page.goBack();
+    return;
+  }
+  const close = dialog.getByRole("button", { name: /close/i }).filter({ visible: true }).first();
+  if (await close.count()) {
+    await close.click();
+    return;
+  }
+  const outside = page.getByRole("button", { name: /close/i }).filter({ visible: true }).last();
+  if (await outside.count()) {
+    await outside.click();
+    return;
+  }
+  await page.keyboard.press("Escape");
+}
+function itemOpenerSelector(itemId) {
+  const marked = itemId ? `[data-zappie-item="${itemId}"]` : "[data-zappie-item]";
+  return [
+    `a[href]${marked}`,
+    `button${marked}`,
+    `[role="link"]${marked}`,
+    `[role="button"]${marked}`,
+    `${marked} a[href]`
+  ].join(", ");
+}
+async function cartTriggerSelector(page) {
+  return await page.locator("[data-zappie-cart-trigger]").count() ? "[data-zappie-cart-trigger]" : '[data-zappie-overlay-trigger="bag"]';
+}
+async function cartTrigger(page) {
+  return page.locator(await cartTriggerSelector(page)).filter({ visible: true }).first();
+}
+async function tabTo(page, selector, presses = 60) {
+  for (let index = 0; index < presses; index++) {
+    await page.keyboard.press("Tab");
+    const inside = await page.evaluate(
+      (value) => Boolean(document.activeElement?.closest(value)),
+      selector
+    );
+    if (inside) {
+      return true;
+    }
+  }
+  return false;
+}
+async function signIn(page, site = page.url()) {
+  await page.context().addCookies([
+    {
+      name: "zappie_session",
+      value: "signed",
+      domain: new URL(site).hostname,
+      path: "/"
+    }
+  ]);
+}
+async function revealField(page, field, input, reach = async () => {
+}) {
+  const site = new URL(page.url());
+  const opener = page.locator(`[data-zappie-field-open="${field}"]`).filter({ visible: true }).first();
+  const shown = input.filter({ visible: true }).first();
+  await shown.or(opener).first().waitFor();
+  if (await shown.isVisible()) {
+    return shown;
+  }
+  await opener.click();
+  if (await sentToSignIn(page, site, shown)) {
+    await signIn(page, site.href);
+    await open(page, site.pathname);
+    await reach();
+    await opener.click();
+  }
+  await shown.waitFor();
+  return shown;
+}
+async function sentToSignIn(page, site, shown) {
+  const deadline = Date.now() + 1e4;
+  while (Date.now() < deadline) {
+    const url = new URL(page.url());
+    if (url.origin !== site.origin || url.pathname === "/_zappie/login") {
+      return true;
+    }
+    if (await shown.isVisible().catch(() => false)) {
+      return false;
+    }
+    await page.waitForTimeout(100);
+  }
+  return false;
+}
+async function dialogConfirm(page, confirm) {
+  const marked = page.locator(confirm).filter({ visible: true }).first();
+  if (await marked.count()) {
+    return marked;
+  }
+  const button = page.locator('[role="dialog"]').filter({ visible: true }).last().locator('footer button:enabled, button[type="submit"]:enabled').filter({ visible: true }).last();
+  return await button.count() ? button : void 0;
 }
 
 // src/checks/v01-routes.ts
@@ -373,6 +571,7 @@ var v02 = {
 };
 
 // src/fixtures.ts
+var preparedPages = /* @__PURE__ */ new WeakMap();
 async function installFault(page, fault) {
   if (!fault) {
     return;
@@ -408,6 +607,179 @@ async function installFault(page, fault) {
       }).observe(document, { childList: true, subtree: true });
     });
   }
+  if (fault === "card-link") {
+    await page.addInitScript(() => {
+      new MutationObserver(() => {
+        for (const node of document.querySelectorAll(
+          '[role="dialog"] [aria-label="Close item"]'
+        )) {
+          node.setAttribute("aria-label", "Close");
+        }
+      }).observe(document, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        attributeFilter: ["aria-label"]
+      });
+    });
+  }
+  if (fault === "no-add-marker") {
+    await page.addInitScript(() => {
+      new MutationObserver(() => {
+        for (const node of document.querySelectorAll(
+          '[data-zappie-action="add-to-cart"]'
+        )) {
+          node.removeAttribute("data-zappie-action");
+        }
+      }).observe(document, { childList: true, subtree: true });
+    });
+  }
+  if (fault === "add-enabled-invalid" || fault === "add-enabled-silent") {
+    await page.addInitScript((flags) => {
+      new MutationObserver(() => {
+        for (const original of document.querySelectorAll(
+          '[role="dialog"] button[data-zappie-action="add-to-cart"]:not([data-verify-proxied])'
+        )) {
+          original.setAttribute("data-verify-proxied", "");
+          original.removeAttribute("data-zappie-action");
+          original.style.display = "none";
+          const proxy = document.createElement("button");
+          proxy.type = "button";
+          proxy.textContent = "Add";
+          proxy.setAttribute("data-zappie-action", "add-to-cart");
+          proxy.setAttribute("data-verify-proxied", "");
+          proxy.addEventListener("click", () => {
+            if (!original.disabled) {
+              original.click();
+              return;
+            }
+            const group = original.closest('[role="dialog"]')?.querySelector(
+              '[data-zappie-option-group][aria-required="true"]:not(:has([data-state="checked"]))'
+            );
+            if (flags && group) {
+              group.setAttribute("aria-invalid", "true");
+              group.setAttribute("data-invalid", "");
+              const message = document.createElement("p");
+              message.textContent = "Choose one to continue";
+              group.append(message);
+              group.focus();
+            }
+          });
+          original.after(proxy);
+        }
+      }).observe(document, { childList: true, subtree: true });
+    }, fault === "add-enabled-invalid");
+  }
+  if (fault === "total-on-checkout" || fault === "total-missing") {
+    await page.addInitScript((onCheckout) => {
+      window.addEventListener(
+        "click",
+        (event) => {
+          const link = event.target?.closest("a[data-zappie-cart-checkout]");
+          if (!link) {
+            return;
+          }
+          event.preventDefault();
+          event.stopImmediatePropagation();
+          history.pushState(history.state, "", link.href);
+          window.dispatchEvent(
+            new PopStateEvent("popstate", { state: history.state })
+          );
+        },
+        { capture: true }
+      );
+      new MutationObserver(() => {
+        for (const node of document.querySelectorAll(
+          '[data-zappie-overlay="bag"] [data-zappie-total]'
+        )) {
+          sessionStorage.setItem("verify-total", node.textContent ?? "");
+          node.removeAttribute("data-zappie-total");
+        }
+        const text = sessionStorage.getItem("verify-total");
+        if (onCheckout && text && location.pathname === "/checkout" && document.querySelector("main") && !document.querySelector("[data-verify-total]")) {
+          const total = document.createElement("p");
+          total.setAttribute("data-verify-total", "");
+          total.setAttribute("data-zappie-total", "");
+          total.textContent = text;
+          document.querySelector("main").prepend(total);
+        }
+      }).observe(document, { childList: true, subtree: true });
+    }, fault === "total-on-checkout");
+  }
+  if (fault === "address-confirm" || fault === "address-not-stored") {
+    await page.addInitScript((confirms) => {
+      let release = false;
+      window.addEventListener(
+        "click",
+        (event) => {
+          const option = event.target?.closest(
+            '[role="option"]'
+          );
+          if (!option || release) {
+            return;
+          }
+          event.stopImmediatePropagation();
+          event.preventDefault();
+          if (!confirms) {
+            return;
+          }
+          const dialog = document.createElement("div");
+          dialog.setAttribute("role", "dialog");
+          dialog.setAttribute("aria-label", "Confirm address");
+          const footer = document.createElement("footer");
+          const button = document.createElement("button");
+          button.type = "button";
+          button.textContent = "Deliver here";
+          button.addEventListener("click", () => {
+            dialog.remove();
+            release = true;
+            option.click();
+            release = false;
+          });
+          footer.append(button);
+          dialog.append(footer);
+          document.body.append(dialog);
+        },
+        { capture: true }
+      );
+    }, fault === "address-confirm");
+  }
+  if (fault === "field-rows") {
+    await page.addInitScript(() => {
+      const fields = [
+        ["address", "[data-zappie-address-input]"],
+        ["phone", 'input[type="tel"]']
+      ];
+      new MutationObserver(() => {
+        for (const [field, selector] of fields) {
+          for (const input of document.querySelectorAll(
+            `${selector}:not([data-verify-row])`
+          )) {
+            input.setAttribute("data-verify-row", "");
+            input.hidden = true;
+            const row = document.createElement("button");
+            row.type = "button";
+            row.textContent = `Add your ${field}`;
+            row.setAttribute("data-zappie-field-open", field);
+            row.addEventListener("click", () => {
+              if (!document.cookie.includes("zappie_session=signed")) {
+                window.location.assign(
+                  new URL(
+                    `/_zappie/login?return=${encodeURIComponent(location.pathname)}`,
+                    location.href
+                  ).href
+                );
+                return;
+              }
+              row.remove();
+              input.hidden = false;
+            });
+            input.before(row);
+          }
+        }
+      }).observe(document, { childList: true, subtree: true });
+    });
+  }
   if (fault === "overlay-markers") {
     await page.addInitScript(() => {
       new MutationObserver(() => {
@@ -426,7 +798,32 @@ async function installFault(page, fault) {
       }).observe(document, { childList: true, subtree: true });
     });
   }
-  if (fault === "bag-on-tap") {
+  if (fault === "bag-after-add" || fault === "bag-after-add-on-tap") {
+    await page.addInitScript(() => {
+      const sync = () => {
+        let count = 0;
+        try {
+          count = window.__zappie?.cart().count ?? 0;
+        } catch {
+        }
+        for (const node of document.querySelectorAll(
+          '[data-zappie-overlay-trigger="bag"]'
+        )) {
+          if (count === 0) {
+            node.style.setProperty("display", "none", "important");
+          } else {
+            node.style.removeProperty("display");
+          }
+        }
+      };
+      new MutationObserver(sync).observe(document, {
+        childList: true,
+        subtree: true
+      });
+      window.setInterval(sync, 50);
+    });
+  }
+  if (fault === "bag-on-tap" || fault === "bag-after-add-on-tap") {
     let release = () => {
     };
     let tapped = Promise.resolve();
@@ -462,24 +859,26 @@ async function installFault(page, fault) {
     );
   }
   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) {
+    const browser = page.context().browser();
+    const index = browser ? preparedPages.get(browser) ?? 0 : 0;
+    if (browser) {
+      preparedPages.set(browser, index + 1);
+    }
+    if (index > 0 && (index - 1) % 3 === 0) {
+      await page.addInitScript(() => {
+        document.addEventListener(
+          "click",
+          (event) => {
+            if (event.target instanceof Element && event.target.closest("[data-zappie-overlay-trigger]")) {
+              const until = performance.now() + 250;
+              while (performance.now() < until) {
+              }
             }
-          }
-        },
-        { capture: true }
-      );
-    });
+          },
+          { capture: true }
+        );
+      });
+    }
   }
   if (fault === "late-hydration") {
     await page.route(
@@ -643,6 +1042,22 @@ async function applyPageFault(page, fault) {
       }
     });
   }
+  if (fault === "card-link") {
+    await page.waitForFunction(() => {
+      const link = document.querySelector("a[data-zappie-item]");
+      return link !== null && Object.keys(link).some((key) => key.startsWith("__reactProps$"));
+    });
+    await page.locator("a[data-zappie-item]").evaluateAll((links) => {
+      for (const link of links) {
+        const id = link.getAttribute("data-zappie-item");
+        const card = link.parentElement?.querySelector(
+          `article[data-zappie-item="${id}"]`
+        );
+        link.textContent = card?.querySelector("h3")?.textContent ?? "Item";
+        card?.removeAttribute("data-zappie-item");
+      }
+    });
+  }
   if (fault === "missing-marker") {
     await page.locator("[data-zappie-item]").evaluateAll((nodes) => {
       for (const node of nodes) {
@@ -878,11 +1293,11 @@ var v05 = {
       "The test menu has no available item with required options",
       "Keep one available configurable item in the test menu."
     );
-    const item = page.locator(`[data-zappie-item="${selected.id}"]`).first();
-    await item.locator("xpath=..").getByRole("link", { name: "View details" }).click();
+    await openItem(page, selected.id);
     const dialog = page.getByRole("dialog");
     await dialog.waitFor();
     const required = dialog.locator('[data-zappie-option-group][aria-required="true"]').first();
+    await required.waitFor({ timeout: 5e3 }).catch(() => void 0);
     assertion(
       await required.count(),
       "required_group_missing",
@@ -891,23 +1306,41 @@ var v05 = {
     );
     const before = await debugValue(page, () => window.__zappie.cart().count);
     const add = dialog.locator('[data-zappie-action="add-to-cart"]');
-    assertion(
-      await add.isDisabled(),
-      "required_option_bypassed",
-      "Add is enabled before the shopper chooses a required option",
-      "Disable Add until the shopper completes every required option group."
-    );
-    for (let index = 0; index < 5 && await add.isDisabled(); index++) {
-      const unsatisfied = dialog.locator(
-        '[data-zappie-option-group][aria-required="true"]:not(:has([data-state="checked"]))'
-      ).first();
+    const unsatisfied = dialog.locator(
+      '[data-zappie-option-group][aria-required="true"]:not(:has([data-state="checked"]))'
+    );
+    const blocked2 = await add.isDisabled();
+    if (!blocked2) {
+      const group = unsatisfied.first();
+      const textBefore = (await group.innerText().catch(() => "")).trim();
+      await add.click();
+      await page.waitForTimeout(500);
+      const added = await page.evaluate(
+        (count) => window.__zappie.cart().count > count,
+        before
+      );
       assertion(
-        await unsatisfied.count(),
+        !added && await dialog.isVisible(),
+        "required_option_bypassed",
+        "Add put the item in the cart before the shopper chose a required option",
+        "Disable Add until the shopper completes every required option group, or keep the item open and flag the group when Add is tapped."
+      );
+      assertion(
+        await group.evaluate(flagged, textBefore),
+        "required_option_unflagged",
+        "Tapping Add before a required choice did not flag the group",
+        "Mark the group that needs a choice with aria-invalid or data-invalid and show a message saying why."
+      );
+    }
+    for (let index = 0; index < 5 && (blocked2 ? await add.isDisabled() : await unsatisfied.count() > 0); index++) {
+      const next = unsatisfied.first();
+      assertion(
+        await next.count(),
         "required_option_unselectable",
         "A required option group has no selectable choice",
         "Keep an available choice in every required option group."
       );
-      await unsatisfied.locator('[data-zappie-option]:not([aria-disabled="true"])').first().click();
+      await next.locator('[data-zappie-option]:not([aria-disabled="true"])').first().click();
     }
     assertion(
       await add.isEnabled(),
@@ -935,6 +1368,22 @@ var v05 = {
     );
   }
 };
+function flagged(group, textBefore) {
+  const invalid = group.getAttribute("aria-invalid") === "true" || group.hasAttribute("data-invalid") || group.querySelector('[aria-invalid="true"], [data-invalid]') !== null;
+  if (!invalid) {
+    return false;
+  }
+  const shown = (element) => element instanceof HTMLElement && element.getClientRects().length > 0 && Boolean(element.innerText.trim());
+  if (group instanceof HTMLElement && group.innerText.trim().length > textBefore.length) {
+    return true;
+  }
+  const referenced = ["aria-describedby", "aria-errormessage"].flatMap((name) => group.getAttribute(name)?.split(/\s+/) ?? []).some((id) => shown(document.getElementById(id)));
+  if (referenced) {
+    return true;
+  }
+  const dialog = group.closest('[role="dialog"]') ?? document;
+  return [...dialog.querySelectorAll('[role="alert"]')].some(shown);
+}
 
 // src/checks/v06-quote.ts
 var v06 = {
@@ -946,9 +1395,20 @@ var v06 = {
     if (new URL(page.url()).pathname !== "/") {
       await open(page);
     }
-    const total = page.locator("[data-zappie-total]");
-    if (!await total.isVisible()) {
-      await page.locator("[data-zappie-cart-trigger]").first().click();
+    const total = page.locator("[data-zappie-total]").filter({ visible: true });
+    const bagOpen = page.locator('[data-zappie-overlay="bag"]').filter({ visible: true });
+    if (!await total.count()) {
+      if (!await bagOpen.count()) {
+        await (await cartTrigger(page)).click();
+      }
+      await total.first().waitFor({ timeout: 2e3 }).catch(() => void 0);
+    }
+    if (!await total.count()) {
+      const handover = page.locator('[data-zappie-overlay="bag"], [role="dialog"]').filter({ visible: true }).locator('[data-zappie-cart-checkout], a[href*="/checkout"]').filter({ visible: true }).first();
+      if (await handover.count()) {
+        await handover.click();
+        await page.waitForURL((url) => url.pathname.endsWith("/checkout"));
+      }
     }
     await page.waitForFunction(
       () => window.__zappie.events.some((entry) => entry.name === "quote"),
@@ -962,11 +1422,21 @@ var v06 = {
       "The cart did not produce a quote within 2 seconds",
       "Open the cart through the SDK and render Totals so it requests a quote."
     );
-    const rendered = await total.textContent();
+    let expected = format.money(quote.total);
+    let rendered = null;
+    for (let attempt = 0; attempt < 20; attempt++) {
+      const latest = await page.evaluate(() => window.__zappie.quote());
+      expected = format.money((latest ?? quote).total);
+      rendered = await total.first().textContent({ timeout: 5e3 }).catch(() => null);
+      if (rendered === null || rendered.includes(expected)) {
+        break;
+      }
+      await page.waitForTimeout(250);
+    }
     assertion(
-      rendered?.includes(format.money(quote.total)),
+      rendered?.includes(expected),
       "total_mismatch",
-      `Rendered total does not match ${format.money(quote.total)}`,
+      `Rendered total does not match ${expected}`,
       "Render quote.total with the SDK Money formatter."
     );
   }
@@ -1101,7 +1571,7 @@ var v07 = {
       await window.__zappie.cart.inject({ lines: lines2 });
     }, lines);
     await page.reload({ waitUntil: "domcontentloaded" });
-    await page.locator("[data-zappie-cart-trigger]").first().click();
+    await (await cartTrigger(page)).click();
     const codes = unavailable ? ["price_changed", "item_unavailable"] : ["price_changed"];
     for (const code of codes) {
       const issue = page.locator(`[data-zappie-issue="${code}"]`).first();
@@ -1424,14 +1894,28 @@ var v10 = {
       "Render a delivery control with data-zappie-fulfilment=delivery."
     );
     await delivery.click();
-    const input = page.locator("[data-zappie-address-input]");
-    await input.waitFor();
+    const input = await revealField(
+      page,
+      "address",
+      page.locator("[data-zappie-address-input]"),
+      () => delivery.click()
+    );
     await input.fill(ADDRESS);
     await page.getByText(ADDRESS, { exact: true }).last().click();
-    await page.waitForFunction(() => {
-      const fulfilment2 = window.__zappie.cart().fulfilment;
-      return fulfilment2?.type === "delivery" && Boolean(fulfilment2.address.placeId);
-    });
+    if (!await addressStored(page, 3e3)) {
+      const confirm = await dialogConfirm(
+        page,
+        "[data-zappie-address-confirm]"
+      );
+      assertion(
+        confirm,
+        "delivery_address_missing",
+        "The selected address was not stored",
+        "Store the resolved address on delivery fulfilment when the shopper picks it, or mark the control that confirms it with data-zappie-address-confirm."
+      );
+      await confirm.click();
+    }
+    await addressStored(page);
     const fulfilment = await debugValue(
       page,
       () => window.__zappie.cart().fulfilment
@@ -1475,12 +1959,30 @@ var v10 = {
     );
   }
 };
+async function addressStored(page, timeout) {
+  return page.waitForFunction(
+    () => {
+      const fulfilment = window.__zappie.cart().fulfilment;
+      return fulfilment?.type === "delivery" && Boolean(fulfilment.address.placeId);
+    },
+    void 0,
+    timeout === void 0 ? {} : { timeout }
+  ).then(
+    () => true,
+    (error) => {
+      if (timeout === void 0) {
+        throw error;
+      }
+      return false;
+    }
+  );
+}
 
 // src/checks/v13-accessibility.ts
 import AxeBuilder from "@axe-core/playwright";
 
 // src/checks/semantics.ts
-var TOUCH_TARGET_PX = 44;
+var TOUCH_TARGET_PX = 24;
 async function semanticFindings(page, scope) {
   return page.evaluate(
     ({ scope: scope2, minimum }) => {
@@ -1583,11 +2085,29 @@ var semanticHints = {
   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."
+  touch_target_too_small: "Make every menu control at least 24\xD724 px on a phone, with padding or a larger hit area."
 };
 
 // src/checks/v13-accessibility.ts
 async function severeViolations(page) {
+  await page.evaluate(
+    () => new Promise((resolve) => {
+      const deadline = performance.now() + 2e3;
+      let quiet = 0;
+      const frame = () => {
+        const running = document.getAnimations().some(
+          (animation) => animation.playState === "running" && animation.effect?.getComputedTiming().iterations !== Infinity
+        );
+        quiet = running ? 0 : quiet + 1;
+        if (quiet >= 3 || performance.now() > deadline) {
+          resolve();
+          return;
+        }
+        requestAnimationFrame(frame);
+      };
+      requestAnimationFrame(frame);
+    })
+  );
   const analysis = await new AxeBuilder({ page }).analyze();
   return analysis.violations.filter(
     (entry) => entry.impact === "critical" || entry.impact === "serious"
@@ -1621,11 +2141,48 @@ async function holdsFocus(target2) {
   }
   return false;
 }
+var ADD = '[data-zappie-action="add-to-cart"]';
+async function keyboardReachesAddAndCart(page, itemId, cartInColumn) {
+  const cart = cartInColumn ? [] : [await cartTriggerSelector(page)];
+  if (await page.locator(ADD).count() || !itemId) {
+    return controlsAreReachable(page, [ADD, ...cart]);
+  }
+  const opener = itemOpenerSelector(itemId);
+  if (cart.length && !await controlsAreReachable(page, cart)) {
+    return false;
+  }
+  await open(page);
+  if (!await tabTo(page, opener, 200)) {
+    return false;
+  }
+  await page.keyboard.press("Enter");
+  await itemShown(page);
+  return tabTo(page, ADD);
+}
+async function checkoutEnabled(page, timeout) {
+  return page.waitForFunction(
+    () => document.querySelector("[data-zappie-checkout]")?.disabled === false,
+    void 0,
+    { timeout }
+  ).then(
+    () => true,
+    () => false
+  );
+}
+async function fillSteadily(input, value) {
+  for (let attempt = 0; attempt < 3; attempt++) {
+    await input.fill(value);
+    await input.page().waitForTimeout(150);
+    if (await input.inputValue() === value) {
+      return;
+    }
+  }
+}
 var v13 = {
   id: "V13",
   title: "Accessibility",
   viewports: "both",
-  async run({ page, context, options, fault }, viewport) {
+  async run({ page, options, fault }, viewport) {
     await page.setViewportSize(viewport);
     await open(page);
     await applyPageFault(page, fault);
@@ -1643,21 +2200,23 @@ var v13 = {
       "No available item can be opened for accessibility checks",
       "Keep one available item in the test menu."
     );
-    const card = page.locator(`[data-zappie-item="${item.id}"]`).first().locator("xpath=..");
-    await card.getByRole("link", { name: "View details" }).click();
+    const { focusTarget: card } = await openItem(page, item.id);
     violations.push(...await severeViolations(page));
     semantics.push(
       ...await semanticFindings(page, { page: false, phone: false })
     );
-    await page.getByRole("button", { name: "Close item" }).click();
+    await closeItem(page);
     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();
+    const cart = await cartTrigger(page);
+    const cartInColumn = viewport.width >= 768 && !await cart.isVisible();
+    if (!cartInColumn) {
+      await cart.click();
+    }
     violations.push(...await severeViolations(page));
     semantics.push(
       ...await semanticFindings(page, { page: false, phone: false })
@@ -1671,8 +2230,10 @@ var v13 = {
       message || "Accessibility violation",
       "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)) {
+    if (!cartInColumn) {
+      await page.keyboard.press("Escape");
+    }
+    if (!cartInColumn && !await holdsFocus(cart)) {
       semantics.push({
         code: "focus_not_returned",
         message: "Focus did not return to the cart control after the cart closed"
@@ -1691,14 +2252,7 @@ var v13 = {
         )
       ].join(" ")
     );
-    await context.addCookies([
-      {
-        name: "zappie_session",
-        value: "signed",
-        domain: new URL(page.url()).hostname,
-        path: "/"
-      }
-    ]);
+    await signIn(page);
     await open(page, "/orders/order_fixture");
     const order = await severeViolations(page);
     assertion(
@@ -1709,16 +2263,32 @@ var v13 = {
     );
     await open(page);
     assertion(
-      await controlsAreReachable(page, [
-        '[data-zappie-action="add-to-cart"]',
-        "[data-zappie-cart-trigger]"
-      ]),
+      await keyboardReachesAddAndCart(
+        page,
+        simpleItem(await readMenu(options))?.id,
+        cartInColumn
+      ),
       "keyboard_marker_unreachable",
       "Keyboard navigation did not reach the Add and cart controls",
       "Keep the marked Add and cart controls in the tab order."
     );
     await open(page, "/checkout");
-    await page.locator('input[type="tel"]').fill("+2348000000001");
+    const tel = page.locator('input[type="tel"]').filter({ visible: true }).first();
+    const phoneRow = page.locator('[data-zappie-field-open="phone"]').filter({ visible: true }).first();
+    await tel.or(phoneRow).first().waitFor();
+    if (!await tel.isVisible() && await checkoutEnabled(page, 3e3)) {
+      await phoneRow.focus();
+    } else {
+      const phone = await revealField(
+        page,
+        "phone",
+        page.locator('input[type="tel"]')
+      );
+      await fillSteadily(phone, "+2348000000001");
+      if (await page.locator('[role="dialog"]').filter({ has: phone }).isVisible()) {
+        await (await dialogConfirm(page, "[data-zappie-field-confirm]"))?.click();
+      }
+    }
     await page.waitForFunction(
       () => !document.querySelector("[data-zappie-checkout]")?.disabled
     );
@@ -1738,7 +2308,7 @@ var v14 = {
   viewports: "mobile",
   async run({ page, metrics, fault, cpuThrottlingRate: cpuThrottlingRate2 }, viewport) {
     await page.setViewportSize(viewport);
-    const cdp = await applyPhoneProfile(page, cpuThrottlingRate2);
+    const { cdp } = await applyPhoneProfile(page, cpuThrottlingRate2);
     await page.addInitScript(() => {
       const state = { lcp: 0, cls: 0 };
       Object.assign(window, { __zappiePerformance: state });
@@ -1820,7 +2390,7 @@ var v15 = {
   viewports: "mobile",
   async run({ page, metrics, cpuThrottlingRate: cpuThrottlingRate2 }, viewport) {
     await page.setViewportSize(viewport);
-    const cdp = await applyPhoneProfile(page, cpuThrottlingRate2);
+    const { cdp } = await applyPhoneProfile(page, cpuThrottlingRate2);
     try {
       await page.goto("/", { waitUntil: "domcontentloaded" });
       await cdp.send("Network.setCacheDisabled", { cacheDisabled: false });
@@ -2101,6 +2671,41 @@ async function openSettledMenu(page) {
     network.stop();
   }
 }
+async function revealBagTrigger(page, itemId) {
+  const bag = page.locator(`${triggerSelector("bag")}:visible`).first();
+  if (!itemId || await bag.count()) {
+    return;
+  }
+  const before = await page.evaluate(() => window.__zappie?.cart().count ?? 0).catch(() => 0);
+  const add = '[data-zappie-action="add-to-cart"]';
+  const quick = page.locator(`[data-zappie-item="${itemId}"] ${add}`).filter({ visible: true }).first();
+  if (await quick.count()) {
+    await quick.click();
+  } else {
+    const opener = page.locator(itemOpenerSelector(itemId)).filter({ visible: true }).first();
+    if (!await opener.count()) {
+      return;
+    }
+    await opener.click();
+    const inItem = page.locator(
+      `[role="dialog"] [data-zappie-item] ${add}:visible, main [data-zappie-item] ${add}:visible`
+    ).first();
+    if (!await inItem.waitFor({ timeout: 5e3 }).then(
+      () => true,
+      () => false
+    )) {
+      return;
+    }
+    await inItem.click();
+  }
+  await page.waitForFunction(
+    (count) => (window.__zappie?.cart().count ?? 0) > count,
+    before,
+    { timeout: 5e3 }
+  ).catch(() => void 0);
+  await openSettledMenu(page);
+  await bag.waitFor({ timeout: 5e3 }).catch(() => void 0);
+}
 
 // src/checks/v16-overlays-open-quickly.ts
 var OVERLAY_OPEN_BUDGET_MS = 100;
@@ -2110,64 +2715,89 @@ var median = (values) => {
   const sorted = [...values].sort((a, b) => a - b);
   return sorted[Math.floor(sorted.length / 2)];
 };
+async function firstOpen(fresh, viewport, name, cpuThrottlingRate2, itemId) {
+  const { page } = fresh;
+  try {
+    await page.setViewportSize(viewport);
+    const { cdp, rate } = await applyPhoneProfile(page, cpuThrottlingRate2);
+    try {
+      await openSettledMenu(page);
+      if (name === "bag") {
+        await revealBagTrigger(page, itemId);
+      }
+      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);
+      return ms === void 0 ? void 0 : { ms, rate };
+    } finally {
+      await cdp.detach().catch(() => void 0);
+    }
+  } finally {
+    await fresh.close();
+  }
+}
 var v16 = {
   id: "V16",
   title: "Overlays open quickly",
   viewports: "mobile",
-  async run({ page, metrics, cpuThrottlingRate: cpuThrottlingRate2 }, viewport) {
+  async run({ page, options, metrics, freshPage, 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);
+    const itemId = simpleItem(await readMenu(options))?.id;
+    await openSettledMenu(page);
+    await revealBagTrigger(page, itemId);
+    const names = (await overlayTriggers(page)).map(({ name }) => name);
+    skipWithoutTriggers(names);
+    const timings = {};
+    const samples = {};
+    const rates = {};
+    const unopened = [];
+    for (const name of names) {
+      const opens = [];
+      const opensRates = [];
+      for (let sample = 0; sample < OVERLAY_OPEN_SAMPLES; sample++) {
+        const open2 = await firstOpen(
+          await freshPage(),
+          viewport,
+          name,
+          cpuThrottlingRate2,
+          itemId
+        );
+        if (open2 === void 0) {
+          break;
         }
+        opens.push(Math.round(open2.ms));
+        opensRates.push(open2.rate);
+      }
+      if (opens.length < OVERLAY_OPEN_SAMPLES) {
+        unopened.push(name);
+      } else {
+        samples[name] = opens;
+        rates[name] = opensRates;
+        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();
     }
+    metrics.overlayOpenMs = timings;
+    metrics.overlayOpenSamplesMs = samples;
+    metrics.overlayOpenRates = rates;
+    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} first 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."
+    );
   }
 };
 
@@ -2201,8 +2831,11 @@ var scrollLocked = (page) => page.evaluate(() => {
   };
   return held(document.documentElement) || held(document.body);
 });
-async function checkOverlay(page, name) {
+async function checkOverlay(page, name, itemId) {
   await openSettledMenu(page);
+  if (name === "bag") {
+    await revealBagTrigger(page, itemId);
+  }
   const trigger = page.locator(`${triggerSelector(name)}:visible`).first();
   await trigger.focus();
   await page.keyboard.press("Enter");
@@ -2280,15 +2913,26 @@ var v17 = {
   id: "V17",
   title: "Overlays manage focus",
   viewports: "mobile",
-  async run({ page }, viewport) {
+  async run({ page, options, freshPage }, viewport) {
     await page.setViewportSize(viewport);
+    const itemId = simpleItem(await readMenu(options))?.id;
     await page.goto("/", { waitUntil: "domcontentloaded" });
     await page.locator("[data-zappie-item]").first().waitFor();
+    if (!await page.locator(`${triggerSelector("bag")}:visible`).count()) {
+      await openSettledMenu(page);
+      await revealBagTrigger(page, itemId);
+    }
     const names = (await overlayTriggers(page)).map(({ name }) => name);
     skipWithoutTriggers(names);
     const findings = [];
     for (const name of names) {
-      findings.push(...await checkOverlay(page, name));
+      const fresh = await freshPage();
+      try {
+        await fresh.page.setViewportSize(viewport);
+        findings.push(...await checkOverlay(fresh.page, name, itemId));
+      } finally {
+        await fresh.close();
+      }
     }
     const [first] = findings;
     if (first) {
@@ -2362,60 +3006,6 @@ 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";
@@ -2502,7 +3092,7 @@ async function reset(options) {
 }
 
 // src/version.ts
-var PACKAGE_VERSION = true ? "0.2.2" : "0.0.0-development";
+var PACKAGE_VERSION = true ? "0.2.4" : "0.0.0-development";
 
 // src/runner.ts
 var VERSION = PACKAGE_VERSION;
@@ -2583,18 +3173,7 @@ async function execute(check, run2) {
   }
 }
 var label = (viewport) => `${viewport.width}x${viewport.height}`;
-async function runVerify(options, fault) {
-  if (!/^pk_test_.+/.test(options.key)) {
-    throw new VerifyError(
-      "live_key_refused",
-      "Verify accepts only pk_test_ keys",
-      "Create a test publishable key and rerun verify."
-    );
-  }
-  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);
+async function openContext(browser, options) {
   const context = await browser.newContext(browserOptions(options));
   if (options.standInForPlatform) {
     await context.route(
@@ -2617,10 +3196,29 @@ async function runVerify(options, fault) {
       }
     );
   }
-  await context.tracing.start({ screenshots: true, snapshots: true });
+  return context;
+}
+async function preparePage(context, options, fault) {
   const page = await context.newPage();
   page.setDefaultTimeout(Math.min(options.timeoutMs ?? 2e4, 2e4));
   await installFault(page, fault);
+  return page;
+}
+async function runVerify(options, fault) {
+  if (!/^pk_test_.+/.test(options.key)) {
+    throw new VerifyError(
+      "live_key_refused",
+      "Verify accepts only pk_test_ keys",
+      "Create a test publishable key and rerun verify."
+    );
+  }
+  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 openContext(browser, options);
+  await context.tracing.start({ screenshots: true, snapshots: true });
+  const page = await preparePage(context, options, fault);
   const metrics = {};
   const run2 = {
     options,
@@ -2629,7 +3227,14 @@ async function runVerify(options, fault) {
     page,
     metrics,
     cpuThrottlingRate: throttlingRate,
-    ...fault ? { fault } : {}
+    ...fault ? { fault } : {},
+    async freshPage() {
+      const fresh = await openContext(browser, options);
+      return {
+        page: await preparePage(fresh, options, fault),
+        close: () => fresh.close()
+      };
+    }
   };
   const results = [await reset(options)];
   try {