@zappie/verify 0.1.5 → 0.2.3

package/dist/index.js

@@ -11,14 +11,15 @@ import {
   stableErrorCode,
   validateConfig,
   validateLine
-} from "./chunk-JYFSFOIS.js";
+} 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";
   }
 };
@@ -27,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";
@@ -265,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" });
@@ -285,7 +348,9 @@ async function debugValue(page, expression) {
 }
 var mobile = { width: 390, height: 844 };
 var desktop = { width: 1440, height: 900 };
-async function applyPhoneProfile(page) {
+async function applyPhoneProfile(page, fallbackRate) {
+  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 });
@@ -296,8 +361,144 @@ async function applyPhoneProfile(page) {
     uploadThroughput: 1e5,
     connectionType: "cellular3g"
   });
-  await cdp.send("Emulation.setCPUThrottlingRate", { rate: 4 });
-  return cdp;
+  await cdp.send("Emulation.setCPUThrottlingRate", { rate });
+  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
@@ -369,6 +570,7 @@ var v02 = {
 };
 
 // src/fixtures.ts
+var preparedPages = /* @__PURE__ */ new WeakMap();
 async function installFault(page, fault) {
   if (!fault) {
     return;
@@ -391,6 +593,361 @@ async function installFault(page, fault) {
       await route.continue();
     });
   }
+  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 });
+    });
+  }
+  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(() => {
+        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 });
+    });
+  }
+  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();
+    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 }
+      );
+    });
+    await page.route(
+      /\/assets\/cart-drawer-[^/]*\.js(?:\?|$)/,
+      async (route) => {
+        await tapped;
+        await route.continue().catch(() => {
+        });
+      }
+    );
+  }
+  if (fault === "one-slow-open") {
+    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 }
+        );
+      });
+    }
+  }
+  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()}`
+        });
+      }
+    );
+  }
+  if (fault === "late-idle") {
+    await page.addInitScript(() => {
+      const request = window.requestIdleCallback?.bind(window);
+      const cancel = window.cancelIdleCallback?.bind(window);
+      if (!request || !cancel) {
+        return;
+      }
+      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);
+      };
+    });
+  }
+  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"]
+      });
+    });
+  }
   if (fault === "quick-add-via-item") {
     await page.addInitScript(() => {
       const removeQuickAdds = () => {
@@ -484,6 +1041,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) {
@@ -719,11 +1292,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",
@@ -732,23 +1305,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(),
@@ -776,6 +1367,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 = {
@@ -787,9 +1394,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"),
@@ -803,11 +1421,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."
     );
   }
@@ -942,7 +1570,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();
@@ -1265,14 +1893,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
@@ -1316,10 +1958,154 @@ 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 = 24;
+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 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) => requestAnimationFrame(
+        () => requestAnimationFrame(() => requestAnimationFrame(resolve))
+      )
+    )
+  );
+  await page.evaluate(
+    () => Promise.race([
+      Promise.all(
+        document.getAnimations().filter(
+          (animation) => animation.effect?.getComputedTiming().iterations !== Infinity
+        ).map((animation) => animation.finished.catch(() => void 0))
+      ),
+      new Promise((resolve) => setTimeout(resolve, 2e3))
+    ])
+  );
   const analysis = await new AxeBuilder({ page }).analyze();
   return analysis.violations.filter(
     (entry) => entry.impact === "critical" || entry.impact === "serious"
@@ -1343,15 +2129,47 @@ 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 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);
+}
 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);
     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
     );
@@ -1361,11 +2179,27 @@ 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 { focusTarget: card } = await openItem(page, item.id);
     violations.push(...await severeViolations(page));
-    await page.getByRole("button", { name: "Close item" }).click();
-    await page.locator("[data-zappie-cart-trigger]").first().click();
+    semantics.push(
+      ...await semanticFindings(page, { page: false, phone: false })
+    );
+    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 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 })
+    );
     const message = violations.flatMap(
       (entry) => entry.nodes.map((node) => `${entry.id}: ${node.target.join(" ")}`)
     ).join(", ");
@@ -1375,15 +2209,29 @@ 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");
-    await context.addCookies([
-      {
-        name: "zappie_session",
-        value: "signed",
-        domain: new URL(page.url()).hostname,
-        path: "/"
-      }
-    ]);
+    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"
+      });
+    }
+    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 signIn(page);
     await open(page, "/orders/order_fixture");
     const order = await severeViolations(page);
     assertion(
@@ -1394,16 +2242,25 @@ 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 phone = await revealField(
+      page,
+      "phone",
+      page.locator('input[type="tel"]')
+    );
+    await phone.fill("+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
     );
@@ -1421,9 +2278,9 @@ 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 applyPhoneProfile(page);
+    const { cdp } = await applyPhoneProfile(page, cpuThrottlingRate2);
     await page.addInitScript(() => {
       const state = { lcp: 0, cls: 0 };
       Object.assign(window, { __zappiePerformance: state });
@@ -1451,24 +2308,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(
@@ -1500,9 +2360,9 @@ var v15 = {
   id: "V15",
   title: "Tappable product cards",
   viewports: "mobile",
-  async run({ page, metrics }, viewport) {
+  async run({ page, metrics, cpuThrottlingRate: cpuThrottlingRate2 }, viewport) {
     await page.setViewportSize(viewport);
-    const cdp = await applyPhoneProfile(page);
+    const { cdp } = await applyPhoneProfile(page, cpuThrottlingRate2);
     try {
       await page.goto("/", { waitUntil: "domcontentloaded" });
       await cdp.send("Network.setCacheDisabled", { cacheDisabled: false });
@@ -1617,6 +2477,446 @@ function itemRouteModule(itemPath) {
   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();
+  }
+}
+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;
+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)];
+};
+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, options, metrics, freshPage, cpuThrottlingRate: cpuThrottlingRate2 }, viewport) {
+    await page.setViewportSize(viewport);
+    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;
+    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."
+    );
+  }
+};
+
+// 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, 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");
+  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, 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) {
+      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) {
+      throw new VerifyError(
+        first.code,
+        findings.map(({ message }) => message).join(". "),
+        [...new Set(findings.map(({ hint }) => hint))].join(" ")
+      );
+    }
+  }
+};
+
 // src/checks/index.ts
 var checks = [
   v01,
@@ -1630,7 +2930,9 @@ var checks = [
   v10,
   v13,
   v14,
-  v15
+  v15,
+  v16,
+  v17
 ];
 var blocked = [
   [
@@ -1762,7 +3064,7 @@ async function reset(options) {
 }
 
 // src/version.ts
-var PACKAGE_VERSION = true ? "0.1.5" : "0.0.0-development";
+var PACKAGE_VERSION = true ? "0.2.3" : "0.0.0-development";
 
 // src/runner.ts
 var VERSION = PACKAGE_VERSION;
@@ -1811,7 +3113,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,
@@ -1843,6 +3145,37 @@ async function execute(check, run2) {
   }
 }
 var label = (viewport) => `${viewport.width}x${viewport.height}`;
+async function openContext(browser, options) {
+  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
+          })
+        });
+      }
+    );
+  }
+  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(
@@ -1853,17 +3186,11 @@ async function runVerify(options, fault) {
   }
   const started = Date.now();
   const browser = await chromium.launch();
-  const context = await browser.newContext(browserOptions(options));
-  if (options.standInForPlatform) {
-    await context.route(
-      "**/_zappie/view",
-      (route) => route.fulfill({ status: 204 })
-    );
-  }
+  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 context.newPage();
-  page.setDefaultTimeout(Math.min(options.timeoutMs ?? 2e4, 2e4));
-  await installFault(page, fault);
+  const page = await preparePage(context, options, fault);
   const metrics = {};
   const run2 = {
     options,
@@ -1871,7 +3198,15 @@ async function runVerify(options, fault) {
     context,
     page,
     metrics,
-    ...fault ? { fault } : {}
+    cpuThrottlingRate: throttlingRate,
+    ...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 {
@@ -1899,7 +3234,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,
@@ -1971,12 +3308,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