@zappie/verify 0.3.0 → 0.3.2

package/dist/index.js

@@ -9,6 +9,7 @@ import {
   requestWithRetry,
   resolveSourceMenu,
   stableErrorCode,
+  sumMoney,
   validateConfig,
   validateLine
 } from "./chunk-CW3HI5TY.js";
@@ -279,6 +280,14 @@ function signal(child, value) {
   }
 }
 
+// ../sdk/src/site-config/types.ts
+var DEFAULT_BUDGETS = {
+  jsKbGz: 200,
+  cssKbGz: 50,
+  lcpMs: 2500,
+  tappableMs: 3e3
+};
+
 // src/project-config.ts
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
 import path2 from "path";
@@ -303,10 +312,15 @@ async function readProjectSettings(cwd, { required }) {
   }
   const config = record(value) ? value : {};
   const verify2 = record(config.verify) ? config.verify : {};
+  const budgets = record(config.budgets) ? config.budgets : {};
+  const override = record(budgets.override) ? budgets.override : {};
+  const tappableMs = budgets.tappableMs;
+  const explainedRaisedTappableBudget = typeof override.reason === "string" && override.reason.trim().length > 0;
   const settings = {
     ...typeof config.store === "string" ? { store: config.store } : {},
     ...verify2.startPath !== void 0 ? { startPath: verify2.startPath } : {},
-    ...verify2.cataloguePath !== void 0 ? { cataloguePath: verify2.cataloguePath } : {}
+    ...verify2.cataloguePath !== void 0 ? { cataloguePath: verify2.cataloguePath } : {},
+    ...typeof tappableMs === "number" && (tappableMs <= DEFAULT_BUDGETS.tappableMs || explainedRaisedTappableBudget) ? { tappableMs } : {}
   };
   if (required && settings.store === void 0) {
     throw new VerifyError(
@@ -360,13 +374,16 @@ function isRoute(path4) {
 function startPath(options) {
   return options.startPath ?? DEFAULT_START_PATH;
 }
+function hasPlaceholders(path4) {
+  return path4.includes("{menu}") || path4.includes("{branch}");
+}
 function checkPaths(options) {
   const { startPath: start, cataloguePath } = options;
   if (start !== void 0 && !isRoute(start)) {
     throw new VerifyError(
       "invalid_start_path",
       `The start path ${JSON.stringify(start)} is not a route on the site`,
-      "Set verify.startPath or --start to a route that starts with one /, such as /menu."
+      "Set verify.startPath or --start to a route that starts with one /, such as /menu or /menu?menu={menu}."
     );
   }
   if (cataloguePath !== void 0 && (!isRoute(cataloguePath) || !cataloguePath.includes("{menu}"))) {
@@ -898,7 +915,7 @@ async function installFault(page, fault) {
               return;
             }
             const group = original.closest('[role="dialog"]')?.querySelector(
-              '[data-zappie-option-group][aria-required="true"]:not(:has([data-state="checked"]))'
+              '[data-zappie-option-group]:is([data-zappie-required="true"], [aria-required="true"]):has([data-zappie-option]):not(:has([data-state="checked"]))'
             );
             if (flags && group) {
               group.setAttribute("aria-invalid", "true");
@@ -1240,6 +1257,23 @@ ${await response.text()}`
       });
     });
   }
+  if (fault === "from-price") {
+    await page.addInitScript(() => {
+      new MutationObserver(() => {
+        for (const node of document.querySelectorAll(
+          '[data-zappie-item="item_jollof"] .z-kit-money'
+        )) {
+          if (node.textContent !== "From \u20A65,000") {
+            node.textContent = "From \u20A65,000";
+          }
+        }
+      }).observe(document, {
+        childList: true,
+        subtree: true,
+        characterData: true
+      });
+    });
+  }
   if (fault === "add-stuck") {
     await page.addInitScript(() => {
       document.addEventListener(
@@ -1277,14 +1311,237 @@ ${await response.text()}`
       }).observe(document, { childList: true, subtree: true });
     });
   }
+  if (isMarkupFault(fault)) {
+    await page.addInitScript(keepMarkupFault, fault);
+  }
 }
-async function applyPageFault(page, fault) {
-  if (fault === "quick-add-via-item") {
-    await page.locator('[data-zappie-item] [data-zappie-action="add-to-cart"]').evaluateAll((nodes) => {
-      for (const node of nodes) {
-        node.remove();
+var markupFaults = [
+  "from-price",
+  "quick-add-via-item",
+  "missing-marker",
+  "hidden-marker-attribute",
+  "hidden-marker-display",
+  "hidden-marker-visibility",
+  "hidden-marker-aria",
+  "zero-size-marker",
+  "tiny-marker",
+  "clipped-marker",
+  "clip-path-marker",
+  "negative-coordinate-marker",
+  "popular-name-only-markers",
+  "marker-without-name",
+  "uppercase-marker-name",
+  "scrollable-markers",
+  "content-visibility-auto-markers",
+  "nfkc-marker-name",
+  "entity-marker-name",
+  "entity-apos-marker-name",
+  "entity-gt-marker-name",
+  "entity-lt-marker-name",
+  "entity-quot-marker-name",
+  "soft-hyphen-marker-name",
+  "zero-width-marker-name",
+  "axe"
+];
+function isMarkupFault(fault) {
+  return markupFaults.includes(fault);
+}
+function keepMarkupFault(fault) {
+  const outermost = "[data-zappie-item]:not([data-zappie-item] [data-zappie-item])";
+  const markers = () => document.querySelectorAll("[data-zappie-item]");
+  const setText = (node, text) => {
+    if (node && node.textContent !== text) {
+      node.textContent = text;
+    }
+  };
+  const styles = {
+    "hidden-marker-display": [["display", "none"]],
+    "hidden-marker-visibility": [["visibility", "hidden"]],
+    "zero-size-marker": [
+      ["border", "0"],
+      ["height", "0"],
+      ["margin", "0"],
+      ["min-height", "0"],
+      ["min-width", "0"],
+      ["overflow", "hidden"],
+      ["padding", "0"],
+      ["width", "0"]
+    ],
+    "tiny-marker": [
+      ["border", "0"],
+      ["height", "1px"],
+      ["min-height", "0"],
+      ["min-width", "0"],
+      ["overflow", "hidden"],
+      ["padding", "0"],
+      ["width", "1px"]
+    ],
+    "clipped-marker": [
+      ["clip", "rect(0 0 0 0)"],
+      ["position", "absolute"]
+    ],
+    "clip-path-marker": [["clip-path", "inset(50%)"]],
+    "negative-coordinate-marker": [
+      ["left", "-10000px"],
+      ["position", "absolute"],
+      ["top", "-10000px"]
+    ],
+    "uppercase-marker-name": [["text-transform", "uppercase"]]
+  };
+  const names = {
+    "nfkc-marker-name": "Jollof rice",
+    "entity-marker-name": "Jollof & rice",
+    "entity-apos-marker-name": "Jollof ' rice",
+    "entity-gt-marker-name": "Jollof > rice",
+    "entity-lt-marker-name": "Jollof < rice",
+    "entity-quot-marker-name": 'Jollof " rice',
+    "soft-hyphen-marker-name": "Jollof rice",
+    "zero-width-marker-name": "Jollof rice"
+  };
+  const apply = () => {
+    const style = styles[fault];
+    if (style) {
+      for (const node of markers()) {
+        for (const [property, value] of style) {
+          node.style.setProperty(property, value, "important");
+        }
       }
-    });
+    }
+    const name = names[fault];
+    if (name !== void 0) {
+      for (const node of document.querySelectorAll(
+        '[data-zappie-item="item_jollof"]'
+      )) {
+        setText(node.querySelector("h1, h2, h3"), name);
+      }
+    }
+    if (fault === "from-price") {
+      for (const node of document.querySelectorAll(
+        '[data-zappie-item="item_jollof"] .z-kit-money'
+      )) {
+        setText(node, "From \u20A65,000");
+      }
+    }
+    if (fault === "quick-add-via-item") {
+      for (const node of document.querySelectorAll(
+        '[data-zappie-item] [data-zappie-action="add-to-cart"]'
+      )) {
+        if (!node.closest('[data-zappie-overlay="item"], [role="dialog"]')) {
+          node.remove();
+        }
+      }
+    }
+    if (fault === "missing-marker") {
+      for (const node of markers()) {
+        node.removeAttribute("data-zappie-item");
+      }
+    }
+    if (fault === "hidden-marker-attribute") {
+      for (const node of markers()) {
+        if (!node.hasAttribute("hidden")) {
+          node.setAttribute("hidden", "");
+        }
+      }
+    }
+    if (fault === "hidden-marker-aria") {
+      for (const node of markers()) {
+        if (node.getAttribute("aria-hidden") !== "true") {
+          node.setAttribute("aria-hidden", "true");
+        }
+      }
+    }
+    if (fault === "marker-without-name") {
+      for (const heading of document.querySelectorAll(
+        "[data-zappie-item] h1, [data-zappie-item] h2, [data-zappie-item] h3"
+      )) {
+        heading.closest("[data-zappie-item]")?.before(heading);
+      }
+    }
+    if (fault === "popular-name-only-markers") {
+      const main = document.querySelector("main");
+      const cards = [
+        ...document.querySelectorAll("article[data-zappie-item]")
+      ].map((card) => ({
+        id: card.getAttribute("data-zappie-item") ?? "",
+        href: card.querySelector('a[href*="/item/"]')?.href ?? "#",
+        name: card.querySelector("h1, h2, h3")?.textContent ?? "Item"
+      }));
+      const key = JSON.stringify(cards);
+      const current = document.querySelector("[data-verify-popular]");
+      if (main && cards.length > 0 && (current?.getAttribute("data-verify-popular") !== key || main.firstElementChild !== current)) {
+        current?.remove();
+        const popular = document.createElement("section");
+        popular.setAttribute("data-verify-popular", key);
+        const heading = document.createElement("h2");
+        heading.textContent = "Popular";
+        popular.append(heading);
+        for (const card of cards) {
+          const link = document.createElement("a");
+          link.href = card.href;
+          link.setAttribute("data-zappie-item", card.id);
+          link.textContent = card.name;
+          popular.append(link);
+        }
+        main.prepend(popular);
+      }
+    }
+    if (fault === "scrollable-markers") {
+      for (const node of document.querySelectorAll(outermost)) {
+        if (node.parentElement?.hasAttribute("data-verify-scroll-track")) {
+          continue;
+        }
+        const scroller = document.createElement("div");
+        scroller.style.cssText = "height: 1px; overflow: auto; width: 1px";
+        const track = document.createElement("div");
+        track.setAttribute("data-verify-scroll-track", "");
+        track.style.cssText = "padding-left: 1000px; width: 2000px";
+        node.before(scroller);
+        scroller.append(track);
+        track.append(node);
+      }
+    }
+    if (fault === "content-visibility-auto-markers") {
+      const nodes = [...document.querySelectorAll(outermost)].filter(
+        (node) => !node.parentElement?.hasAttribute("data-verify-deferred")
+      );
+      if (nodes.length > 0) {
+        let section = document.querySelector("[data-verify-deferred]");
+        if (!section) {
+          section = document.createElement("section");
+          section.setAttribute("data-verify-deferred", "");
+          section.style.cssText = "content-visibility:auto;contain-intrinsic-size:auto 1000px;margin-top:10000px";
+          nodes[0]?.before(section);
+        }
+        section.append(...nodes);
+      }
+    }
+    if (fault === "axe" && document.body && !document.querySelector("[data-verify-axe]")) {
+      const button = document.createElement("button");
+      button.setAttribute("data-verify-axe", "");
+      button.style.color = "#fff";
+      button.style.background = "#fff";
+      document.body.append(button);
+    }
+  };
+  let started = false;
+  window.__verifyMarkupFault = () => {
+    started = true;
+    apply();
+  };
+  new MutationObserver(() => {
+    if (started) {
+      apply();
+    }
+  }).observe(document, { childList: true, subtree: true });
+}
+function pageHydrated() {
+  const hydrated2 = (node) => node !== null && Object.keys(node).some((key) => key.startsWith("__reactProps$"));
+  return hydrated2(document.body) && [...document.querySelectorAll("[data-zappie-item]")].every(hydrated2);
+}
+async function applyPageFault(page, fault) {
+  if (fault && isMarkupFault(fault)) {
+    await page.waitForFunction(pageHydrated);
+    await page.evaluate(() => window.__verifyMarkupFault?.());
   }
   if (fault === "card-link") {
     await page.waitForFunction(() => {
@@ -1302,21 +1559,6 @@ async function applyPageFault(page, fault) {
       }
     });
   }
-  if (fault === "missing-marker") {
-    await page.locator("[data-zappie-item]").evaluateAll((nodes) => {
-      for (const node of nodes) {
-        node.removeAttribute("data-zappie-item");
-      }
-    });
-  }
-  if (fault === "axe") {
-    await page.evaluate(() => {
-      const button = document.createElement("button");
-      button.style.color = "#fff";
-      button.style.background = "#fff";
-      document.body.append(button);
-    });
-  }
 }
 function randomScript(name, length) {
   let state = 1;
@@ -1376,8 +1618,43 @@ function catalogues(menu) {
     };
   }).filter((catalogue) => catalogue.items.length > 0);
 }
+function fillStartPath(template, menu) {
+  const first = catalogues(menu)[0]?.id ?? menu.menus?.[0]?.id ?? menu.id;
+  return { path: cataloguePage(template, first, menu.branchId), menuId: first };
+}
+var startMenus = /* @__PURE__ */ new WeakMap();
+async function fillStartOptions(options, read = readMenu) {
+  const template = options.startPath;
+  if (template === void 0 || !hasPlaceholders(template)) {
+    return options;
+  }
+  let filled;
+  try {
+    filled = fillStartPath(template, await read(options));
+  } catch (failure) {
+    if (failure instanceof VerifyError) {
+      throw failure;
+    }
+    throw new VerifyError(
+      "start_path_unfilled",
+      `Verify could not read the menu to fill the start path ${template}: ${failure instanceof Error ? failure.message : String(failure)}`,
+      "Check the store and key, or set a start path without {menu} or {branch}."
+    );
+  }
+  checkPaths({ startPath: filled.path });
+  const result = { ...options, startPath: filled.path };
+  if (template.includes("{menu}")) {
+    startMenus.set(result, filled.menuId);
+  }
+  return result;
+}
 function cataloguePages(options, menu) {
   const { cataloguePath } = options;
+  const startMenu = startMenus.get(options);
+  const shown = !cataloguePath && startMenu !== void 0 ? catalogues(menu).find((catalogue) => catalogue.id === startMenu) : void 0;
+  if (shown) {
+    return [{ path: startPath(options), items: shown.items, name: shown.name }];
+  }
   const pages = cataloguePath ? catalogues(menu) : [];
   if (!cataloguePath || pages.length === 0) {
     return [{ path: startPath(options), items: sortedItems(menu) }];
@@ -1395,6 +1672,31 @@ function itemPath(options, menu, itemId) {
   return holder && options.cataloguePath ? cataloguePage(options.cataloguePath, holder.id, menu.branchId) : startPath(options);
 }
 
+// ../sdk/src/pricing/index.ts
+var cheapest = (prices) => prices.filter((price) => price.amountMinor >= 0).sort((a, b) => a.amountMinor - b.amountMinor)[0];
+function startingPrice(item) {
+  const available = item.variants.filter((variant) => variant.isAvailable);
+  const base = cheapest(
+    (available.length ? available : item.variants).map(
+      (variant) => variant.price
+    )
+  ) ?? item.price;
+  return sumMoney(
+    item.optionGroups.flatMap(
+      (group) => !group.isAttribute && group.required && group.kind === "select" ? cheapest(group.choices.map((choice) => choice.price)) ?? [] : []
+    ),
+    base
+  );
+}
+function showsFromPrice(item) {
+  const prices = [
+    ...new Set(
+      item.variants.filter((variant) => variant.isAvailable).map((variant) => variant.price.amountMinor)
+    )
+  ];
+  return prices.length > 1 || prices.length === 1 && startingPrice(item).amountMinor > prices[0];
+}
+
 // src/checks/menu-match.ts
 function menuCoverage(items, shownIds) {
   const available = items.filter((item) => item.isAvailable);
@@ -1408,6 +1710,16 @@ function menuCoverage(items, shownIds) {
 function priceMatches(text, formatted) {
   return text?.includes(formatted) ?? false;
 }
+function shownPrices(item) {
+  const prices = [format.money(item.price)];
+  if (showsFromPrice(item)) {
+    const from = format.money(startingPrice(item));
+    if (from !== prices[0]) {
+      prices.push(from);
+    }
+  }
+  return prices;
+}
 
 // src/checks/v03-menu.ts
 var v03 = {
@@ -1417,8 +1729,9 @@ var v03 = {
   async run({ page, options, fault }, viewport) {
     const menu = await readMenu(options);
     await page.setViewportSize(viewport);
-    const severalMenus = !options.cataloguePath && catalogues(menu).length > 1;
-    for (const catalogue of cataloguePages(options, menu)) {
+    const pages = cataloguePages(options, menu);
+    const severalMenus = !options.cataloguePath && pages[0]?.name === void 0 && catalogues(menu).length > 1;
+    for (const catalogue of pages) {
       await open(page, catalogue.path);
       await applyPageFault(page, fault);
       await judgeCatalogue(
@@ -1433,24 +1746,46 @@ var v03 = {
 async function judgeCatalogue(page, items, menuName, severalMenus) {
   const available = items.filter((item) => item.isAvailable);
   const shownIds = /* @__PURE__ */ new Set();
+  const markerText = /* @__PURE__ */ new Map();
   for (const item of available) {
     const marker = page.locator(`[data-zappie-item="${item.id}"]`);
-    if (await marker.count() > 0 || await page.getByText(item.name, { exact: true }).count() > 0) {
+    const text = await visibleMarkerText(marker);
+    markerText.set(item.id, text);
+    const prices = shownPrices(item);
+    if (text.some(
+      (value) => nameMatches(value, item.name) && prices.some((price) => priceMatches(value, normalizeText(price)))
+    ) || await marker.count() === 0 && await page.getByText(item.name, { exact: true }).filter({ visible: true }).count() > 0) {
       shownIds.add(item.id);
     }
   }
+  for (const item of available) {
+    if (shownIds.has(item.id)) {
+      continue;
+    }
+    const text = markerText.get(item.id)?.find((value) => nameMatches(value, item.name));
+    if (text === void 0) {
+      continue;
+    }
+    const prices = shownPrices(item);
+    assertion(
+      prices.some((price) => priceMatches(text, normalizeText(price))),
+      "price_mismatch",
+      `${item.name} does not show ${prices.join(" or From ")}`,
+      "Render prices with format.money from @zappie/sdk, and a From price with startingPrice from @zappie/sdk/pricing."
+    );
+  }
   const coverage = menuCoverage(items, shownIds);
   assertion(
     coverage.passes || severalMenus,
     "menu_mismatch",
     `The ${menuName} shows ${coverage.shown} of ${coverage.available} available items`,
-    "Render at least 95% of available menu items with data-zappie-item markers or visible names."
+    "Render at least 95% of available menu items with visible data-zappie-item markers that contain their name and price, or visible names when no marker exists."
   );
   assertion(
     coverage.passes,
     "menu_mismatch",
     `The ${menuName} shows ${coverage.shown} of ${coverage.available} available items`,
-    "Render at least 95% of available menu items with data-zappie-item markers or visible names. If each menu has its own page, set verify.cataloguePath, such as /menu?menu={menu}."
+    "Render at least 95% of available menu items with visible data-zappie-item markers that contain their name and price, or visible names when no marker exists. If each menu has its own page, set verify.cataloguePath, such as /menu?menu={menu}."
   );
   assertion(
     await page.locator("[data-zappie-item]").count(),
@@ -1471,15 +1806,95 @@ async function judgeCatalogue(page, items, menuName, severalMenus) {
       );
     }
   }
-  for (const item of available.slice(0, 2)) {
-    const text = await page.locator(`[data-zappie-item="${item.id}"]`).first().textContent();
-    assertion(
-      priceMatches(text, format.money(item.price)),
-      "price_mismatch",
-      `${item.name} does not show ${format.money(item.price)}`,
-      "Render prices with format.money from @zappie/sdk."
-    );
-  }
+}
+function nameMatches(text, name) {
+  return text.includes(normalizeText(decodeBasicEntities(name)));
+}
+function normalizeText(value) {
+  return value.normalize("NFKC").replace(/[\u00ad\u200b-\u200d\u2060\ufeff]/g, "").replace(/\s+/g, " ").trim().toLocaleLowerCase();
+}
+function decodeBasicEntities(value) {
+  const entities = {
+    amp: "&",
+    apos: "'",
+    gt: ">",
+    lt: "<",
+    quot: '"'
+  };
+  return value.replace(
+    /&(amp|apos|gt|lt|quot);/gi,
+    (entity) => entities[entity.slice(1, -1).toLowerCase()] ?? entity
+  );
+}
+async function visibleMarkerText(marker) {
+  const text = await marker.evaluateAll(
+    (nodes) => nodes.flatMap((node) => {
+      for (let current = node; current; current = current.parentElement) {
+        const ariaHidden = current.getAttribute("aria-hidden")?.trim().toLowerCase();
+        const style = getComputedStyle(current);
+        if (current.hasAttribute("hidden") || ariaHidden === "true" || style.display === "none" || style.visibility === "hidden" || style.visibility === "collapse" || style.contentVisibility === "hidden" || fullyClipped(current, style)) {
+          return [];
+        }
+      }
+      const hasBox = [...node.getClientRects()].some((box) => {
+        const documentRight = box.right + window.scrollX;
+        const documentBottom = box.bottom + window.scrollY;
+        return box.width >= 2 && box.height >= 2 && documentRight > 0 && documentBottom > 0;
+      });
+      if (!hasBox) {
+        return [];
+      }
+      const text2 = node.textContent;
+      return text2 === null ? [] : [text2];
+      function fullyClipped(element, style) {
+        const box = element.getBoundingClientRect();
+        const clip = style.clip.match(
+          /^rect\((auto|-?[\d.]+px)[, ]+(auto|-?[\d.]+px)[, ]+(auto|-?[\d.]+px)[, ]+(auto|-?[\d.]+px)\)$/
+        );
+        if (clip) {
+          const top2 = length(clip[1], 0);
+          const right2 = length(clip[2], box.width);
+          const bottom2 = length(clip[3], box.height);
+          const left2 = length(clip[4], 0);
+          if (right2 <= left2 || bottom2 <= top2) {
+            return true;
+          }
+        }
+        const clipPath = style.clipPath;
+        if (/^(circle|ellipse)\(0(?:px|%)?(?:\s|\))/i.test(clipPath)) {
+          return true;
+        }
+        const inset = clipPath.match(/^inset\(([^)]+)\)/i);
+        if (!inset) {
+          return false;
+        }
+        const values = inset[1].split(/\s+/).slice(0, 4).map(
+          (value, index) => insetLength(value, index % 2 ? box.width : box.height)
+        );
+        if (values.some((value) => value === void 0)) {
+          return false;
+        }
+        const top = values[0];
+        const right = values.length === 1 ? top : values[1];
+        const bottom = values.length < 3 ? top : values[2];
+        const left = values.length < 4 ? right : values[3];
+        return top + bottom >= box.height || right + left >= box.width;
+      }
+      function length(value, fallback) {
+        return value === "auto" || value === void 0 ? fallback : Number.parseFloat(value);
+      }
+      function insetLength(value, dimension) {
+        if (value.endsWith("%")) {
+          return Number.parseFloat(value) / 100 * dimension;
+        }
+        if (value.endsWith("px") || value === "0") {
+          return Number.parseFloat(value);
+        }
+        return void 0;
+      }
+    })
+  );
+  return text.map(normalizeText);
 }
 
 // src/checks/v04-add-simple.ts
@@ -1571,6 +1986,7 @@ var v04 = {
 };
 
 // src/checks/v05-add-options.ts
+var REQUIRED_GROUP = '[data-zappie-option-group]:is([data-zappie-required="true"], [aria-required="true"])';
 var v05 = {
   id: "V05",
   title: "Add an item with required options",
@@ -1589,22 +2005,22 @@ var v05 = {
     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();
+    const required = dialog.locator(REQUIRED_GROUP).first();
     await required.waitFor({ timeout: 5e3 }).catch(() => void 0);
     assertion(
       await required.count(),
       "required_group_missing",
       "The item dialog has no marked required option group",
-      "Expose required groups through data-zappie-option-group and aria-required."
+      "Mark each option group with data-zappie-option-group and each required one with data-zappie-required, as OptionGroup from @zappie/foundations does."
     );
     const before = await debugValue(page, () => window.__zappie.cart().count);
     const add = dialog.locator('[data-zappie-action="add-to-cart"]');
     const unsatisfied = dialog.locator(
-      '[data-zappie-option-group][aria-required="true"]:not(:has([data-state="checked"]))'
+      `${REQUIRED_GROUP}:has([data-zappie-option]):not(:has([data-state="checked"]))`
     );
     const blocked2 = await add.isDisabled();
-    if (!blocked2) {
-      const group = unsatisfied.first();
+    const group = unsatisfied.first();
+    if (!blocked2 && await group.count() > 0) {
       const textBefore = (await group.innerText().catch(() => "")).trim();
       await add.click();
       await page.waitForTimeout(500);
@@ -2936,13 +3352,20 @@ var v14 = {
 };
 
 // src/checks/v15-tappable-product-cards.ts
-var TAPPABLE_BUDGET_MS = 3e3;
 var OPEN_BUDGET_MS = 300;
+function tappableBudgetMs(configured) {
+  if (configured === void 0 || !Number.isFinite(configured)) {
+    return DEFAULT_BUDGETS.tappableMs;
+  }
+  return Math.min(5e3, Math.max(DEFAULT_BUDGETS.tappableMs, configured));
+}
 var v15 = {
   id: "V15",
   title: "Tappable product cards",
   viewports: "mobile",
   async run({ page, options, metrics, cpuThrottlingRate: cpuThrottlingRate2 }, viewport) {
+    const limitMs = tappableBudgetMs(options.tappableMs);
+    metrics.productCardTappableLimitMs = limitMs;
     await page.setViewportSize(viewport);
     const { cdp } = await applyPhoneProfile(page, cpuThrottlingRate2);
     try {
@@ -2987,10 +3410,10 @@ var v15 = {
       const tappableMs = await page.evaluate(() => performance.now());
       metrics.productCardTappableMs = Math.round(tappableMs);
       assertion(
-        tappableMs <= TAPPABLE_BUDGET_MS,
+        tappableMs <= limitMs,
         "product_card_tappable_too_late",
-        `The first product card became tappable in ${Math.round(tappableMs)} ms`,
-        "Reduce critical scripts, fonts and high-priority images until product cards become tappable within 3 seconds."
+        `The first product card became tappable in ${Math.round(tappableMs)} ms; the site limit is ${limitMs} ms`,
+        "Reduce critical scripts, fonts and high-priority images until product cards meet the site's tappable limit."
       );
       assertion(
         await prefetched,
@@ -3547,7 +3970,7 @@ async function reset(options) {
 }
 
 // src/version.ts
-var PACKAGE_VERSION = true ? "0.3.0" : "0.0.0-development";
+var PACKAGE_VERSION = true ? "0.3.2" : "0.0.0-development";
 
 // src/runner.ts
 var VERSION = PACKAGE_VERSION;
@@ -3672,15 +4095,16 @@ async function preparePage(context, options, fault) {
   await installFault(page, fault);
   return page;
 }
-async function runVerify(options, fault) {
-  if (!/^pk_test_.+/.test(options.key)) {
+async function runVerify(input, fault) {
+  if (!/^pk_test_.+/.test(input.key)) {
     throw new VerifyError(
       "live_key_refused",
       "Verify accepts only pk_test_ keys",
       "Create a test publishable key and rerun verify."
     );
   }
-  checkPaths(options);
+  checkPaths(input);
+  const options = await fillStartOptions(input);
   const wanted = options.only ? expandOnly(options.only, knownCheckIds()) : void 0;
   const started = Date.now();
   const executablePath = browserExecutable(options);
@@ -3747,6 +4171,7 @@ async function runVerify(options, fault) {
         ...cpuBenchmark === void 0 ? {} : { cpuBenchmark },
         cpuThrottlingRate: throttlingRate,
         startPath: startPath(options),
+        ...options.startPath !== input.startPath ? { startPathTemplate: input.startPath } : {},
         ...options.cataloguePath ? { cataloguePath: options.cataloguePath } : {}
       },
       startedAt: new Date(started).toISOString(),
@@ -3774,16 +4199,17 @@ async function runVerify(options, fault) {
 
 // src/project.ts
 async function verifyProject(options) {
-  const settings = options.store && options.startPath && options.cataloguePath ? {} : await readProjectSettings(options.cwd, { required: !options.store });
+  const settings = options.store && options.startPath && options.cataloguePath && options.tappableMs !== void 0 ? {} : await readProjectSettings(options.cwd, { required: !options.store });
   const store = options.store ?? settings.store;
   const startPath2 = options.startPath ?? settings.startPath;
   const warnings = "ignored" in settings && settings.ignored ? [
     {
       code: "config_settings_ignored",
-      message: `${settings.ignored}, so verify ran without its verify.startPath and verify.cataloguePath. Fix zappie.config.ts, or pass the start path with --start.`
+      message: `${settings.ignored}, so verify ran without its route settings or tappable budget. Fix zappie.config.ts before rerunning verify.`
     }
   ] : [];
   const cataloguePath = options.cataloguePath ?? settings.cataloguePath;
+  const tappableMs = options.tappableMs ?? settings.tappableMs;
   let preview;
   try {
     preview = options.url ? void 0 : await startLocalPreview({
@@ -3804,6 +4230,7 @@ async function verifyProject(options) {
       ...options.only ? { only: options.only } : {},
       ...startPath2 !== void 0 ? { startPath: startPath2 } : {},
       ...cataloguePath !== void 0 ? { cataloguePath } : {},
+      ...tappableMs !== void 0 ? { tappableMs } : {},
       ...warnings.length ? { warnings } : {},
       ...options.viewports ? { viewports: options.viewports } : {},
       ...options.artifactsDir ? { artifactsDir: options.artifactsDir } : {},