@zappie/verify 0.2.9 → 0.3.1

package/dist/index.js

@@ -9,6 +9,7 @@ import {
   requestWithRetry,
   resolveSourceMenu,
   stableErrorCode,
+  sumMoney,
   validateConfig,
   validateLine
 } from "./chunk-CW3HI5TY.js";
@@ -287,7 +288,37 @@ function supportsTypeScriptImport(version = process.versions.node) {
   const [major = 0, minor = 0] = version.split(".").map(Number);
   return major > 22 || major === 22 && minor >= 18;
 }
-async function readStore(cwd) {
+async function readProjectSettings(cwd, { required }) {
+  let value;
+  try {
+    value = await loadConfig(cwd);
+  } catch (error) {
+    if (required) {
+      throw error;
+    }
+    const exists = await stat2(path2.join(cwd, "zappie.config.ts")).then(
+      () => true,
+      () => false
+    );
+    return exists && error instanceof VerifyError ? { ignored: error.message } : {};
+  }
+  const config = record(value) ? value : {};
+  const verify2 = record(config.verify) ? config.verify : {};
+  const settings = {
+    ...typeof config.store === "string" ? { store: config.store } : {},
+    ...verify2.startPath !== void 0 ? { startPath: verify2.startPath } : {},
+    ...verify2.cataloguePath !== void 0 ? { cataloguePath: verify2.cataloguePath } : {}
+  };
+  if (required && settings.store === void 0) {
+    throw new VerifyError(
+      "store_missing",
+      "zappie.config.ts must define a store",
+      "Define store in zappie.config.ts or pass --store."
+    );
+  }
+  return settings;
+}
+async function loadConfig(cwd) {
   if (!supportsTypeScriptImport()) {
     throw new VerifyError(
       "unsupported_node",
@@ -300,10 +331,7 @@ async function readStore(cwd) {
     const version = (await stat2(file)).mtimeMs;
     await readFile2(file, "utf8");
     const loaded = await import(`${pathToFileURL(file).href}?verify=${version}`);
-    const value = loaded.default;
-    if (value && typeof value === "object" && "store" in value && typeof value.store === "string") {
-      return value.store;
-    }
+    return loaded.default;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new VerifyError(
@@ -312,12 +340,8 @@ async function readStore(cwd) {
       "Create a readable zappie.config.ts or pass --store."
     );
   }
-  throw new VerifyError(
-    "store_missing",
-    "zappie.config.ts must define a store",
-    "Define store in zappie.config.ts or pass --store."
-  );
 }
+var record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 
 // src/runner.ts
 import {
@@ -327,6 +351,53 @@ import {
 import { mkdir } from "fs/promises";
 import path3 from "path";
 
+// src/paths.ts
+var DEFAULT_START_PATH = "/";
+var ROUTE = /^\/(?!\/)[^\\]*$/;
+var SITE = "http://site.invalid";
+function isRoute(path4) {
+  return typeof path4 === "string" && ROUTE.test(path4) && new URL(path4, SITE).origin === SITE;
+}
+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 or /menu?menu={menu}."
+    );
+  }
+  if (cataloguePath !== void 0 && (!isRoute(cataloguePath) || !cataloguePath.includes("{menu}"))) {
+    throw new VerifyError(
+      "invalid_catalogue_path",
+      `The catalogue path ${JSON.stringify(cataloguePath)} is not a route with {menu}`,
+      "Set verify.cataloguePath to a route that starts with one / and puts {menu} where the menu id goes, such as /menu?menu={menu}."
+    );
+  }
+}
+function cataloguePage(cataloguePath, menuId, branchId) {
+  return cataloguePath.replaceAll("{menu}", encodeURIComponent(menuId)).replaceAll("{branch}", encodeURIComponent(branchId));
+}
+function isAtPath(url, path4) {
+  let current;
+  try {
+    current = new URL(url);
+  } catch {
+    return false;
+  }
+  if (current.protocol !== "http:" && current.protocol !== "https:") {
+    return false;
+  }
+  const wanted = new URL(path4, current);
+  return current.pathname === wanted.pathname && (wanted.search === "" || current.search === wanted.search);
+}
+
 // src/cpu.ts
 var REFERENCE_CPU_BENCHMARK = 26e3;
 var REFERENCE_CPU_THROTTLING_RATE = 4;
@@ -384,7 +455,7 @@ async function benchmarkCpu(browser) {
 }
 
 // src/checks/common.ts
-async function open(page, path4 = "/") {
+async function open(page, path4) {
   const response = await page.goto(path4, { waitUntil: "domcontentloaded" });
   assertion(
     response?.status() === 200,
@@ -554,8 +625,8 @@ async function dialogConfirm(page, confirm) {
 }
 
 // src/checks/routes.ts
-async function publicRoutePaths(request, baseUrl) {
-  const paths = /* @__PURE__ */ new Set(["/"]);
+async function publicRoutePaths(request, baseUrl, start = "/") {
+  const paths = /* @__PURE__ */ new Set(["/", start]);
   const sitemap = await request.get(new URL("/sitemap.xml", baseUrl).href);
   if (sitemap.ok()) {
     for (const match of (await sitemap.text()).matchAll(
@@ -583,7 +654,11 @@ var v01 = {
     };
     page.on("pageerror", onPageError);
     page.on("console", onConsole);
-    for (const path4 of await publicRoutePaths(page.request, options.url)) {
+    for (const path4 of await publicRoutePaths(
+      page.request,
+      options.url,
+      startPath(options)
+    )) {
       await open(page, path4);
     }
     page.off("pageerror", onPageError);
@@ -604,7 +679,7 @@ var v02 = {
   viewports: "mobile",
   async run({ page, options }, viewport) {
     await page.setViewportSize(viewport);
-    await open(page);
+    await open(page, startPath(options));
     const debug = await debugValue(page, () => ({
       store: window.__zappie?.store,
       version: window.__zappie?.version
@@ -660,6 +735,95 @@ async function installFault(page, fault) {
       await route.fulfill({ response, headers });
     });
   }
+  if (fault === "catalogue-directory") {
+    await page.route(
+      (url) => url.pathname === "/" && !url.searchParams.has("menu"),
+      async (route) => {
+        if (route.request().resourceType() !== "document") {
+          await route.continue();
+          return;
+        }
+        const response = await route.fetch();
+        const headers = { ...response.headers() };
+        delete headers["content-length"];
+        delete headers["content-encoding"];
+        await route.fulfill({
+          response,
+          headers: { ...headers, "content-type": "text/html; charset=utf-8" },
+          body: [
+            '<!doctype html><html lang="en"><head><meta charset="utf-8">',
+            '<meta name="viewport" content="width=device-width, initial-scale=1">',
+            "<title>Choose a menu</title></head><body><main>",
+            "<h1>Choose a menu</h1><ul>",
+            '<li><a href="/?menu=menu_all_day">All day</a></li>',
+            '<li><a href="/?menu=menu_treats">Treats</a></li>',
+            "</ul></main></body></html>"
+          ].join("")
+        });
+      }
+    );
+  }
+  if (fault === "catalogue-gap") {
+    await page.addInitScript(() => {
+      new MutationObserver(() => {
+        if (new URLSearchParams(location.search).get("menu") !== "menu_treats") {
+          return;
+        }
+        for (const node of document.querySelectorAll(
+          '[data-zappie-item="item_zobo"]'
+        )) {
+          node.remove();
+        }
+      }).observe(document, { childList: true, subtree: true });
+    });
+  }
+  if (fault === "oversized" || fault === "late-chunk") {
+    const large = randomScript("__verifyLarge", 26e4);
+    await page.route(
+      "**/__verify-large.js",
+      (route) => route.fulfill({ contentType: "text/javascript", body: large })
+    );
+  }
+  if (fault === "oversized") {
+    await page.route(
+      (url) => url.pathname === "/",
+      async (route) => {
+        if (route.request().resourceType() !== "document") {
+          await route.continue();
+          return;
+        }
+        const response = await route.fetch();
+        const headers = { ...response.headers() };
+        delete headers["content-length"];
+        delete headers["content-encoding"];
+        await route.fulfill({
+          response,
+          headers,
+          body: (await response.text()).replace(
+            "</head>",
+            '<script defer src="/__verify-large.js"></script></head>'
+          )
+        });
+      }
+    );
+  }
+  if (fault === "late-chunk") {
+    await page.route(
+      "**/__verify-late.js",
+      (route) => route.fulfill({
+        contentType: "text/javascript",
+        body: randomScript("__verifyLate", 46e4)
+      })
+    );
+    await page.addInitScript(() => {
+      window.addEventListener("load", () => {
+        setTimeout(() => {
+          const late = "/__verify-late.js";
+          void import(late);
+        }, 0);
+      });
+    });
+  }
   if (fault === "hydration-delay") {
     await page.route(/\.(?:js|mjs)(?:\?|$)/, async (route) => {
       await new Promise((resolve) => setTimeout(resolve, 3500));
@@ -738,7 +902,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");
@@ -1080,6 +1244,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(
@@ -1157,20 +1338,14 @@ async function applyPageFault(page, fault) {
       document.body.append(button);
     });
   }
-  if (fault === "oversized") {
-    let state = 1;
-    const payload = Array.from({ length: 26e4 }, () => {
-      state = state * 48271 % 2147483647;
-      return String.fromCharCode(33 + state % 90);
-    }).join("");
-    await page.route(
-      "**/__verify-large.js",
-      (route) => route.fulfill({
-        contentType: "text/javascript",
-        body: `window.__verifyLarge=${JSON.stringify(payload)}`
-      })
-    );
-  }
+}
+function randomScript(name, length) {
+  let state = 1;
+  const payload = Array.from({ length }, () => {
+    state = state * 48271 % 2147483647;
+    return String.fromCharCode(33 + state % 90);
+  }).join("");
+  return `window.${name}=${JSON.stringify(payload)}`;
 }
 
 // src/checks/catalogue.ts
@@ -1203,6 +1378,103 @@ function configurableItem(menu) {
     (item) => item.isAvailable && item.optionGroups.some((group) => group.required)
   );
 }
+function catalogues(menu) {
+  const sources = menu.menus?.length ? menu.menus : [
+    {
+      id: menu.id,
+      name: menu.name,
+      categoryIds: menu.categories.map((category) => category.id)
+    }
+  ];
+  return sources.map((source) => {
+    const ids = new Set(
+      menu.categories.filter((category) => source.categoryIds.includes(category.id)).flatMap((category) => category.itemIds)
+    );
+    return {
+      id: source.id,
+      name: source.name,
+      items: sortedItems(menu).filter((item) => ids.has(item.id))
+    };
+  }).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) }];
+  }
+  return pages.map((catalogue) => ({
+    path: cataloguePage(cataloguePath, catalogue.id, menu.branchId),
+    items: catalogue.items,
+    name: catalogue.name
+  }));
+}
+function itemPath(options, menu, itemId) {
+  const holder = options.cataloguePath && itemId ? catalogues(menu).find(
+    (catalogue) => catalogue.items.some((item) => item.id === itemId)
+  ) : void 0;
+  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) {
@@ -1217,6 +1489,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 = {
@@ -1226,54 +1508,72 @@ var v03 = {
   async run({ page, options, fault }, viewport) {
     const menu = await readMenu(options);
     await page.setViewportSize(viewport);
-    await open(page);
-    await applyPageFault(page, fault);
-    const items = sortedItems(menu);
-    const available = items.filter((item) => item.isAvailable);
-    const shownIds = /* @__PURE__ */ new Set();
-    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) {
-        shownIds.add(item.id);
-      }
-    }
-    const coverage = menuCoverage(items, shownIds);
-    assertion(
-      coverage.passes,
-      "menu_mismatch",
-      `The menu shows ${coverage.shown} of ${coverage.available} available items`,
-      "Render at least 95% of available menu items with data-zappie-item markers or visible names."
-    );
-    assertion(
-      await page.locator("[data-zappie-item]").count(),
-      "item_marker_missing",
-      "The menu has no item marker",
-      "Add data-zappie-item to each rendered menu item."
-    );
-    for (const item of items.filter((entry) => !entry.isAvailable)) {
-      const add = page.locator(
-        `[data-zappie-item="${item.id}"] [data-zappie-action="add-to-cart"]`
+    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(
+        page,
+        catalogue.items,
+        catalogue.name === void 0 ? "menu" : `${catalogue.name} menu at ${catalogue.path}`,
+        severalMenus
       );
-      if (await add.count()) {
-        assertion(
-          await add.isDisabled(),
-          "unavailable_item_addable",
-          `Shoppers can add the unavailable item ${item.name}`,
-          "Disable add-to-cart for unavailable items."
-        );
-      }
     }
-    for (const item of available.slice(0, 2)) {
-      const text = await page.locator(`[data-zappie-item="${item.id}"]`).first().textContent();
+  }
+};
+async function judgeCatalogue(page, items, menuName, severalMenus) {
+  const available = items.filter((item) => item.isAvailable);
+  const shownIds = /* @__PURE__ */ new Set();
+  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) {
+      shownIds.add(item.id);
+    }
+  }
+  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."
+  );
+  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}."
+  );
+  assertion(
+    await page.locator("[data-zappie-item]").count(),
+    "item_marker_missing",
+    `The ${menuName} has no item marker`,
+    "Add data-zappie-item to each rendered menu item."
+  );
+  for (const item of items.filter((entry) => !entry.isAvailable)) {
+    const add = page.locator(
+      `[data-zappie-item="${item.id}"] [data-zappie-action="add-to-cart"]`
+    );
+    if (await add.count()) {
       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."
+        await add.isDisabled(),
+        "unavailable_item_addable",
+        `Shoppers can add the unavailable item ${item.name}`,
+        "Disable add-to-cart for unavailable items."
       );
     }
   }
-};
+  for (const item of available.slice(0, 2)) {
+    const text = await page.locator(`[data-zappie-item="${item.id}"]`).first().textContent();
+    const prices = shownPrices(item);
+    assertion(
+      prices.some((price) => priceMatches(text, 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."
+    );
+  }
+}
 
 // src/checks/v04-add-simple.ts
 var v04 = {
@@ -1282,7 +1582,9 @@ var v04 = {
   viewports: "both",
   async run({ page, options, fault }, viewport) {
     await page.setViewportSize(viewport);
-    await open(page);
+    const menu = await readMenu(options);
+    const item = simpleItem(menu);
+    await open(page, itemPath(options, menu, item?.id));
     await applyPageFault(page, fault);
     const before = await debugValue(page, () => window.__zappie.cart().count);
     await page.evaluate(() => {
@@ -1293,7 +1595,6 @@ var v04 = {
         );
       });
     });
-    const item = simpleItem(await readMenu(options));
     assertion(
       item,
       "simple_item_missing",
@@ -1363,14 +1664,16 @@ 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",
   viewports: "both",
   async run({ page, options }, viewport) {
     await page.setViewportSize(viewport);
-    await open(page);
-    const selected = configurableItem(await readMenu(options));
+    const menu = await readMenu(options);
+    const selected = configurableItem(menu);
+    await open(page, itemPath(options, menu, selected?.id));
     assertion(
       selected,
       "required_item_missing",
@@ -1380,22 +1683,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);
@@ -1474,10 +1777,13 @@ var v06 = {
   id: "V06",
   title: "Cart quote and total",
   viewports: "both",
-  async run({ page }, viewport) {
+  async run({ page, options }, viewport) {
     await page.setViewportSize(viewport);
-    if (new URL(page.url()).pathname !== "/") {
-      await open(page);
+    const start = startPath(options);
+    const stay = isAtPath(page.url(), start) || start !== DEFAULT_START_PATH && await (await cartTrigger(page)).isVisible().catch(() => false);
+    if (!stay) {
+      await open(page, start);
+      await page.waitForFunction(() => Boolean(window.__zappie));
     }
     const total = page.locator("[data-zappie-total]").filter({ visible: true });
     const bagOpen = page.locator('[data-zappie-overlay="bag"]').filter({ visible: true });
@@ -1602,9 +1908,9 @@ var v07 = {
   id: "V07",
   title: "Handle quote issues",
   viewports: "mobile",
-  async run({ page }, viewport) {
+  async run({ page, options }, viewport) {
     await page.setViewportSize(viewport);
-    await open(page);
+    await open(page, startPath(options));
     await page.waitForFunction(() => window.__zappie?.cart().isHydrated);
     const debug = await page.evaluate(() => ({
       inject: typeof window.__zappie?.cart.inject === "function",
@@ -2226,7 +2532,7 @@ async function holdsFocus(target2) {
   return false;
 }
 var ADD = '[data-zappie-action="add-to-cart"]';
-async function keyboardReachesAddAndCart(page, itemId, cartInColumn) {
+async function keyboardReachesAddAndCart(page, itemId, itemPage, cartInColumn) {
   const cart = cartInColumn ? [] : [await cartTriggerSelector(page)];
   if (await page.locator(ADD).count() || !itemId) {
     return controlsAreReachable(page, [ADD, ...cart]);
@@ -2235,7 +2541,7 @@ async function keyboardReachesAddAndCart(page, itemId, cartInColumn) {
   if (cart.length && !await controlsAreReachable(page, cart)) {
     return false;
   }
-  await open(page);
+  await open(page, itemPage);
   if (!await tabTo(page, opener, 200)) {
     return false;
   }
@@ -2268,16 +2574,28 @@ var v13 = {
   viewports: "both",
   async run({ page, options, fault }, viewport) {
     await page.setViewportSize(viewport);
-    await open(page);
+    const menu = await readMenu(options);
+    const start = startPath(options);
+    await open(page, start);
     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
-    );
+    const item = sortedItems(menu).find((entry) => entry.isAvailable);
+    const itemPage = itemPath(options, menu, item?.id);
+    if (itemPage !== start) {
+      await open(page, itemPage);
+      await applyPageFault(page, fault);
+      violations.push(...await severeViolations(page));
+      semantics.push(
+        ...await semanticFindings(page, {
+          page: true,
+          phone: viewport.width < 768
+        })
+      );
+    }
     assertion(
       item,
       "available_item_missing",
@@ -2345,13 +2663,11 @@ var v13 = {
       order.map((entry) => entry.id).join(", ") || "Order page has a serious axe violation",
       "Fix serious and critical axe findings on the order page."
     );
-    await open(page);
+    const simple = simpleItem(menu)?.id;
+    const simplePage = itemPath(options, menu, simple);
+    await open(page, simplePage);
     assertion(
-      await keyboardReachesAddAndCart(
-        page,
-        simpleItem(await readMenu(options))?.id,
-        cartInColumn
-      ),
+      await keyboardReachesAddAndCart(page, simple, simplePage, 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."
@@ -2385,250 +2701,46 @@ var v13 = {
   }
 };
 
-// src/checks/v14-performance.ts
-var v14 = {
-  id: "V14",
-  title: "Performance budget",
-  viewports: "mobile",
-  async run({ page, metrics, fault, cpuThrottlingRate: cpuThrottlingRate2 }, viewport) {
-    await page.setViewportSize(viewport);
-    const { cdp } = await applyPhoneProfile(page, cpuThrottlingRate2);
-    await page.addInitScript(() => {
-      const state = { lcp: 0, cls: 0 };
-      Object.assign(window, { __zappiePerformance: state });
-      new PerformanceObserver((list) => {
-        state.lcp = Math.max(
-          state.lcp,
-          ...list.getEntries().map((entry) => entry.startTime)
-        );
-      }).observe({ type: "largest-contentful-paint", buffered: true });
-      new PerformanceObserver((list) => {
-        state.cls += list.getEntries().filter(
-          (entry) => !entry.hadRecentInput
-        ).reduce(
-          (sum, entry) => sum + (entry.value ?? 0),
-          0
-        );
-      }).observe({ type: "layout-shift", buffered: true });
-    });
-    await page.goto("/", { waitUntil: "load" });
-    await applyPageFault(page, fault);
-    if (fault === "oversized") {
-      await page.addScriptTag({ url: "/__verify-large.js" });
+// 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 });
     }
-    await page.locator("[data-zappie-item]").first().waitFor();
-    await page.waitForTimeout(500);
-    const values = await page.evaluate(async () => {
-      const observed = window.__zappiePerformance ?? { lcp: 0, cls: 0 };
-      const resources = performance.getEntriesByType("resource");
-      const gzipped = async (entry) => {
-        if (typeof CompressionStream === "undefined") {
-          const timing = entry;
-          return timing.encodedBodySize || timing.transferSize;
+  }
+  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 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(
-      values.js <= 200 * 1024,
-      "bundle_too_large",
-      `Menu uses ${values.js} B of gzipped JavaScript`,
-      "Split route code until the menu transfers at most 200 KiB of JavaScript."
-    );
-    assertion(
-      values.lcp <= 2500,
-      "lcp_too_slow",
-      `Menu LCP was ${Math.round(values.lcp)} ms`,
-      "Reduce critical rendering work until mobile LCP is at most 2.5 seconds."
-    );
-    assertion(
-      values.cls <= 0.1,
-      "cls_too_high",
-      `Menu CLS was ${values.cls.toFixed(3)}`,
-      "Reserve layout space so CLS stays at or below 0.1."
-    );
-    await cdp.detach();
-  }
-};
-
-// src/checks/v15-tappable-product-cards.ts
-var TAPPABLE_BUDGET_MS = 3e3;
-var OPEN_BUDGET_MS = 300;
-var v15 = {
-  id: "V15",
-  title: "Tappable product cards",
-  viewports: "mobile",
-  async run({ page, metrics, cpuThrottlingRate: cpuThrottlingRate2 }, viewport) {
-    await page.setViewportSize(viewport);
-    const { cdp } = await applyPhoneProfile(page, cpuThrottlingRate2);
-    try {
-      await page.goto("/", { waitUntil: "domcontentloaded" });
-      await cdp.send("Network.setCacheDisabled", { cacheDisabled: false });
-      const link = page.locator('a[href*="/item/"]').first();
-      await link.waitFor();
-      const href = await link.getAttribute("href");
-      assertion(
-        href !== null,
-        "product_card_link_missing",
-        "The first product card has no destination",
-        "Link the product card to its item page."
-      );
-      const itemPath = new URL(href, page.url()).pathname;
-      await page.waitForFunction(() => "__reactRouterManifest" in window, null, {
-        timeout: 8e3
-      }).catch(() => void 0);
-      const itemModule = await page.evaluate(itemRouteModule, itemPath);
-      const prefetched = page.waitForResponse(
-        (response) => {
-          const path4 = new URL(response.url()).pathname;
-          if (path4 === itemModule) {
-            return true;
-          }
-          return path4 === `${itemPath}.data` && response.request().headers()["sec-purpose"] === "prefetch";
-        },
-        { timeout: 8e3 }
-      ).then(async (response) => {
-        await response.finished();
-        return true;
-      }).catch(() => false);
-      await link.evaluate(
-        (node) => node.scrollIntoView({ block: "center", inline: "nearest" })
-      );
-      await page.waitForFunction(() => {
-        const candidate = document.querySelector('a[href*="/item/"]');
-        return candidate !== null && Object.keys(candidate).some(
-          (key) => key.startsWith("__reactProps$") || key.startsWith("__reactFiber$")
-        );
-      });
-      const tappableMs = await page.evaluate(() => performance.now());
-      metrics.productCardTappableMs = Math.round(tappableMs);
-      assertion(
-        tappableMs <= TAPPABLE_BUDGET_MS,
-        "product_card_tappable_too_late",
-        `The first product card became tappable in ${Math.round(tappableMs)} ms`,
-        "Reduce critical scripts, fonts and high-priority images until product cards become tappable within 3 seconds."
-      );
-      assertion(
-        await prefetched,
-        "product_card_prefetch_missing",
-        "The first product card did not prefetch its item page",
-        'Prefetch item links with prefetch="viewport".'
-      );
-      await page.waitForLoadState("networkidle");
-      await page.evaluate(() => {
-        document.addEventListener(
-          "click",
-          (event) => {
-            const target2 = event.target;
-            if (target2?.closest('a[href*="/item/"]')) {
-              window.__zappieTapAt = performance.now();
-            }
-          },
-          { capture: true, once: true }
-        );
-      });
-      await link.click({ noWaitAfter: true });
-      await Promise.race([
-        page.waitForURL((url) => /\/item\//.test(url.pathname)),
-        page.locator('[role="dialog"] [data-zappie-item]').waitFor({ state: "visible" })
-      ]);
-      const openMs = await page.evaluate(
-        () => performance.now() - (window.__zappieTapAt ?? 0)
-      );
-      metrics.productCardOpenMs = Math.round(openMs);
-      assertion(
-        openMs <= OPEN_BUDGET_MS,
-        "product_card_open_too_slow",
-        `The first product card opened in ${Math.round(openMs)} ms`,
-        'Set routeDiscovery to initial and prefetch item links with prefetch="viewport" so the item surface opens within 300 ms.'
-      );
-    } finally {
-      await cdp.detach();
-    }
-  }
-};
-function itemRouteModule(itemPath) {
-  const manifest = window.__reactRouterManifest;
-  if (!manifest) {
-    return void 0;
-  }
-  const segments = (path4) => path4.split("/").filter(Boolean);
-  const fullPath = (route2) => {
-    const parts = [];
-    for (let current = route2; current; current = current.parentId ? manifest.routes[current.parentId] : void 0) {
-      if (current.path) {
-        parts.unshift(current.path);
-      }
-    }
-    return segments(parts.join("/"));
-  };
-  const wanted = segments(itemPath);
-  const route = Object.values(manifest.routes).find((entry) => {
-    if (!entry.path) {
-      return false;
-    }
-    const pattern = fullPath(entry);
-    return pattern.length === wanted.length && pattern.every(
-      (part, index) => part.startsWith(":") || part === wanted[index]
-    );
-  });
-  return route ? new URL(route.module, location.href).pathname : void 0;
-}
-
-// src/checks/overlays.ts
-var OVERLAY_NAMES = ["bag", "branch", "search", "item"];
-var IDLE_FALLBACK_MS = 2e3;
-var NETWORK_QUIET_MS = 500;
-var SETTLE_ROUNDS = 3;
-var SETTLE_TIMEOUT_MS = 15e3;
-var triggerSelector = (name) => `[data-zappie-overlay-trigger="${name}"]`;
-var overlaySelector = (name) => `[data-zappie-overlay="${name}"]`;
-var markersHint = 'Add data-zappie-overlay-trigger="bag", "branch", "search" or "item" to each control that opens that overlay, and data-zappie-overlay with the same name on its role="dialog" element. Until the menu has them, this check is skipped.';
-async function overlayTriggers(page) {
-  const found = [];
-  for (const name of OVERLAY_NAMES) {
-    const trigger = page.locator(`${triggerSelector(name)}:visible`).first();
-    if (await trigger.count() > 0) {
-      found.push({ name, trigger });
-    }
-  }
-  return found;
-}
-function skipWithoutTriggers(found) {
-  if (found.length === 0) {
-    skipCheck(
-      "overlay_markers_missing",
-      "The menu has no data-zappie-overlay-trigger controls",
-      markersHint
-    );
-  }
-}
-function armOverlayTimer(page, name, timeoutMs) {
-  return page.evaluate(
-    ({ selector, timeout }) => {
-      const state = {};
-      Object.assign(window, { __zappieOverlayTimer: state });
-      const visible = () => {
-        const node = document.querySelector(selector);
-        if (!(node instanceof HTMLElement)) {
-          return false;
-        }
-        const box = node.getBoundingClientRect();
-        return box.width > 0 && box.height > 0 && node.checkVisibility();
+        const box = node.getBoundingClientRect();
+        return box.width > 0 && box.height > 0 && node.checkVisibility();
       };
       document.addEventListener(
         "click",
@@ -2719,10 +2831,10 @@ function hydrated() {
     )
   );
 }
-async function openSettledMenu(page) {
+async function openSettledMenu(page, start) {
   const network = watchNetwork(page);
   try {
-    await page.goto("/", { waitUntil: "domcontentloaded" });
+    await page.goto(start, { 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);
@@ -2755,11 +2867,17 @@ async function openSettledMenu(page) {
     network.stop();
   }
 }
-async function revealBagTrigger(page, itemId) {
+async function revealBagTrigger(page, start, item) {
   const bag = page.locator(`${triggerSelector("bag")}:visible`).first();
-  if (!itemId || await bag.count()) {
+  if (!item || await bag.count()) {
     return;
   }
+  const itemId = item.id;
+  const marked = page.locator(`[data-zappie-item="${itemId}"]`);
+  if (item.path !== start && !await marked.count()) {
+    await page.goto(item.path, { waitUntil: "domcontentloaded" });
+    await marked.first().waitFor({ timeout: 5e3 }).catch(() => void 0);
+  }
   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();
@@ -2787,9 +2905,253 @@ async function revealBagTrigger(page, itemId) {
     before,
     { timeout: 5e3 }
   ).catch(() => void 0);
-  await openSettledMenu(page);
+  await openSettledMenu(page, start);
   await bag.waitFor({ timeout: 5e3 }).catch(() => void 0);
 }
+function bagItem(options, menu) {
+  const id = simpleItem(menu)?.id;
+  return {
+    start: startPath(options),
+    item: id ? { id, path: itemPath(options, menu, id) } : void 0
+  };
+}
+
+// src/checks/v14-performance.ts
+var LOADED_JS_BUDGET_KB = 350;
+var LOADED_WAIT_MS = 1e4;
+var v14 = {
+  id: "V14",
+  title: "Performance budget",
+  viewports: "mobile",
+  async run({ page, options, metrics, fault, cpuThrottlingRate: cpuThrottlingRate2 }, viewport) {
+    await page.setViewportSize(viewport);
+    const { cdp } = await applyPhoneProfile(page, cpuThrottlingRate2);
+    await page.addInitScript(() => {
+      const state = { lcp: 0, cls: 0, documentScripts: [] };
+      Object.assign(window, { __zappiePerformance: state });
+      document.addEventListener("DOMContentLoaded", () => {
+        state.documentScripts = [
+          ...[
+            ...document.querySelectorAll("script[src]")
+          ].map((node) => node.src),
+          ...[
+            ...document.querySelectorAll(
+              'link[rel="modulepreload"][href], link[rel="preload"][as="script"][href]'
+            )
+          ].map((node) => node.href)
+        ];
+      });
+      new PerformanceObserver((list) => {
+        state.lcp = Math.max(
+          state.lcp,
+          ...list.getEntries().map((entry) => entry.startTime)
+        );
+      }).observe({ type: "largest-contentful-paint", buffered: true });
+      new PerformanceObserver((list) => {
+        state.cls += list.getEntries().filter(
+          (entry) => !entry.hadRecentInput
+        ).reduce(
+          (sum, entry) => sum + (entry.value ?? 0),
+          0
+        );
+      }).observe({ type: "layout-shift", buffered: true });
+    });
+    const network = watchNetwork(page);
+    await page.goto(startPath(options), { waitUntil: "load" });
+    await applyPageFault(page, fault);
+    await page.locator("[data-zappie-item]").first().waitFor();
+    await page.waitForTimeout(500);
+    await network.quiet(Date.now() + LOADED_WAIT_MS);
+    network.stop();
+    const values = await page.evaluate(async () => {
+      const observed = window.__zappiePerformance ?? {
+        lcp: 0,
+        cls: 0,
+        documentScripts: []
+      };
+      const resources = performance.getEntriesByType("resource");
+      const named = new Set(observed.documentScripts);
+      const needed = (entry) => named.has(entry.name);
+      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, counted = () => true) => (await Promise.all(
+        resources.filter(
+          (entry) => new URL(entry.name).pathname.endsWith(extension) && counted(entry)
+        ).map(gzipped)
+      )).reduce((sum, size) => sum + size, 0);
+      return {
+        lcp: observed.lcp,
+        cls: observed.cls,
+        js: await total(".js", needed),
+        loadedJs: await total(".js"),
+        css: await total(".css")
+      };
+    });
+    metrics.menuJsKbGz = Math.round(values.js / 1024 * 10) / 10;
+    metrics.menuJsLoadedKbGz = Math.round(values.loadedJs / 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(
+      values.js <= 200 * 1024,
+      "bundle_too_large",
+      `Menu uses ${values.js} B of gzipped JavaScript`,
+      "Split route code until the menu transfers at most 200 KiB of JavaScript."
+    );
+    assertion(
+      values.loadedJs <= LOADED_JS_BUDGET_KB * 1024,
+      "loaded_js_too_large",
+      `The menu loads ${values.loadedJs} B of gzipped JavaScript in all, counting what it imports after it starts`,
+      `Load what the menu imports after it starts only when a shopper needs it, until the menu loads at most ${LOADED_JS_BUDGET_KB} KiB of JavaScript in all.`
+    );
+    assertion(
+      values.lcp <= 2500,
+      "lcp_too_slow",
+      `Menu LCP was ${Math.round(values.lcp)} ms`,
+      "Reduce critical rendering work until mobile LCP is at most 2.5 seconds."
+    );
+    assertion(
+      values.cls <= 0.1,
+      "cls_too_high",
+      `Menu CLS was ${values.cls.toFixed(3)}`,
+      "Reserve layout space so CLS stays at or below 0.1."
+    );
+    await cdp.detach();
+  }
+};
+
+// src/checks/v15-tappable-product-cards.ts
+var TAPPABLE_BUDGET_MS = 3e3;
+var OPEN_BUDGET_MS = 300;
+var v15 = {
+  id: "V15",
+  title: "Tappable product cards",
+  viewports: "mobile",
+  async run({ page, options, metrics, cpuThrottlingRate: cpuThrottlingRate2 }, viewport) {
+    await page.setViewportSize(viewport);
+    const { cdp } = await applyPhoneProfile(page, cpuThrottlingRate2);
+    try {
+      await page.goto(startPath(options), { waitUntil: "domcontentloaded" });
+      await cdp.send("Network.setCacheDisabled", { cacheDisabled: false });
+      const link = page.locator('a[href*="/item/"]').first();
+      await link.waitFor();
+      const href = await link.getAttribute("href");
+      assertion(
+        href !== null,
+        "product_card_link_missing",
+        "The first product card has no destination",
+        "Link the product card to its item page."
+      );
+      const itemPath2 = new URL(href, page.url()).pathname;
+      await page.waitForFunction(() => "__reactRouterManifest" in window, null, {
+        timeout: 8e3
+      }).catch(() => void 0);
+      const itemModule = await page.evaluate(itemRouteModule, itemPath2);
+      const prefetched = page.waitForResponse(
+        (response) => {
+          const path4 = new URL(response.url()).pathname;
+          if (path4 === itemModule) {
+            return true;
+          }
+          return path4 === `${itemPath2}.data` && response.request().headers()["sec-purpose"] === "prefetch";
+        },
+        { timeout: 8e3 }
+      ).then(async (response) => {
+        await response.finished();
+        return true;
+      }).catch(() => false);
+      await link.evaluate(
+        (node) => node.scrollIntoView({ block: "center", inline: "nearest" })
+      );
+      await page.waitForFunction(() => {
+        const candidate = document.querySelector('a[href*="/item/"]');
+        return candidate !== null && Object.keys(candidate).some(
+          (key) => key.startsWith("__reactProps$") || key.startsWith("__reactFiber$")
+        );
+      });
+      const tappableMs = await page.evaluate(() => performance.now());
+      metrics.productCardTappableMs = Math.round(tappableMs);
+      assertion(
+        tappableMs <= TAPPABLE_BUDGET_MS,
+        "product_card_tappable_too_late",
+        `The first product card became tappable in ${Math.round(tappableMs)} ms`,
+        "Reduce critical scripts, fonts and high-priority images until product cards become tappable within 3 seconds."
+      );
+      assertion(
+        await prefetched,
+        "product_card_prefetch_missing",
+        "The first product card did not prefetch its item page",
+        'Prefetch item links with prefetch="viewport".'
+      );
+      await page.waitForLoadState("networkidle");
+      await page.evaluate(() => {
+        document.addEventListener(
+          "click",
+          (event) => {
+            const target2 = event.target;
+            if (target2?.closest('a[href*="/item/"]')) {
+              window.__zappieTapAt = performance.now();
+            }
+          },
+          { capture: true, once: true }
+        );
+      });
+      await link.click({ noWaitAfter: true });
+      await Promise.race([
+        page.waitForURL((url) => /\/item\//.test(url.pathname)),
+        page.locator('[role="dialog"] [data-zappie-item]').waitFor({ state: "visible" })
+      ]);
+      const openMs = await page.evaluate(
+        () => performance.now() - (window.__zappieTapAt ?? 0)
+      );
+      metrics.productCardOpenMs = Math.round(openMs);
+      assertion(
+        openMs <= OPEN_BUDGET_MS,
+        "product_card_open_too_slow",
+        `The first product card opened in ${Math.round(openMs)} ms`,
+        'Set routeDiscovery to initial and prefetch item links with prefetch="viewport" so the item surface opens within 300 ms.'
+      );
+    } finally {
+      await cdp.detach();
+    }
+  }
+};
+function itemRouteModule(itemPath2) {
+  const manifest = window.__reactRouterManifest;
+  if (!manifest) {
+    return void 0;
+  }
+  const segments = (path4) => path4.split("/").filter(Boolean);
+  const fullPath = (route2) => {
+    const parts = [];
+    for (let current = route2; current; current = current.parentId ? manifest.routes[current.parentId] : void 0) {
+      if (current.path) {
+        parts.unshift(current.path);
+      }
+    }
+    return segments(parts.join("/"));
+  };
+  const wanted = segments(itemPath2);
+  const route = Object.values(manifest.routes).find((entry) => {
+    if (!entry.path) {
+      return false;
+    }
+    const pattern = fullPath(entry);
+    return pattern.length === wanted.length && pattern.every(
+      (part, index) => part.startsWith(":") || part === wanted[index]
+    );
+  });
+  return route ? new URL(route.module, location.href).pathname : void 0;
+}
 
 // src/checks/v16-overlays-open-quickly.ts
 var OVERLAY_OPEN_BUDGET_MS = 100;
@@ -2804,15 +3166,15 @@ 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) {
+async function firstOpen(fresh, viewport, name, cpuThrottlingRate2, start, item) {
   const { page } = fresh;
   try {
     await page.setViewportSize(viewport);
     const { cdp, rate } = await applyPhoneProfile(page, cpuThrottlingRate2);
     try {
-      await openSettledMenu(page);
+      await openSettledMenu(page, start);
       if (name === "bag") {
-        await revealBagTrigger(page, itemId);
+        await revealBagTrigger(page, start, item);
       }
       const trigger = page.locator(`${triggerSelector(name)}:visible`).first();
       await trigger.evaluate(
@@ -2835,9 +3197,9 @@ var v16 = {
   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 { start, item } = bagItem(options, await readMenu(options));
+    await openSettledMenu(page, start);
+    await revealBagTrigger(page, start, item);
     const names = (await overlayTriggers(page)).map(({ name }) => name);
     skipWithoutTriggers(names);
     const timings = {};
@@ -2854,7 +3216,8 @@ var v16 = {
           viewport,
           name,
           cpuThrottlingRate2,
-          itemId
+          start,
+          item
         );
         if (open2 === void 0) {
           opened = false;
@@ -2922,10 +3285,10 @@ var scrollLocked = (page) => page.evaluate(() => {
   };
   return held(document.documentElement) || held(document.body);
 });
-async function checkOverlay(page, name, itemId) {
-  await openSettledMenu(page);
+async function checkOverlay(page, name, start, item) {
+  await openSettledMenu(page, start);
   if (name === "bag") {
-    await revealBagTrigger(page, itemId);
+    await revealBagTrigger(page, start, item);
   }
   const trigger = page.locator(`${triggerSelector(name)}:visible`).first();
   await trigger.focus();
@@ -3006,12 +3369,12 @@ var v17 = {
   viewports: "mobile",
   async run({ page, options, freshPage }, viewport) {
     await page.setViewportSize(viewport);
-    const itemId = simpleItem(await readMenu(options))?.id;
-    await page.goto("/", { waitUntil: "domcontentloaded" });
+    const { start, item } = bagItem(options, await readMenu(options));
+    await page.goto(start, { 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);
+      await openSettledMenu(page, start);
+      await revealBagTrigger(page, start, item);
     }
     const names = (await overlayTriggers(page)).map(({ name }) => name);
     skipWithoutTriggers(names);
@@ -3020,7 +3383,7 @@ var v17 = {
       const fresh = await freshPage();
       try {
         await fresh.page.setViewportSize(viewport);
-        findings.push(...await checkOverlay(fresh.page, name, itemId));
+        findings.push(...await checkOverlay(fresh.page, name, start, item));
       } finally {
         await fresh.close();
       }
@@ -3056,7 +3419,11 @@ var v18 = {
   async run({ page, options, warn }, viewport) {
     await page.setViewportSize(viewport);
     let reportOnlyFound = false;
-    for (const path4 of await publicRoutePaths(page.request, options.url)) {
+    for (const path4 of await publicRoutePaths(
+      page.request,
+      options.url,
+      startPath(options)
+    )) {
       const response = await page.goto(new URL(path4, options.url).href, {
         waitUntil: "domcontentloaded"
       });
@@ -3220,6 +3587,7 @@ function printSummary(report) {
     return `${check.result.toUpperCase().padEnd(7)} ${check.id} ${check.title}${suffix}${warnings}`;
   });
   lines.push(
+    ...(report.warnings ?? []).map((warning) => `WARNING: ${warning.message}`),
     `${report.result.toUpperCase()}: ${report.summary.passed} passed, ${report.summary.failed} failed, ${report.summary.skipped} skipped`,
     report.signature ? "Report signed (ed25519)." : "Report unsigned."
   );
@@ -3273,7 +3641,7 @@ async function reset(options) {
 }
 
 // src/version.ts
-var PACKAGE_VERSION = true ? "0.2.9" : "0.0.0-development";
+var PACKAGE_VERSION = true ? "0.3.1" : "0.0.0-development";
 
 // src/runner.ts
 var VERSION = PACKAGE_VERSION;
@@ -3398,14 +3766,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(input);
+  const options = await fillStartOptions(input);
   const wanted = options.only ? expandOnly(options.only, knownCheckIds()) : void 0;
   const started = Date.now();
   const executablePath = browserExecutable(options);
@@ -3470,13 +3840,17 @@ async function runVerify(options, fault) {
         sdkVersion,
         browser: `chromium ${browser.version()}${executablePath ? ` (${executablePath})` : ""}`,
         ...cpuBenchmark === void 0 ? {} : { cpuBenchmark },
-        cpuThrottlingRate: throttlingRate
+        cpuThrottlingRate: throttlingRate,
+        startPath: startPath(options),
+        ...options.startPath !== input.startPath ? { startPathTemplate: input.startPath } : {},
+        ...options.cataloguePath ? { cataloguePath: options.cataloguePath } : {}
       },
       startedAt: new Date(started).toISOString(),
       durationMs: Date.now() - started,
       result: summary.failed ? "failed" : "passed",
       summary,
       checks: results,
+      ...options.warnings?.length ? { warnings: options.warnings } : {},
       metrics
     };
     return signReport(
@@ -3496,7 +3870,16 @@ async function runVerify(options, fault) {
 
 // src/project.ts
 async function verifyProject(options) {
-  const store = options.store ?? await readStore(options.cwd);
+  const settings = options.store && options.startPath && options.cataloguePath ? {} : 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.`
+    }
+  ] : [];
+  const cataloguePath = options.cataloguePath ?? settings.cataloguePath;
   let preview;
   try {
     preview = options.url ? void 0 : await startLocalPreview({
@@ -3515,6 +3898,9 @@ async function verifyProject(options) {
       suite: options.suite,
       runner: options.runner ?? "cli",
       ...options.only ? { only: options.only } : {},
+      ...startPath2 !== void 0 ? { startPath: startPath2 } : {},
+      ...cataloguePath !== void 0 ? { cataloguePath } : {},
+      ...warnings.length ? { warnings } : {},
       ...options.viewports ? { viewports: options.viewports } : {},
       ...options.artifactsDir ? { artifactsDir: options.artifactsDir } : {},
       ...options.timeoutMs ? { timeoutMs: options.timeoutMs } : {},
@@ -3550,6 +3936,8 @@ function normalizeUrl(value) {
 // src/regression.ts
 var DEFAULT_REGRESSION_THRESHOLDS = {
   menuJsKbGz: { relative: 0.05, absolute: 2 },
+  // What idle and intent preloads fetch varies a little between runs, so its allowance is wider.
+  menuJsLoadedKbGz: { relative: 0.1, absolute: 10 },
   menuCssKbGz: { relative: 0.05, absolute: 1 },
   lcpMs: { relative: 0.1, absolute: 150 },
   cls: { relative: 0, absolute: 0.02 },