@zappie/verify 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,4049 @@
+import {
+  ZappieError,
+  asError,
+  format,
+  hours,
+  isBoolean,
+  isString,
+  list,
+  mapItem,
+  mapMenu,
+  mapMoney,
+  money,
+  multiplyMoney,
+  opt,
+  payloadKey,
+  record,
+  sumMoney,
+  text,
+  wireError
+} from "./chunk-WUWUDCYO.js";
+
+// src/error.ts
+var VerifyError = class extends Error {
+  constructor(code, message, hint) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+    this.name = "VerifyError";
+  }
+};
+function assertion(condition, code, message, hint) {
+  if (!condition) {
+    throw new VerifyError(code, message, hint);
+  }
+}
+
+// src/local-preview.ts
+import { spawn } from "child_process";
+import { readFile } from "fs/promises";
+import path from "path";
+
+// src/project-command.ts
+import { createServer } from "net";
+function execArgs(manager, binary, args) {
+  if (manager === "npm") {
+    return { executable: "npm", args: ["exec", "--no", "--", binary, ...args] };
+  }
+  if (manager === "yarn") {
+    return { executable: "yarn", args: ["exec", binary, ...args] };
+  }
+  if (manager === "bun") {
+    return { executable: "bun", args: ["x", "--no-install", binary, ...args] };
+  }
+  return { executable: "pnpm", args: ["exec", binary, ...args] };
+}
+function freePort() {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      server.close(
+        () => typeof address === "object" && address ? resolve(address.port) : reject(new Error("No free port was assigned."))
+      );
+    });
+  });
+}
+var outputTail = (value) => value.trim().split("\n").slice(-12).join("\n");
+
+// src/local-preview.ts
+async function startLocalPreview(options) {
+  const manifest = JSON.parse(
+    await readFile(path.join(options.cwd, "package.json"), "utf8")
+  );
+  const packages = { ...manifest.dependencies, ...manifest.devDependencies };
+  const framework = packages["react-router"] ? "react-router" : packages.vite ? "vite" : void 0;
+  if (!framework || framework === "react-router" && !packages.wrangler) {
+    throw new VerifyError(
+      "preview_unsupported",
+      "Local verify supports React Router on Cloudflare and Vite. Pass a URL for this project.",
+      "Pass the deployed or externally started preview URL to zappie verify."
+    );
+  }
+  await run(
+    options,
+    execArgs(options.packageManager, framework, ["build"]),
+    "build"
+  );
+  const port = await freePort();
+  const command = previewCommand(options, framework, port);
+  const child = spawn(command.executable, command.args, {
+    cwd: options.cwd,
+    env: options.environment ?? process.env,
+    detached: process.platform !== "win32",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let output = "";
+  child.stdout?.on("data", (value) => output += String(value));
+  child.stderr?.on("data", (value) => output += String(value));
+  const abort = () => void stop(child);
+  options.signal?.addEventListener("abort", abort, { once: true });
+  const url = `http://127.0.0.1:${port}`;
+  try {
+    await ready(url, child, options.signal, () => output);
+  } catch (error) {
+    await stop(child);
+    options.signal?.removeEventListener("abort", abort);
+    throw error;
+  }
+  return {
+    url,
+    close: async () => {
+      options.signal?.removeEventListener("abort", abort);
+      await stop(child);
+    }
+  };
+}
+function previewCommand(options, framework, port) {
+  if (framework === "vite") {
+    return execArgs(options.packageManager, "vite", [
+      "preview",
+      "--host",
+      "127.0.0.1",
+      "--port",
+      String(port),
+      "--strictPort"
+    ]);
+  }
+  const args = [
+    "dev",
+    "--port",
+    String(port),
+    "--ip",
+    "127.0.0.1",
+    "--inspector-port",
+    "0",
+    "--no-show-interactive-dev-session"
+  ];
+  for (const [name, value] of Object.entries({
+    ZAPPIE_KEY: options.key,
+    ZAPPIE_STORE: options.store,
+    ZAPPIE_API: options.environment?.ZAPPIE_API ?? process.env.ZAPPIE_API,
+    ZAPPIE_BRANCH: options.environment?.ZAPPIE_BRANCH ?? process.env.ZAPPIE_BRANCH,
+    ZAPPIE_IMAGES: options.environment?.ZAPPIE_IMAGES ?? process.env.ZAPPIE_IMAGES
+  })) {
+    if (value) {
+      args.push("--var", `${name}:${value}`);
+    }
+  }
+  return execArgs(options.packageManager, "wrangler", args);
+}
+async function run(options, command, label2) {
+  const child = spawn(command.executable, command.args, {
+    cwd: options.cwd,
+    env: options.environment ?? process.env,
+    signal: options.signal,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let output = "";
+  child.stdout.on("data", (value) => output += String(value));
+  child.stderr.on("data", (value) => output += String(value));
+  const code = await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("close", (value) => resolve(value ?? 1));
+  });
+  if (code !== 0) {
+    throw new VerifyError(
+      `${label2}_failed`,
+      `${label2} failed:
+${outputTail(output)}`,
+      `Fix the project ${label2} and rerun verify.`
+    );
+  }
+}
+async function ready(url, child, signal2, output) {
+  const expires = Date.now() + 6e4;
+  while (Date.now() < expires) {
+    signal2?.throwIfAborted();
+    if (child.exitCode !== null) {
+      throw new VerifyError(
+        "preview_exited",
+        `Preview exited before it was ready:
+${outputTail(output())}`,
+        "Run the project preview directly and fix its startup error."
+      );
+    }
+    try {
+      const response = await fetch(url, signal2 ? { signal: signal2 } : {});
+      if (response.status < 500) {
+        return;
+      }
+    } catch (error) {
+      if (signal2?.aborted) {
+        throw error;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new VerifyError(
+    "preview_timeout",
+    `Preview did not become ready:
+${outputTail(output())}`,
+    "Make the preview answer on its assigned port within 60 seconds."
+  );
+}
+async function stop(child) {
+  if (child.exitCode !== null || !child.pid) {
+    return;
+  }
+  signal(child, "SIGTERM");
+  await Promise.race([
+    new Promise((resolve) => child.once("close", resolve)),
+    new Promise((resolve) => setTimeout(resolve, 2e3))
+  ]);
+  if (child.exitCode === null) {
+    signal(child, "SIGKILL");
+  }
+}
+function signal(child, value) {
+  try {
+    if (process.platform === "win32") {
+      child.kill(value);
+    } else if (child.pid) {
+      process.kill(-child.pid, value);
+    }
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "ESRCH")) {
+      throw error;
+    }
+  }
+}
+
+// src/project-config.ts
+import { readFile as readFile2, stat } from "fs/promises";
+import path2 from "path";
+import { pathToFileURL } from "url";
+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) {
+  if (!supportsTypeScriptImport()) {
+    throw new VerifyError(
+      "unsupported_node",
+      "zappie verify needs Node 22.18 or later to read zappie.config.ts",
+      "Use Node 22.18 or later, or pass --store."
+    );
+  }
+  const file = path2.join(cwd, "zappie.config.ts");
+  try {
+    const version = (await stat(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;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new VerifyError(
+      "config_unreadable",
+      `Could not read zappie.config.ts: ${message}`,
+      "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."
+  );
+}
+
+// src/runner.ts
+import { chromium, errors } from "@playwright/test";
+import { mkdir } from "fs/promises";
+import path3 from "path";
+
+// src/checks/common.ts
+async function open(page, path4 = "/") {
+  const response = await page.goto(path4, { waitUntil: "domcontentloaded" });
+  assertion(
+    response?.status() === 200,
+    "route_not_rendered",
+    `${path4} answered ${response?.status() ?? "without a response"}`,
+    "Make the route return a 200 response and render its page shell."
+  );
+}
+async function debugValue(page, expression) {
+  await page.waitForFunction(() => Boolean(window.__zappie));
+  return page.evaluate(expression);
+}
+var mobile = { width: 390, height: 844 };
+var desktop = { width: 1440, height: 900 };
+
+// src/checks/v01-routes.ts
+var v01 = {
+  id: "V01",
+  title: "Routes render",
+  viewports: "both",
+  async run({ page, options }, viewport) {
+    await page.setViewportSize(viewport);
+    const errors2 = [];
+    const onPageError = (error) => errors2.push(error.message);
+    const onConsole = (message) => {
+      if (message.type() === "error" && !/favicon.*404/i.test(message.text())) {
+        errors2.push(message.text());
+      }
+    };
+    page.on("pageerror", onPageError);
+    page.on("console", onConsole);
+    const paths = /* @__PURE__ */ new Set(["/"]);
+    const sitemap = await page.request.get(
+      new URL("/sitemap.xml", options.url).href
+    );
+    if (sitemap.ok()) {
+      for (const match of (await sitemap.text()).matchAll(
+        /<loc>([^<]+)<\/loc>/g
+      )) {
+        paths.add(new URL(match[1]).pathname);
+      }
+    }
+    for (const path4 of [...paths].sort()) {
+      await open(page, path4);
+    }
+    page.off("pageerror", onPageError);
+    page.off("console", onConsole);
+    assertion(
+      errors2.length === 0,
+      "page_error",
+      errors2[0] ?? "A route logged an error",
+      "Fix uncaught page errors and console errors on every public route."
+    );
+  }
+};
+
+// src/checks/v02-sdk.ts
+var v02 = {
+  id: "V02",
+  title: "SDK test mode and store",
+  viewports: "mobile",
+  async run({ page, options }, viewport) {
+    await page.setViewportSize(viewport);
+    await open(page);
+    const debug = await debugValue(page, () => ({
+      store: window.__zappie?.store,
+      version: window.__zappie?.version
+    }));
+    assertion(
+      debug.store === options.store,
+      "sdk_store_mismatch",
+      `SDK store is ${debug.store ?? "missing"}, expected ${options.store}`,
+      "Create the SDK client with the same store slug passed to verify."
+    );
+    assertion(
+      /^0\./.test(debug.version ?? ""),
+      "sdk_version_unsupported",
+      `Unsupported SDK version ${debug.version ?? "missing"}`,
+      "Use a supported @zappie/sdk major version."
+    );
+  }
+};
+
+// ../sdk/src/cart/errors.ts
+var ZappieCartError = class extends ZappieError {
+  constructor(issues) {
+    super("cart_invalid", issues[0]?.message ?? "The cart needs attention");
+    this.issues = issues;
+    this.name = "ZappieCartError";
+  }
+};
+
+// ../sdk/src/cart/price.ts
+function estimateUnitPrice(item, line) {
+  const variant = line.variantId ? item.variants.find((v) => v.id === line.variantId) : void 0;
+  if (line.variantId && !variant) {
+    throw new ZappieError("invalid_request", "The selected variant is missing");
+  }
+  const extras = line.choices.flatMap((selected) => {
+    const group = item.optionGroups.find((g) => g.id === selected.groupId);
+    const choice = group?.choices.find((c) => c.id === selected.choiceId);
+    if (!group || !choice) {
+      throw new ZappieError(
+        "invalid_request",
+        "The selected option is missing"
+      );
+    }
+    return group.isAttribute ? [] : [multiplyMoney(choice.price, Math.max(selected.quantity, 1))];
+  });
+  return sumMoney(extras, variant?.price ?? item.price);
+}
+
+// ../sdk/src/cart/source-menu.ts
+function resolveSourceMenu(menu, itemId, menuId) {
+  const categories = menu.categories.filter((c) => c.itemIds.includes(itemId));
+  const sources = menu.menus ?? [
+    { id: menu.id, categoryIds: menu.categories.map((c) => c.id) }
+  ];
+  const placements = menu.items[itemId]?.placements;
+  const candidates = sources.filter(
+    (source) => (!placements || placements.some(
+      (p) => p.menuId === source.id && source.categoryIds.includes(p.categoryId)
+    )) && source.categoryIds.some((id) => categories.some((c) => c.id === id))
+  );
+  if (menuId !== void 0) {
+    return typeof menuId === "string" && menuId.trim().length > 0 && menuId.length <= 256 && candidates.some((source) => source.id === menuId) ? menuId : void 0;
+  }
+  return candidates.length === 1 ? candidates[0].id : void 0;
+}
+
+// ../sdk/src/cart/validate.ts
+function issue(code, message, fixes = [], groupId) {
+  return {
+    code,
+    severity: "blocking",
+    message,
+    fixes,
+    source: "local",
+    ...groupId ? { groupId } : {}
+  };
+}
+function effectiveGroups(item, input) {
+  const selected = /* @__PURE__ */ new Map();
+  for (const choice of input.choices ?? []) {
+    const ids = selected.get(choice.groupId) ?? /* @__PURE__ */ new Set();
+    ids.add(choice.choiceId);
+    selected.set(choice.groupId, ids);
+  }
+  return item.optionGroups.map((group) => {
+    let required = group.required;
+    let { min, max } = group.selection;
+    for (const rule of group.conditions ?? []) {
+      const chosen = selected.get(rule.groupId) ?? /* @__PURE__ */ new Set();
+      const matches = rule.count ? rule.count.op === "eq" ? chosen.size === rule.count.value : rule.count.op === "gte" ? chosen.size >= rule.count.value : chosen.size <= rule.count.value : chosen.size > 0 && rule.choiceIds.length > 0 && (rule.match === "all" ? rule.choiceIds.every((id) => chosen.has(id)) : rule.choiceIds.some((id) => chosen.has(id)));
+      if (!matches) {
+        continue;
+      }
+      required = rule.setRequired ?? required;
+      min = rule.setMin ?? min;
+      if (rule.setMax != null) {
+        max = rule.setMax > 0 ? rule.setMax : void 0;
+      }
+    }
+    return {
+      ...group,
+      required,
+      selection: { min, ...max !== void 0 ? { max } : {} }
+    };
+  });
+}
+function normalizeInput(item, input) {
+  const inactive = new Set(
+    item.optionGroups.filter((g) => g.isAvailable === false).map((g) => g.id)
+  );
+  return {
+    ...input,
+    quantity: input.quantity ?? item.quantity.min,
+    choices: (input.choices ?? []).filter((c) => !inactive.has(c.groupId)).map((c) => ({ ...c, quantity: c.quantity ?? 1 })),
+    inputs: Object.fromEntries(
+      Object.entries(input.inputs ?? {}).filter(([id]) => !inactive.has(id))
+    )
+  };
+}
+function resolveVariant(item, input) {
+  const attrs = item.optionGroups.filter((g) => g.isAttribute);
+  const matches = item.variants.filter(
+    (variant) => (!input.variantId || variant.id === input.variantId) && attrs.every((group) => {
+      const selected = input.choices?.filter((c) => c.groupId === group.id) ?? [];
+      return selected.length === 1 && variant.attributeChoices[group.id] === selected[0].choiceId;
+    })
+  );
+  return matches.length === 1 ? matches[0] : void 0;
+}
+function validInput(kind, value) {
+  switch (kind) {
+    case "number":
+      return Number.isFinite(Number(value));
+    case "date":
+      return /^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value;
+    case "time":
+      return /^([01]\d|2[0-3]):[0-5]\d(:[0-5]\d)?$/.test(value);
+    case "toggle":
+      return ["true", "false"].includes(value.toLowerCase());
+    default:
+      return true;
+  }
+}
+function validateLine(item, raw, ctx) {
+  if (!item || item.id !== raw.itemId || !Object.hasOwn(ctx.menu.items, raw.itemId)) {
+    return [
+      issue("item_unavailable", "This item is no longer on the menu", [
+        { action: "remove_line" }
+      ])
+    ];
+  }
+  const issues = [];
+  if (!resolveSourceMenu(ctx.menu, raw.itemId, raw.menuId)) {
+    issues.push(
+      issue(
+        "item_unavailable",
+        raw.menuId === void 0 ? `${item.name} is on more than one menu. Remove it and add it again from the menu you want.` : `${item.name} is no longer on the menu it was added from.`,
+        [{ action: "remove_line" }]
+      )
+    );
+  }
+  if (!item.isAvailable) {
+    issues.push(
+      issue("item_unavailable", `${item.name} is unavailable`, [
+        { action: "remove_line" }
+      ])
+    );
+  }
+  const input = normalizeInput(item, raw);
+  const quantity = input.quantity;
+  const { min, step } = item.quantity;
+  const max = Math.min(item.quantity.max ?? 99, 99);
+  if (!Number.isInteger(quantity) || quantity < min || quantity > max || quantity % step !== 0) {
+    const lower = Math.ceil(min / step) * step;
+    const upper = Math.floor(max / step) * step;
+    const nearest = Math.max(
+      lower,
+      Math.min(
+        upper,
+        Math.round((Number.isFinite(quantity) ? quantity : min) / step) * step
+      )
+    );
+    issues.push(
+      issue(
+        "quantity_limit",
+        `Choose a valid quantity of ${item.name} (${min}\u2013${max}, step ${step})`,
+        lower <= upper ? [{ action: "set_quantity", quantity: nearest }] : []
+      )
+    );
+  }
+  if ((input.note?.length ?? 0) > 280) {
+    issues.push(issue("option_limit", "Notes must be at most 280 characters"));
+  }
+  for (const choice of input.choices ?? []) {
+    if (!item.optionGroups.some((g) => g.id === choice.groupId)) {
+      issues.push(
+        issue(
+          "option_unavailable",
+          "This option group no longer exists",
+          [{ action: "remove_line" }],
+          choice.groupId
+        )
+      );
+    }
+  }
+  for (const id of Object.keys(input.inputs ?? {})) {
+    if (!item.optionGroups.some((g) => g.id === id)) {
+      issues.push(
+        issue(
+          "option_unavailable",
+          "This input group no longer exists",
+          [{ action: "remove_line" }],
+          id
+        )
+      );
+    }
+  }
+  const groups = effectiveGroups(item, input);
+  const missing = groups.filter(
+    (g) => g.isAvailable !== false && g.required && !(input.choices ?? []).some((c) => c.groupId === g.id) && !(input.inputs?.[g.id] ?? "").trim()
+  );
+  if (missing.length) {
+    return [
+      ...issues,
+      ...missing.map(
+        (g) => issue(
+          "option_required",
+          `Choose ${g.name}`,
+          [{ action: "choose_option", groupId: g.id }],
+          g.id
+        )
+      )
+    ];
+  }
+  for (const group of groups) {
+    if (group.isAvailable === false) {
+      continue;
+    }
+    const choices = input.choices?.filter((c) => c.groupId === group.id) ?? [];
+    const text2 = input.inputs?.[group.id] ?? "";
+    const value = text2.trim();
+    const hybrid = group.isInformational && group.kind === "select";
+    const isInput = group.kind !== "select" || hybrid && !group.choices.length;
+    const fix = [{ action: "choose_option", groupId: group.id }];
+    if (group.required && !choices.length && !value) {
+      issues.push(
+        issue("option_required", `Choose ${group.name}`, fix, group.id)
+      );
+    }
+    if (value && (!isInput && !hybrid || choices.length > 0)) {
+      issues.push(
+        issue(
+          "option_limit",
+          `Choose either an option or a response for ${group.name}`,
+          fix,
+          group.id
+        )
+      );
+    }
+    if ((isInput || hybrid) && (text2.length > (group.input?.maxLength ?? 500) || value && !validInput(group.kind, value))) {
+      issues.push(
+        issue(
+          "option_limit",
+          `Enter a valid response for ${group.name}`,
+          fix,
+          group.id
+        )
+      );
+    }
+    const count = choices.reduce((sum, c) => sum + (c.quantity ?? 1), 0);
+    if (choices.length && (isInput || count < group.selection.min || count > (group.selection.max ?? Infinity) || new Set(choices.map((c) => c.choiceId)).size !== choices.length)) {
+      issues.push(
+        issue(
+          "option_limit",
+          `Check the number of options for ${group.name}`,
+          fix,
+          group.id
+        )
+      );
+    }
+    for (const selected of choices) {
+      const choice = group.choices.find((c) => c.id === selected.choiceId);
+      if (!choice?.isAvailable) {
+        issues.push(
+          issue(
+            "option_unavailable",
+            `An option in ${group.name} is unavailable`,
+            [
+              { action: "choose_other_option", groupId: group.id },
+              { action: "remove_line" }
+            ],
+            group.id
+          )
+        );
+      }
+      const n = selected.quantity ?? 1;
+      if (!Number.isInteger(n) || n < (choice?.quantity?.min ?? 1) || n > (choice?.quantity?.max ?? 99)) {
+        issues.push(
+          issue(
+            "option_limit",
+            `Check the option quantity for ${group.name}`,
+            fix,
+            group.id
+          )
+        );
+      }
+    }
+  }
+  const variant = resolveVariant(item, input);
+  if (!variant?.isAvailable) {
+    const groupId = item.optionGroups.find((g) => g.isAttribute)?.id;
+    issues.push(
+      issue(
+        "option_limit",
+        "Choose an available variant",
+        groupId ? [{ action: "choose_option", groupId }] : [{ action: "remove_line" }],
+        groupId
+      )
+    );
+  }
+  return issues;
+}
+
+// ../sdk/src/cart/reconcile.ts
+function lineInput(line) {
+  return {
+    itemId: line.itemId,
+    ...line.menuId !== void 0 ? { menuId: line.menuId } : {},
+    quantity: line.quantity,
+    choices: line.choices.map((c) => ({ ...c })),
+    inputs: { ...line.inputs },
+    ...line.variantId ? { variantId: line.variantId } : {},
+    ...line.note !== void 0 ? { note: line.note } : {}
+  };
+}
+function freezeLine(line) {
+  return Object.freeze({
+    ...line,
+    choices: Object.freeze(line.choices.map((c) => Object.freeze({ ...c }))),
+    inputs: Object.freeze({ ...line.inputs })
+  });
+}
+function reconcile(lines, menu, branch, currency, previous = []) {
+  const issues = [];
+  let priced = true;
+  const result = lines.map((old) => {
+    const item = Object.hasOwn(menu.items, old.itemId) ? menu.items[old.itemId] : void 0;
+    const raw = {
+      ...old,
+      choices: old.choices?.map((c) => ({ ...c })),
+      inputs: { ...old.inputs }
+    };
+    const input = item ? normalizeInput(item, raw) : raw;
+    issues.push(
+      ...validateLine(item, input, { menu, branch }).map((i) => ({
+        ...i,
+        lineId: old.id
+      }))
+    );
+    const variantId = input.variantId ?? (item ? resolveVariant(item, input)?.id : void 0);
+    let unitPrice = money(0, currency);
+    let linePriced = true;
+    try {
+      if (!item) {
+        throw new Error("Missing item");
+      }
+      unitPrice = estimateUnitPrice(item, {
+        choices: (input.choices ?? []).map((c) => ({
+          ...c,
+          quantity: c.quantity ?? 1
+        })),
+        ...variantId ? { variantId } : {}
+      });
+    } catch {
+      priced = false;
+      linePriced = false;
+    }
+    if (old.unitPrice && old.unitPrice.amountMinor !== unitPrice.amountMinor && item && linePriced) {
+      issues.push({
+        ...issue(
+          "price_changed",
+          `${item.name} is now ${format.money(unitPrice)}`,
+          [{ action: "accept_price" }, { action: "remove_line" }]
+        ),
+        severity: "warning",
+        lineId: old.id,
+        data: { previous: old.unitPrice, current: unitPrice }
+      });
+    }
+    return freezeLine({
+      id: old.id,
+      itemId: old.itemId,
+      ...input.menuId !== void 0 ? { menuId: input.menuId } : {},
+      name: item?.name ?? old.name,
+      quantity: input.quantity ?? 1,
+      choices: (input.choices ?? []).map((c) => ({
+        ...c,
+        quantity: c.quantity ?? 1
+      })),
+      inputs: input.inputs ?? {},
+      ...variantId ? { variantId } : {},
+      ...input.note !== void 0 ? { note: input.note } : {},
+      unitPrice,
+      lineSubtotal: multiplyMoney(unitPrice, input.quantity ?? 1),
+      addedAt: old.addedAt
+    });
+  });
+  for (const pending of previous) {
+    if (pending.code === "price_changed" && result.some((l) => l.id === pending.lineId) && !issues.some(
+      (i) => i.code === pending.code && i.lineId === pending.lineId
+    )) {
+      issues.push(pending);
+    }
+  }
+  return { lines: Object.freeze(result), issues, priced };
+}
+
+// ../sdk/src/cart/storage.ts
+function storedMoney(value) {
+  try {
+    return value && money(value.amountMinor, value.currency);
+  } catch {
+    return void 0;
+  }
+}
+function parseCart(raw) {
+  const v = JSON.parse(raw);
+  if (!v || v.v !== 1 || !Array.isArray(v.lines) || v.lines.length > 100 || !Number.isFinite(v.updatedAt) || typeof v.menuVersion !== "string" || v.promoCode !== null && typeof v.promoCode !== "string") {
+    throw new Error("Invalid saved cart");
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const line of v.lines) {
+    if (!line || typeof line.id !== "string" || ids.has(line.id) || typeof line.itemId !== "string" || typeof line.name !== "string" || !Number.isFinite(Date.parse(line.addedAt)) || !Number.isInteger(line.quantity) || line.quantity < 1 || line.quantity > 99 || line.note !== void 0 && (typeof line.note !== "string" || line.note.length > 280) || line.menuId !== void 0 && (typeof line.menuId !== "string" || !line.menuId.trim() || line.menuId.length > 256) || line.variantId !== void 0 && typeof line.variantId !== "string") {
+      throw new Error("Invalid saved cart line");
+    }
+    ids.add(line.id);
+    if (!Array.isArray(line.choices) || line.choices.length > 1e3 || line.choices.some(
+      (c) => !c || typeof c.groupId !== "string" || typeof c.choiceId !== "string" || !Number.isInteger(c.quantity) || c.quantity < 1 || c.quantity > 99
+    )) {
+      throw new Error("Invalid saved choices");
+    }
+    if (!line.inputs || typeof line.inputs !== "object" || Array.isArray(line.inputs) || Object.values(line.inputs).some((t) => typeof t !== "string")) {
+      throw new Error("Invalid saved inputs");
+    }
+  }
+  if (v.fulfilment !== null && !validFulfilment(v.fulfilment)) {
+    throw new Error("Invalid saved fulfilment");
+  }
+  return {
+    v: 1,
+    lines: v.lines.map((l) => {
+      const unitPrice = storedMoney(l.unitPrice);
+      return {
+        id: l.id,
+        itemId: l.itemId,
+        ...l.menuId !== void 0 ? { menuId: l.menuId } : {},
+        name: l.name,
+        addedAt: l.addedAt,
+        ...unitPrice ? { unitPrice } : {},
+        quantity: l.quantity,
+        choices: l.choices,
+        inputs: l.inputs,
+        ...l.variantId ? { variantId: l.variantId } : {},
+        ...l.note !== void 0 ? { note: l.note } : {}
+      };
+    }),
+    fulfilment: v.fulfilment,
+    promoCode: v.promoCode,
+    menuVersion: v.menuVersion,
+    updatedAt: v.updatedAt
+  };
+}
+function validFulfilment(f) {
+  if (!f || !["pickup", "delivery", "dine_in"].includes(f.type) || typeof f.branchId !== "string") {
+    return false;
+  }
+  if ("scheduledFor" in f && f.scheduledFor !== void 0 && !Number.isFinite(Date.parse(f.scheduledFor))) {
+    return false;
+  }
+  if (f.type === "delivery") {
+    const a = f.address;
+    if (!a || typeof a.line1 !== "string" || !a.line1.trim()) {
+      return false;
+    }
+    if ([a.line2, a.city, a.placeId, a.instructions].some(
+      (s) => s !== void 0 && typeof s !== "string"
+    )) {
+      return false;
+    }
+    if (a.coordinates && (!Number.isFinite(a.coordinates.lat) || !Number.isFinite(a.coordinates.lng) || Math.abs(a.coordinates.lat) > 90 || Math.abs(a.coordinates.lng) > 180)) {
+      return false;
+    }
+  }
+  return f.type !== "dine_in" || f.table === void 0 || typeof f.table === "string";
+}
+function createCartStorage(provided, warn) {
+  let storage;
+  let initialized = false;
+  let failed = false;
+  let warned = false;
+  const memory = /* @__PURE__ */ new Map();
+  const warning = (message) => {
+    if (!warned) {
+      warned = true;
+      warn(message);
+    }
+  };
+  const access = (fn, fallback) => {
+    try {
+      if (!initialized) {
+        initialized = true;
+        storage = provided ?? (typeof window === "undefined" ? void 0 : window.localStorage);
+      }
+      if (storage && !failed) {
+        return fn(storage);
+      }
+    } catch {
+      failed = true;
+      warning("Cart storage unavailable; using memory for this client");
+    }
+    return fallback();
+  };
+  return {
+    warning,
+    read(key) {
+      return access(
+        (s) => {
+          const value = s.getItem(key);
+          if (value !== null) {
+            memory.set(key, value);
+          } else {
+            memory.delete(key);
+          }
+          return value;
+        },
+        () => memory.get(key) ?? null
+      );
+    },
+    write(key, value) {
+      memory.set(key, value);
+      access(
+        (s) => s.setItem(key, value),
+        () => {
+        }
+      );
+    },
+    remove(key) {
+      memory.delete(key);
+      access(
+        (s) => s.removeItem(key),
+        () => {
+        }
+      );
+    },
+    accepts(area) {
+      return !failed && (!area || area === storage);
+    },
+    sweep(prefix, current, ttl) {
+      access(
+        (s) => {
+          const keys = Array.from(
+            { length: s.length ?? 0 },
+            (_, index) => s.key?.(index)
+          );
+          for (const key of keys) {
+            if (!key || key === current || !key.startsWith(prefix)) {
+              continue;
+            }
+            try {
+              const raw = s.getItem(key);
+              if (raw && Date.now() - parseCart(raw).updatedAt > ttl) {
+                s.removeItem(key);
+              }
+            } catch {
+              s.removeItem(key);
+            }
+          }
+        },
+        () => {
+        }
+      );
+    }
+  };
+}
+
+// ../sdk/src/cart/wire.ts
+function wireLine(line) {
+  return {
+    line_id: line.id,
+    item_id: line.itemId,
+    ...line.menuId !== void 0 ? { menu_id: line.menuId } : {},
+    quantity: line.quantity,
+    ...line.variantId ? { variant_id: line.variantId } : {},
+    options: line.choices.map((c) => ({
+      group_id: c.groupId,
+      choice_id: c.choiceId,
+      quantity: c.quantity
+    })),
+    inputs: { ...line.inputs },
+    ...line.note !== void 0 ? { note: line.note } : {}
+  };
+}
+function wireFulfilment(f) {
+  return {
+    type: f.type,
+    ..."scheduledFor" in f && f.scheduledFor ? { scheduled_for: f.scheduledFor } : {},
+    ...f.type === "dine_in" && f.table ? { table: f.table } : {},
+    ...f.type === "delivery" ? {
+      address: {
+        line1: f.address.line1,
+        ...f.address.line2 ? { line2: f.address.line2 } : {},
+        ...f.address.city ? { city: f.address.city } : {},
+        ...f.address.placeId ? { place_id: f.address.placeId } : {},
+        ...f.address.instructions ? { instructions: f.address.instructions } : {},
+        ...f.address.coordinates ? {
+          lat: f.address.coordinates.lat,
+          lng: f.address.coordinates.lng
+        } : {}
+      }
+    } : {}
+  };
+}
+
+// ../sdk/src/cart/index.ts
+var EMPTY_CART = Object.freeze({
+  lines: Object.freeze([]),
+  count: 0,
+  subtotal: null,
+  fulfilment: null,
+  promoCode: null,
+  state: { status: "ready" },
+  issues: Object.freeze([]),
+  isHydrated: false
+});
+function deepFreeze(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value)) {
+      deepFreeze(child);
+    }
+  }
+  return value;
+}
+function identity(input) {
+  return JSON.stringify([
+    input.itemId,
+    input.menuId,
+    input.variantId,
+    input.note ?? "",
+    [...input.choices ?? []].sort(
+      (a, b) => a.groupId.localeCompare(b.groupId) || a.choiceId.localeCompare(b.choiceId)
+    ),
+    Object.entries(input.inputs ?? {}).sort(([a], [b]) => a.localeCompare(b))
+  ]);
+}
+function createCart(deps) {
+  const { config, menu: menus, store, events } = deps;
+  const ttl = config.cart?.ttl ?? 7 * 24 * 60 * 60 * 1e3;
+  if (!Number.isFinite(ttl) || ttl <= 0) {
+    throw new ZappieError(
+      "invalid_request",
+      "Cart ttl must be positive milliseconds"
+    );
+  }
+  let snapshot = EMPTY_CART;
+  let menu;
+  let branch;
+  let selected = config.branch;
+  let updatedAt = 0;
+  let timer;
+  let revision = 0;
+  let quoteRevision = 0;
+  let moveSequence = 0;
+  let refreshSequence = 0;
+  let mounted = 0;
+  let detach;
+  let hydration;
+  let lifecycle = 0;
+  let legacy;
+  const listeners = /* @__PURE__ */ new Set();
+  const prefix = `zappie:cart:v1:${config.store}:`;
+  const scope = config.cart?.storageScope;
+  const keyFor = (id) => `${prefix}${id}${scope ? `:${scope}` : ""}`;
+  const key = () => keyFor(branch.id);
+  const storage = createCartStorage(
+    config.storage,
+    (message) => events.emit("warning", { message })
+  );
+  const readSaved = (id) => {
+    let raw = storage.read(keyFor(id));
+    if (raw === null && scope) {
+      raw = storage.read(prefix + id);
+      if (raw !== null) {
+        storage.remove(prefix + id);
+        storage.write(keyFor(id), raw);
+      }
+    }
+    return raw;
+  };
+  let quotes;
+  let loadingQuotes;
+  const quoteClient = () => loadingQuotes ??= import("./quote-client-6XJJHITL.js").then(
+    ({ createQuoteClient }) => quotes = createQuoteClient(deps.transport, deps.context),
+    (error) => {
+      loadingQuotes = void 0;
+      throw error;
+    }
+  );
+  const publish = (patch) => {
+    snapshot = deepFreeze({
+      ...snapshot,
+      ...patch,
+      branchId: branch?.id
+    });
+    for (const fn of [...listeners]) {
+      try {
+        fn();
+      } catch (error) {
+        events.emit("error", { error: asError(error) });
+      }
+    }
+  };
+  const attention = (issues, quote) => issues.some((i) => i.severity !== "info") ? { status: "needs_attention", issues, ...quote ? { quote } : {} } : quote ? { status: "quoted", quote } : { status: "ready" };
+  const cancel = () => {
+    revision++;
+    quoteRevision++;
+    clearTimeout(timer);
+    quotes?.cancel();
+  };
+  const persist = () => {
+    const value = {
+      v: 1,
+      lines: snapshot.lines.map((line) => ({
+        ...lineInput(line),
+        id: line.id,
+        name: line.name,
+        addedAt: line.addedAt,
+        unitPrice: line.unitPrice
+      })),
+      fulfilment: snapshot.fulfilment,
+      promoCode: snapshot.promoCode,
+      menuVersion: menu.version,
+      updatedAt
+    };
+    storage.write(key(), JSON.stringify(value));
+  };
+  const schedule = () => {
+    clearTimeout(timer);
+    if (snapshot.lines.length) {
+      timer = setTimeout(() => {
+        void cart.quote().catch(() => {
+        });
+      }, 300);
+    }
+  };
+  const recompute = (lines, pending = snapshot.issues.filter((i) => i.source === "local"), patch = {}) => {
+    const currency = store.peek().currency;
+    const result = reconcile(lines, menu, branch, currency, pending);
+    const subtotal = result.priced ? sumMoney(
+      result.lines.map((l) => l.lineSubtotal),
+      money(0, currency)
+    ) : null;
+    publish({
+      ...patch,
+      lines: result.lines,
+      count: result.lines.reduce((n, l) => n + l.quantity, 0),
+      subtotal,
+      issues: result.issues,
+      state: attention(result.issues)
+    });
+    for (const i of result.issues) {
+      events.emit("cart_issue", { code: i.code });
+    }
+  };
+  const changed = (lines = snapshot.lines, patch = {}) => {
+    cancel();
+    recompute(lines, void 0, patch);
+    updatedAt = Date.now();
+    persist();
+    schedule();
+  };
+  const choose = (value) => {
+    const found = store.peek()?.branches.find((b) => b.id === value.branchId);
+    if (!found) {
+      throw new ZappieError(
+        "branch_not_found",
+        "Load the storefront branch before using its cart"
+      );
+    }
+    menu = value;
+    branch = found;
+    selected = found.id;
+  };
+  const load = (raw, writeBack = true) => {
+    cancel();
+    let saved;
+    try {
+      saved = raw ? parseCart(raw) : void 0;
+      if (saved && Date.now() - saved.updatedAt > ttl) {
+        saved = void 0;
+        storage.remove(key());
+        events.emit("cart_expired", { branchId: branch.id });
+      }
+    } catch {
+      storage.remove(key());
+      storage.warning("Invalid saved cart discarded");
+    }
+    updatedAt = saved?.updatedAt ?? Date.now();
+    const idle = Date.now() - updatedAt;
+    let fulfilment = saved?.fulfilment ?? null;
+    if (fulfilment?.branchId !== branch.id || idle > 864e5 && fulfilment.type === "delivery") {
+      fulfilment = null;
+    }
+    if (fulfilment && "scheduledFor" in fulfilment && fulfilment.scheduledFor && Date.parse(fulfilment.scheduledFor) < Date.now()) {
+      fulfilment = { ...fulfilment };
+      delete fulfilment.scheduledFor;
+    }
+    const lines = (saved?.lines ?? []).map((line) => ({
+      ...line,
+      ...idle > 864e5 ? { inputs: {} } : {}
+    }));
+    const result = reconcile(lines, menu, branch, store.peek().currency);
+    recompute(result.lines, result.issues, {
+      fulfilment,
+      promoCode: saved?.promoCode ?? null,
+      isHydrated: true
+    });
+    if (raw !== null && writeBack) {
+      persist();
+    }
+    storage.sweep(prefix, key(), ttl);
+  };
+  const ensure = () => {
+    const id = branch?.id ?? store.peek()?.branches.find(
+      (b) => b.id === selected || b.slug === selected || !selected && b.isDefault
+    )?.id ?? (!selected ? store.peek()?.branches[0]?.id : void 0);
+    if (snapshot.isHydrated) {
+      return;
+    }
+    const loaded = menu ?? (id ? deps.workingSet.peek(id, []) : void 0);
+    if (!loaded || !store.peek()) {
+      throw new ZappieError(
+        "invalid_request",
+        "Load the store and menu before editing the cart"
+      );
+    }
+    choose(loaded);
+    const raw = readSaved(branch.id);
+    let migrated = [];
+    if (raw === null && legacy) {
+      try {
+        migrated = legacy(storage.read);
+      } catch {
+        storage.warning("Invalid legacy cart discarded");
+      }
+    }
+    load(raw);
+    if (raw === null && legacy) {
+      persist();
+    }
+    for (const input of migrated.slice(0, 100)) {
+      try {
+        cart.add(input.itemId, input);
+      } catch {
+        events.emit("cart_issue", { code: "item_unavailable" });
+      }
+    }
+  };
+  const refresh = async () => {
+    const id = branch?.id;
+    const seq = moveSequence;
+    const request = ++refreshSequence;
+    const rev = revision;
+    if (!id || !menu) {
+      return;
+    }
+    if (!snapshot.lines.length) {
+      return;
+    }
+    if (menu.completeness !== "partial") {
+      const version = await deps.transport.getMenuVersion({
+        ...deps.context(),
+        branchId: id
+      });
+      if (version.version === menu.version) {
+        return;
+      }
+    }
+    const value = await deps.workingSet.read(
+      id,
+      snapshot.lines.map((l) => l.itemId),
+      true
+    );
+    if (seq !== moveSequence || request !== refreshSequence || rev !== revision || JSON.stringify(value) === JSON.stringify(menu)) {
+      return;
+    }
+    menu = value;
+    cancel();
+    recompute(snapshot.lines);
+    persist();
+    schedule();
+  };
+  const current = (itemId) => {
+    const candidate = deps.workingSet.peek(branch.id, [
+      ...snapshot.lines.map((l) => l.itemId),
+      itemId
+    ]);
+    if (candidate.items[itemId]) {
+      menu = candidate;
+    }
+  };
+  const validated = (raw, id, addedAt) => {
+    current(raw.itemId);
+    const item = Object.hasOwn(menu.items, raw.itemId) ? menu.items[raw.itemId] : void 0;
+    const problems = validateLine(item, raw, { menu, branch });
+    if (problems.length || !item) {
+      throw new ZappieCartError(problems);
+    }
+    const input = normalizeInput(item, raw);
+    const variant = resolveVariant(item, input);
+    const choices = (input.choices ?? []).map((c) => ({
+      ...c,
+      quantity: c.quantity ?? 1
+    }));
+    const unitPrice = estimateUnitPrice(item, {
+      choices,
+      variantId: variant.id
+    });
+    return freezeLine({
+      id: id ?? `line_${Array.from(globalThis.crypto.getRandomValues(new Uint8Array(10)), (byte) => "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz-"[byte & 63]).join("")}`,
+      itemId: item.id,
+      ...input.menuId !== void 0 ? { menuId: input.menuId } : {},
+      name: item.name,
+      quantity: input.quantity,
+      choices,
+      inputs: input.inputs ?? {},
+      variantId: variant.id,
+      ...input.note !== void 0 ? { note: input.note } : {},
+      unitPrice,
+      lineSubtotal: multiplyMoney(unitPrice, input.quantity),
+      addedAt: addedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    });
+  };
+  const offMenu = events.on("menu:updated", ({ branchId, version }) => {
+    if (branch?.id === branchId) {
+      const value = menus.peek(branchId);
+      if (value && value.completeness !== "partial" && value.version === version && value.version !== menu?.version) {
+        refreshSequence++;
+        menu = value;
+        cancel();
+        recompute(snapshot.lines);
+        persist();
+        schedule();
+      }
+    }
+  });
+  const cart = {
+    get branchId() {
+      return snapshot.branchId;
+    },
+    get lines() {
+      return snapshot.lines;
+    },
+    get count() {
+      return snapshot.count;
+    },
+    get subtotal() {
+      return snapshot.subtotal;
+    },
+    get fulfilment() {
+      return snapshot.fulfilment;
+    },
+    get promoCode() {
+      return snapshot.promoCode;
+    },
+    get state() {
+      return snapshot.state;
+    },
+    get issues() {
+      return snapshot.issues;
+    },
+    get isHydrated() {
+      return snapshot.isHydrated;
+    },
+    getSnapshot: () => snapshot,
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    },
+    async hydrate() {
+      if (snapshot.isHydrated) {
+        return refresh();
+      }
+      const life = lifecycle;
+      hydration ??= (async () => {
+        const value = await store.get();
+        const target2 = value.branches.find(
+          (b) => b.id === selected || b.slug === selected
+        ) ?? (!selected ? value.branches.find((b) => b.isDefault) ?? value.branches[0] : void 0);
+        if (!target2) {
+          throw new ZappieError(
+            "branch_not_found",
+            "Cart branch is unavailable"
+          );
+        }
+        let inputs = snapshot.lines;
+        if (!snapshot.isHydrated) {
+          const raw = readSaved(target2.id);
+          try {
+            const saved = raw ? parseCart(raw) : void 0;
+            inputs = saved && Date.now() - saved.updatedAt <= ttl ? saved.lines : raw === null ? legacy?.(storage.read) ?? [] : [];
+          } catch {
+            inputs = [];
+          }
+        }
+        const loaded = await deps.workingSet.read(
+          target2.id,
+          inputs.map((l) => l.itemId)
+        );
+        if (life !== lifecycle) {
+          return;
+        }
+        choose(loaded);
+        ensure();
+        if (loaded.completeness !== "partial") {
+          await refresh();
+        }
+      })().finally(() => {
+        hydration = void 0;
+      });
+      return hydration;
+    },
+    mount() {
+      mounted++;
+      if (!detach && typeof window !== "undefined") {
+        const onStorage = (event) => {
+          if (branch && event.key === key() && storage.accepts(event.storageArea)) {
+            const raw = event.newValue;
+            let ids;
+            try {
+              ids = raw ? parseCart(raw).lines.map((l) => l.itemId) : [];
+            } catch {
+              load(raw, false);
+              return;
+            }
+            const cached = deps.workingSet.peek(branch.id, ids);
+            if (cached.completeness !== "partial" || ids.every((id) => cached.items[id])) {
+              menu = cached;
+              load(raw, false);
+              schedule();
+              return;
+            }
+            const rev = revision;
+            const request = ++refreshSequence;
+            const life = lifecycle;
+            void deps.workingSet.read(branch.id, ids).then((value) => {
+              if (life === lifecycle && rev === revision && request === refreshSequence) {
+                menu = value;
+                load(raw, false);
+                schedule();
+              }
+            }).catch(
+              (error) => events.emit("error", { error: asError(error) })
+            );
+          }
+        };
+        const onFocus = () => {
+          void refresh().catch(
+            (error) => events.emit("error", { error: asError(error) })
+          );
+        };
+        window.addEventListener("storage", onStorage);
+        window.addEventListener("focus", onFocus);
+        detach = () => {
+          window.removeEventListener("storage", onStorage);
+          window.removeEventListener("focus", onFocus);
+        };
+      }
+      if (mounted === 1) {
+        void cart.hydrate().catch(
+          (error) => events.emit("error", { error: asError(error) })
+        );
+      }
+      let active = true;
+      return () => {
+        if (active) {
+          active = false;
+          mounted--;
+          if (mounted === 0) {
+            detach?.();
+            detach = void 0;
+            cancel();
+          }
+        }
+      };
+    },
+    dispose() {
+      lifecycle++;
+      moveSequence++;
+      offMenu();
+      cancel();
+      detach?.();
+      detach = void 0;
+      listeners.clear();
+    },
+    validate(input) {
+      ensure();
+      current(input.itemId);
+      const problems = validateLine(
+        Object.hasOwn(menu.items, input.itemId) ? menu.items[input.itemId] : void 0,
+        input,
+        { menu, branch }
+      );
+      return problems.length ? { ok: false, issues: problems } : { ok: true };
+    },
+    add(item, input = {}) {
+      ensure();
+      let line = validated({
+        ...input,
+        itemId: typeof item === "string" ? item : item.id
+      });
+      const existing = snapshot.lines.find(
+        (l) => identity(lineInput(l)) === identity(lineInput(line))
+      );
+      if (existing) {
+        line = validated(
+          { ...lineInput(line), quantity: existing.quantity + line.quantity },
+          existing.id,
+          existing.addedAt
+        );
+      } else if (snapshot.lines.length >= 100) {
+        throw new ZappieCartError([
+          issue("quantity_limit", "A cart can contain at most 100 lines")
+        ]);
+      }
+      changed(
+        existing ? snapshot.lines.map((l) => l.id === existing.id ? line : l) : [...snapshot.lines, line]
+      );
+      events.emit("add_to_cart", {
+        itemId: line.itemId,
+        quantity: line.quantity - (existing?.quantity ?? 0),
+        value: multiplyMoney(
+          line.unitPrice,
+          line.quantity - (existing?.quantity ?? 0)
+        )
+      });
+      return line;
+    },
+    update(lineId, patch) {
+      ensure();
+      const old = snapshot.lines.find((l) => l.id === lineId);
+      if (!old) {
+        throw new ZappieCartError([
+          issue("item_not_found", "Cart line not found")
+        ]);
+      }
+      const input = { ...lineInput(old), ...patch };
+      if (patch.choices && !patch.variantId) {
+        delete input.variantId;
+      }
+      let line = validated(input, old.id, old.addedAt);
+      const duplicate = snapshot.lines.find(
+        (l) => l.id !== lineId && identity(lineInput(l)) === identity(lineInput(line))
+      );
+      if (duplicate) {
+        line = validated(
+          { ...lineInput(line), quantity: line.quantity + duplicate.quantity },
+          old.id,
+          old.addedAt
+        );
+      }
+      changed(
+        snapshot.lines.filter((l) => l.id !== duplicate?.id).map((l) => l.id === lineId ? line : l)
+      );
+      events.emit("update_cart_line", {
+        lineId,
+        itemId: line.itemId,
+        quantity: line.quantity
+      });
+      return line;
+    },
+    remove(lineId) {
+      ensure();
+      const line = snapshot.lines.find((l) => l.id === lineId);
+      changed(snapshot.lines.filter((l) => l.id !== lineId));
+      if (line) {
+        events.emit("remove_from_cart", {
+          itemId: line.itemId,
+          quantity: line.quantity,
+          value: line.lineSubtotal
+        });
+      }
+    },
+    clear() {
+      ensure();
+      changed([], { fulfilment: null, promoCode: null });
+    },
+    setFulfilment(value) {
+      ensure();
+      if (!validFulfilment(value) || value.branchId !== branch.id) {
+        throw new ZappieCartError([
+          issue(
+            "fulfilment_unavailable",
+            "Select fulfilment for the cart's branch"
+          )
+        ]);
+      }
+      changed(snapshot.lines, { fulfilment: structuredClone(value) });
+    },
+    setPromoCode(code) {
+      ensure();
+      changed(snapshot.lines, { promoCode: code?.trim() || null });
+    },
+    async moveTo(branchId) {
+      ensure();
+      const seq = ++moveSequence;
+      cancel();
+      publish({ state: attention(snapshot.issues) });
+      const value = await deps.workingSet.read(
+        branchId,
+        snapshot.lines.map((l) => l.itemId)
+      );
+      if (seq !== moveSequence) {
+        return;
+      }
+      const oldKey = key();
+      const oldLines = snapshot.lines;
+      choose(value);
+      const kept = oldLines.filter(
+        (line) => !validateLine(value.items[line.itemId], lineInput(line), {
+          menu: value,
+          branch
+        }).length
+      );
+      changed(kept, { fulfilment: null, promoCode: null });
+      const dropped = oldLines.filter((line) => !kept.includes(line)).map((line) => ({
+        ...issue(
+          "item_unavailable",
+          `${line.name} is unavailable at this branch`
+        ),
+        severity: "warning",
+        lineId: line.id
+      }));
+      const issues = [...snapshot.issues, ...dropped];
+      publish({ issues, state: attention(issues) });
+      if (oldKey !== key()) {
+        storage.remove(oldKey);
+      }
+    },
+    async quote(opts = {}) {
+      ensure();
+      clearTimeout(timer);
+      if (opts.force) {
+        events.emit("view_cart", {});
+      }
+      const body = {
+        branch_id: branch.id,
+        lines: snapshot.lines.map(wireLine),
+        ...snapshot.fulfilment ? { fulfilment: wireFulfilment(snapshot.fulfilment) } : {},
+        ...snapshot.promoCode ? { promo_code: snapshot.promoCode } : {},
+        menu_version: menu.version
+      };
+      const seq = revision;
+      const attempt = ++quoteRevision;
+      publish({ state: { status: "quoting" } });
+      try {
+        const client = await quoteClient();
+        return await client.get(body, opts.force ?? false, (quote) => {
+          if (seq !== revision) {
+            return;
+          }
+          const local = snapshot.issues.filter((i) => i.source === "local");
+          const remote = quote.issues.filter(
+            (q) => !local.some(
+              (l) => l.code === q.code && l.lineId === q.lineId && l.groupId === q.groupId
+            )
+          );
+          const issues = [...local, ...remote];
+          publish({ issues, state: attention(issues, quote) });
+          for (const i of remote) {
+            events.emit("cart_issue", { code: i.code });
+          }
+          if (quote.menuVersion !== menu.version || quote.issues.some((i) => i.code === "menu_version_stale")) {
+            void refresh().catch(
+              (error) => events.emit("error", { error: asError(error) })
+            );
+          }
+        });
+      } catch (error) {
+        if (seq === revision && attempt === quoteRevision) {
+          const local = snapshot.issues.filter((i) => i.source === "local");
+          publish({ issues: local, state: attention(local) });
+          events.emit("quote_failed", { code: asError(error).code });
+        }
+        throw error instanceof Error && error.name === "AbortError" ? error : asError(error);
+      }
+    },
+    applyFix(problem, fix = problem.fixes[0]) {
+      if (!snapshot.issues.includes(problem) || !fix || !problem.fixes.some((f) => JSON.stringify(f) === JSON.stringify(fix))) {
+        throw new ZappieError(
+          "invalid_request",
+          "Choose a current cart issue and one of its fixes"
+        );
+      }
+      switch (fix.action) {
+        case "remove_line": {
+          if (problem.lineId) {
+            cart.remove(problem.lineId);
+          }
+          return;
+        }
+        case "remove_promo":
+          cart.setPromoCode(null);
+          return;
+        case "set_quantity": {
+          if (problem.lineId) {
+            cart.update(problem.lineId, { quantity: fix.quantity });
+          }
+          return;
+        }
+        case "accept_price": {
+          quotes?.accept(problem);
+          const issues = snapshot.issues.filter((i) => i !== problem);
+          const quote = "quote" in snapshot.state ? snapshot.state.quote : void 0;
+          const accepted = quote ? {
+            ...quote,
+            issues: quote.issues.filter(
+              (i) => !(i.code === problem.code && i.lineId === problem.lineId)
+            )
+          } : void 0;
+          publish({ issues, state: attention(issues, accepted) });
+          return;
+        }
+        default:
+          throw new ZappieError(
+            "invalid_request",
+            `${fix.action} needs the shopper's selection; use update or setFulfilment`
+          );
+      }
+    },
+    toCheckoutPayload() {
+      ensure();
+      const blocking = snapshot.issues.filter((i) => i.severity === "blocking");
+      if (!snapshot.lines.length || !snapshot.fulfilment) {
+        blocking.push(
+          issue(
+            "fulfilment_unavailable",
+            "Add items and select fulfilment before checkout"
+          )
+        );
+      }
+      if (blocking.length) {
+        throw new ZappieCartError(blocking);
+      }
+      return {
+        lines: snapshot.lines.map(wireLine),
+        fulfilment: structuredClone(snapshot.fulfilment),
+        ...snapshot.promoCode ? { promo_code: snapshot.promoCode } : {},
+        menu_version: menu.version
+      };
+    }
+  };
+  return {
+    cart: Object.freeze(cart),
+    cartCatalogue: () => menu,
+    setLegacyReader(reader) {
+      legacy = reader;
+    }
+  };
+}
+
+// ../sdk/src/cart/working-set.ts
+function createWorkingSet(deps) {
+  const compose = (branchId, ids, metadata) => {
+    const source = metadata ?? deps.menu.peek(branchId);
+    const items = Object.fromEntries(
+      [...new Set(ids)].flatMap((id) => {
+        const item = deps.peekItem(id, branchId) ?? source?.items[id];
+        return item ? [[id, item]] : [];
+      })
+    );
+    return {
+      id: `branch:${branchId}`,
+      name: "Cart working set",
+      branchId,
+      version: "",
+      ...source,
+      kind: "working-set",
+      completeness: "partial",
+      items,
+      categories: (source?.categories ?? []).map((category) => ({
+        ...category,
+        itemIds: Object.values(items).filter(
+          (item) => item.placements ? item.placements.some(
+            (p) => p.categoryId === category.id && (source?.menus ?? [
+              { id: source?.id, categoryIds: [category.id] }
+            ]).some(
+              (m) => m.id === p.menuId && m.categoryIds.includes(category.id)
+            )
+          ) : category.itemIds.includes(item.id)
+        ).map((item) => item.id)
+      }))
+    };
+  };
+  const peek = (branchId, ids) => {
+    const value = deps.menu.peek(branchId);
+    return value && value.completeness !== "partial" ? value : compose(branchId, ids);
+  };
+  return {
+    peek,
+    async read(branchId, ids, fresh = false) {
+      const cached = peek(branchId, ids);
+      if (!ids.length || !fresh && cached.completeness !== "partial") {
+        return cached;
+      }
+      const response = fresh ? await deps.transport.getMenu({
+        ...deps.context(),
+        branchId,
+        metadataOnly: true
+      }) : void 0;
+      const metadata = response && "menu" in response ? response.menu : await deps.menu.get({ branch: branchId, metadataOnly: true });
+      if (metadata.branchId !== branchId) {
+        throw new ZappieError(
+          "server_error",
+          "Cart metadata belongs to another branch"
+        );
+      }
+      deps.menu.hydrate(metadata);
+      if (metadata.completeness !== "partial") {
+        return metadata;
+      }
+      await Promise.all(
+        [...new Set(ids)].map(async (id) => {
+          try {
+            await deps.readItem(id, branchId, fresh);
+          } catch (error) {
+            if (error.code !== "item_not_found") {
+              throw error;
+            }
+          }
+        })
+      );
+      return compose(branchId, ids, metadata);
+    }
+  };
+}
+
+// ../sdk/src/config.ts
+var API_VERSION = "2026-10-01";
+function validateConfig(config, secret = false) {
+  if (!config.store?.trim()) {
+    throw new ZappieError("invalid_request", "A storefront slug is required");
+  }
+  if (secret && typeof window !== "undefined") {
+    throw new ZappieError(
+      "invalid_request",
+      "Secret keys cannot be used in a browser"
+    );
+  }
+  const pattern = secret ? /^sk_(test|live)_.+$/ : /^pk_(test|live)_.+$/;
+  const match = pattern.exec(config.key);
+  if (!match) {
+    throw new ZappieError(
+      "invalid_request",
+      secret ? "A secret sk_test_ or sk_live_ key is required" : "Use a publishable pk_test_ or pk_live_ key; secret keys are never accepted by createZappie"
+    );
+  }
+  return match[1];
+}
+
+// ../sdk/src/internal/abort.ts
+function abortReason(signal2) {
+  return signal2?.reason ?? new DOMException("The request was aborted", "AbortError");
+}
+function throwIfAborted(signal2) {
+  if (signal2?.aborted) {
+    throw abortReason(signal2);
+  }
+}
+function delay(ms, signal2) {
+  return new Promise((resolve, reject) => {
+    throwIfAborted(signal2);
+    const abort = () => {
+      clearTimeout(timer);
+      reject(abortReason(signal2));
+    };
+    const timer = setTimeout(() => {
+      signal2?.removeEventListener("abort", abort);
+      resolve();
+    }, ms);
+    signal2?.addEventListener("abort", abort, { once: true });
+  });
+}
+
+// ../sdk/src/internal/cache.ts
+var REFRESH_BACKOFF_MS = 1e4;
+var EMPTY = Object.freeze({
+  fetchedAt: 0,
+  loading: false
+});
+var Cache = class {
+  constructor(onError) {
+    this.onError = onError;
+    this.entries = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.flights = /* @__PURE__ */ new Map();
+    this.subscribe = (fn) => {
+      this.listeners.add(fn);
+      return () => {
+        this.listeners.delete(fn);
+      };
+    };
+  }
+  snapshot(key) {
+    return this.entries.get(key) ?? EMPTY;
+  }
+  notify() {
+    for (const fn of [...this.listeners]) {
+      fn();
+    }
+  }
+  set(key, value, etag) {
+    this.entries.set(key, {
+      value,
+      fetchedAt: Date.now(),
+      loading: false,
+      ...etag !== void 0 ? { etag } : {}
+    });
+    this.notify();
+  }
+  stale(key) {
+    const entry = this.snapshot(key);
+    return entry.value !== void 0 && Date.now() - entry.fetchedAt >= 6e4;
+  }
+  async get(key, loader, signal2) {
+    throwIfAborted(signal2);
+    const entry = this.snapshot(key);
+    const age = Date.now() - entry.fetchedAt;
+    if (entry.value !== void 0 && age < 6e4) {
+      return entry.value;
+    }
+    const background = entry.value !== void 0 && age < 6e5;
+    if (background && entry.failedAt !== void 0 && Date.now() - entry.failedAt < REFRESH_BACKOFF_MS) {
+      return entry.value;
+    }
+    let flight = this.flights.get(key);
+    if (!flight) {
+      const controller = new AbortController();
+      flight = {
+        controller,
+        users: 0,
+        keepAlive: background,
+        promise: Promise.resolve()
+      };
+      const current2 = flight;
+      this.flights.set(key, current2);
+      const loading = { ...entry, loading: true };
+      this.entries.set(key, loading);
+      this.notify();
+      current2.promise = Promise.resolve().then(() => {
+        throwIfAborted(controller.signal);
+        return loader(controller.signal, entry);
+      }).then((result) => {
+        if (this.entries.get(key) === loading && !controller.signal.aborted) {
+          this.set(key, result.value, result.etag);
+          result.onStored?.();
+        }
+        return result.value;
+      }).catch((error) => {
+        if (this.entries.get(key) === loading) {
+          this.entries.set(
+            key,
+            controller.signal.aborted ? { ...entry, loading: false } : {
+              ...entry,
+              loading: false,
+              error: asError(error),
+              failedAt: Date.now()
+            }
+          );
+          this.notify();
+          if (!controller.signal.aborted) {
+            this.onError(asError(error));
+          }
+        }
+        throw controller.signal.aborted ? abortReason(controller.signal) : asError(error);
+      }).finally(() => {
+        if (this.flights.get(key) === current2) {
+          this.flights.delete(key);
+        }
+      });
+    }
+    if (background) {
+      flight.keepAlive = true;
+      void flight.promise.catch(() => {
+      });
+      return entry.value;
+    }
+    const current = flight;
+    current.users++;
+    return new Promise((resolve, reject) => {
+      let done = false;
+      const finish = (callback) => {
+        if (done) {
+          return;
+        }
+        done = true;
+        signal2?.removeEventListener("abort", abort);
+        current.users--;
+        callback();
+      };
+      const abort = () => {
+        finish(() => reject(abortReason(signal2)));
+        if (current.users === 0 && !current.keepAlive) {
+          current.controller.abort(abortReason(signal2));
+          if (this.flights.get(key) === current) {
+            this.flights.delete(key);
+          }
+        }
+      };
+      signal2?.addEventListener("abort", abort, { once: true });
+      current.promise.then(
+        (value) => finish(() => resolve(value)),
+        (error) => finish(() => reject(error))
+      );
+      if (signal2?.aborted) {
+        abort();
+      }
+    });
+  }
+};
+
+// ../sdk/src/internal/emitter.ts
+function createEmitter() {
+  const listeners = /* @__PURE__ */ new Map();
+  return {
+    on(event, fn) {
+      const set = listeners.get(event) ?? /* @__PURE__ */ new Set();
+      listeners.set(event, set);
+      set.add(fn);
+      return () => {
+        set.delete(fn);
+      };
+    },
+    emit(event, payload) {
+      for (const fn of [...listeners.get(event) ?? []]) {
+        try {
+          fn(payload);
+        } catch (error) {
+          console.error("Zappie event listener failed", error);
+        }
+      }
+    }
+  };
+}
+
+// ../sdk/src/transport/rest.ts
+var MAX_RETRY_WAIT_MS = 5e3;
+var RestTransport = class {
+  constructor(opts = {}) {
+    const url = new URL(opts.baseUrl ?? "https://api.zappie.ai/storefront/v1");
+    if (url.username || url.password || url.search || url.hash || url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) {
+      throw new ZappieError(
+        "invalid_request",
+        "REST baseUrl requires HTTPS, or HTTP on localhost"
+      );
+    }
+    this.baseUrl = url.href.replace(/\/$/, "");
+    this.fetcher = opts.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  }
+  async request(path4, ctx, etag, body) {
+    if (typeof window !== "undefined" && ctx.key.startsWith("sk_")) {
+      throw new ZappieError(
+        "invalid_request",
+        "Secret keys cannot be sent from a browser"
+      );
+    }
+    for (let attempt = 0; ; attempt++) {
+      throwIfAborted(ctx.signal);
+      let response;
+      try {
+        response = await this.fetcher(this.baseUrl + path4, {
+          method: body ? "POST" : "GET",
+          ...body ? { body: JSON.stringify(body) } : {},
+          // Workers reject redirect: "error"; a redirect is still refused below
+          // as a non-OK response (a 3xx, or opaqueredirect in browsers).
+          redirect: "manual",
+          headers: {
+            ...body ? { "Content-Type": "application/json" } : {},
+            ...ctx.idempotencyKey ? { "Idempotency-Key": ctx.idempotencyKey } : {},
+            Authorization: `Bearer ${ctx.key}`,
+            "Zappie-Version": ctx.version,
+            ...etag ? { "If-None-Match": etag } : {}
+          },
+          ...ctx.signal ? { signal: ctx.signal } : {}
+        });
+      } catch (error) {
+        throwIfAborted(ctx.signal);
+        if (attempt >= 2) {
+          throw new ZappieError(
+            "network_error",
+            "Could not reach the storefront service",
+            { cause: error }
+          );
+        }
+        await delay(100 * 2 ** attempt + Math.random() * 100, ctx.signal);
+        continue;
+      }
+      if (response.ok || response.status === 304) {
+        return response;
+      }
+      const retry = response.headers.get("Retry-After");
+      const seconds = retry !== null ? Number(retry) : NaN;
+      const wait2 = retry !== null ? Number.isFinite(seconds) ? Math.max(0, seconds * 1e3) : Math.max(0, Date.parse(retry) - Date.now()) : NaN;
+      const tooLong = Number.isFinite(wait2) && wait2 > MAX_RETRY_WAIT_MS;
+      if (attempt < 2 && !tooLong && (response.status === 429 || response.status >= 500)) {
+        await response.body?.cancel();
+        await delay(
+          Number.isFinite(wait2) ? wait2 : 100 * 2 ** attempt + Math.random() * 100,
+          ctx.signal
+        );
+        continue;
+      }
+      const errorBody = await response.json().catch(() => ({}));
+      throw wireError(
+        errorBody,
+        response.status,
+        response.headers.get("Zappie-Request-Id") ?? void 0
+      );
+    }
+  }
+  async json(response) {
+    try {
+      return await response.json();
+    } catch (cause) {
+      if (cause instanceof Error && cause.name === "AbortError") {
+        throw cause;
+      }
+      throw new ZappieError(
+        "server_error",
+        "The storefront service returned invalid JSON",
+        { status: response.status, cause }
+      );
+    }
+  }
+  async quote(ctx, body) {
+    const request = {
+      ...ctx,
+      idempotencyKey: ctx.idempotencyKey ?? await payloadKey(JSON.stringify(body))
+    };
+    const raw = await this.json(
+      await this.request("/quote", request, void 0, body)
+    );
+    return raw;
+  }
+  async getStore(ctx) {
+    const mapper = import("./store-KIO5RCZO.js").catch((cause) => {
+      throw new ZappieError(
+        "server_error",
+        "Could not load the storefront store mapper",
+        { cause }
+      );
+    });
+    const response = this.request("/store", ctx).then(
+      (value) => this.json(value)
+    );
+    const [{ mapStore }, raw] = await Promise.all([mapper, response]);
+    return mapStore(
+      raw,
+      record,
+      text,
+      list,
+      hours,
+      mapMoney,
+      money,
+      opt,
+      isString,
+      isBoolean
+    );
+  }
+  async getMenu(ctx) {
+    let cursor;
+    const seen = /* @__PURE__ */ new Set();
+    let output;
+    let etag;
+    do {
+      const query = new URLSearchParams({
+        branch: ctx.branchId,
+        ...ctx.metadataOnly ? { metadata_only: "true" } : {},
+        ...cursor ? { cursor } : {}
+      });
+      const response = await this.request(
+        `/menus?${query}`,
+        ctx,
+        cursor ? void 0 : ctx.ifNoneMatch
+      );
+      if (response.status === 304) {
+        if (cursor) {
+          throw new ZappieError(
+            "server_error",
+            "Unexpected 304 on a continuation page"
+          );
+        }
+        return {
+          notModified: true,
+          ...response.headers.get("ETag") ? { etag: response.headers.get("ETag") } : {}
+        };
+      }
+      const raw = record(await this.json(response));
+      const page = mapMenu(raw, ctx.branchId);
+      if (ctx.metadataOnly) {
+        if (Object.keys(page.items).length || raw.next_cursor) {
+          throw new ZappieError("server_error", "Invalid metadata response");
+        }
+        return { menu: { ...page, completeness: "partial" } };
+      }
+      if (!output) {
+        output = page;
+        etag = response.headers.get("ETag") ?? void 0;
+      } else {
+        if (page.version !== output.version) {
+          throw new ZappieError(
+            "server_error",
+            "Menu changed while fetching pages; retry the read"
+          );
+        }
+        Object.assign(output.items, page.items);
+        for (const category of page.categories) {
+          const existing = output.categories.find((c) => c.id === category.id);
+          if (existing) {
+            existing.itemIds = [
+              .../* @__PURE__ */ new Set([...existing.itemIds, ...category.itemIds])
+            ];
+          } else {
+            output.categories.push(category);
+          }
+        }
+        for (const section of page.menus ?? []) {
+          const existing = output.menus?.find((m) => m.id === section.id);
+          if (existing) {
+            existing.categoryIds = [
+              .../* @__PURE__ */ new Set([...existing.categoryIds, ...section.categoryIds])
+            ];
+          } else {
+            output.menus?.push(section);
+          }
+        }
+      }
+      cursor = typeof raw.next_cursor === "string" && raw.next_cursor ? raw.next_cursor : void 0;
+      if (cursor) {
+        if (seen.has(cursor)) {
+          throw new ZappieError(
+            "server_error",
+            "Repeated menu pagination cursor"
+          );
+        }
+        seen.add(cursor);
+      }
+    } while (cursor);
+    if (output.menus && output.menus.length > 1) {
+      output.id = `branch:${ctx.branchId}`;
+      output.name = "Catalogue";
+      delete output.schedule;
+    }
+    for (const category of output.categories) {
+      for (const id of category.itemIds) {
+        if (!Object.prototype.hasOwnProperty.call(output.items, id)) {
+          throw new ZappieError(
+            "server_error",
+            "Category refers to a missing item"
+          );
+        }
+      }
+    }
+    if (Object.keys(output.items).length > 2e3) {
+      console.warn("Zappie menu contains more than 2,000 items");
+    }
+    return { menu: output, ...etag ? { etag } : {} };
+  }
+  async getSelectedMenu(ctx) {
+    return (await import("./selected-menu-3GCAICBQ.js")).selectedMenu(
+      ctx,
+      (path4) => this.request(path4, ctx, ctx.ifNoneMatch),
+      (response) => this.json(response),
+      mapMenu,
+      () => new ZappieError("server_error", "Invalid selected menu")
+    );
+  }
+  async search(ctx) {
+    return (await import("./search-YIHT6CXN.js")).searchPage(
+      ctx,
+      async (path4) => this.json(await this.request(path4, ctx)),
+      mapMenu,
+      () => new ZappieError("server_error", "Invalid search page")
+    );
+  }
+  async getCategoryPage(ctx) {
+    const query = new URLSearchParams({
+      branch: ctx.branchId,
+      ...ctx.cursor ? { cursor: ctx.cursor } : {}
+    });
+    const raw = await this.json(
+      await this.request(
+        `/menus/${encodeURIComponent(ctx.menuId)}/categories/${encodeURIComponent(ctx.categoryId)}/items?${query}`,
+        ctx
+      )
+    );
+    return (await import("./category-page-UBHOB5IN.js")).categoryPage(
+      record(raw),
+      ctx,
+      mapMenu,
+      () => new ZappieError("server_error", "Invalid category page")
+    );
+  }
+  async getMenuVersion(ctx) {
+    const value = record(
+      await this.json(
+        await this.request(
+          `/menus/version?${new URLSearchParams({ branch: ctx.branchId })}`,
+          ctx
+        )
+      )
+    );
+    if (typeof value.menu_version !== "string" || typeof value.availability_hash !== "string") {
+      throw new ZappieError("server_error", "Invalid menu version response");
+    }
+    return {
+      version: value.menu_version,
+      availabilityHash: value.availability_hash
+    };
+  }
+  async getItem(ctx) {
+    const item = mapItem(
+      await this.json(
+        await this.request(
+          `/items/${encodeURIComponent(ctx.itemId)}?${new URLSearchParams({ branch: ctx.branchId })}`,
+          ctx
+        )
+      )
+    );
+    if (item.id !== ctx.itemId) {
+      throw new ZappieError(
+        "server_error",
+        "Item response identity does not match the request"
+      );
+    }
+    return item;
+  }
+};
+
+// ../sdk/src/client.ts
+function buildClient(input, secret = false) {
+  const mode = validateConfig(input, secret);
+  const config = Object.freeze({
+    ...input,
+    version: input.version ?? API_VERSION,
+    telemetry: input.telemetry ?? true
+  });
+  const transport = input.transport ?? new RestTransport({
+    ...input.baseUrl ? { baseUrl: input.baseUrl } : {},
+    ...input.fetch ? { fetch: input.fetch } : {}
+  });
+  const events = createEmitter();
+  const cache = new Cache((error) => events.emit("error", { error }));
+  const ctx = (signal2) => ({
+    key: config.key,
+    version: config.version,
+    ...signal2 ? { signal: signal2 } : {}
+  });
+  const store = {
+    get: (opts = {}) => cache.get(
+      "store",
+      async (signal2) => ({ value: await transport.getStore(ctx(signal2)) }),
+      opts.signal
+    ),
+    peek: () => cache.snapshot("store").value
+  };
+  const resolveBranch = (value, requested) => {
+    const selected = requested ?? config.branch;
+    const branch = selected ? value.branches.find((b) => b.id === selected || b.slug === selected) : value.branches.find((b) => b.isDefault) ?? value.branches[0];
+    if (!branch) {
+      throw new ZappieError(
+        "branch_not_found",
+        "No matching storefront branch",
+        { param: "branch" }
+      );
+    }
+    return branch;
+  };
+  let hydratedBranch;
+  const branchKey = (requested) => {
+    const value = store.peek();
+    if (value) {
+      return resolveBranch(value, requested).id;
+    }
+    const selected = requested ?? config.branch;
+    if (hydratedBranch && (selected === void 0 || selected === config.branch || selected === hydratedBranch)) {
+      return hydratedBranch;
+    }
+    return selected ?? "default";
+  };
+  const menuKey = (requested) => `menu:${branchKey(requested)}`;
+  const menu = {
+    async search(query, opts = {}) {
+      if (!transport.search) {
+        throw new ZappieError(
+          "invalid_request",
+          "Transport does not support search"
+        );
+      }
+      const branch = resolveBranch(await store.get(opts), opts.branch);
+      return transport.search({
+        ...ctx(opts.signal),
+        branchId: branch.id,
+        query,
+        ...opts.cursor ? { cursor: opts.cursor } : {}
+      });
+    },
+    async get(opts = {}) {
+      const branch = resolveBranch(await store.get(opts), opts.branch);
+      return cache.get(
+        `menu:${branch.id}${opts.metadataOnly ? ":partial" : ""}`,
+        async (signal2, entry) => {
+          const response = await transport.getMenu({
+            ...ctx(signal2),
+            branchId: branch.id,
+            ...opts.metadataOnly ? { metadataOnly: true } : {},
+            ...entry.etag ? { ifNoneMatch: entry.etag } : {}
+          });
+          if ("notModified" in response) {
+            if (!entry.value) {
+              throw new ZappieError(
+                "server_error",
+                "Received 304 without a cached menu"
+              );
+            }
+            return {
+              value: entry.value,
+              ...response.etag ?? entry.etag ? { etag: response.etag ?? entry.etag } : {}
+            };
+          }
+          if (!opts.metadataOnly && response.menu.completeness === "partial") {
+            throw new ZappieError(
+              "server_error",
+              "Partial catalogue cannot satisfy a complete read"
+            );
+          }
+          if (response.menu.branchId !== branch.id) {
+            throw new ZappieError(
+              "server_error",
+              "Menu belongs to a different branch"
+            );
+          }
+          return {
+            value: response.menu,
+            etag: response.etag ?? response.menu.version,
+            onStored: () => {
+              if (entry.value && entry.value.version !== response.menu.version) {
+                events.emit("menu:updated", {
+                  branchId: branch.id,
+                  version: response.menu.version
+                });
+              }
+            }
+          };
+        },
+        opts.signal
+      );
+    },
+    peek: (branch) => cache.snapshot(menuKey(branch)).value ?? cache.snapshot(`${menuKey(branch)}:partial`).value,
+    async page(menuId, categoryId, opts = {}) {
+      if (!transport.getCategoryPage) {
+        throw new ZappieError(
+          "invalid_request",
+          "Transport does not support category pages"
+        );
+      }
+      const branch = resolveBranch(await store.get(opts), opts.branch);
+      return transport.getCategoryPage({
+        ...ctx(opts.signal),
+        branchId: branch.id,
+        menuId,
+        categoryId,
+        ...opts.cursor ? { cursor: opts.cursor } : {}
+      });
+    },
+    async version(opts = {}) {
+      const branch = resolveBranch(await store.get(opts), opts.branch);
+      return transport.getMenuVersion({
+        ...ctx(opts.signal),
+        branchId: branch.id
+      });
+    },
+    async item(id, opts = {}) {
+      const branch = resolveBranch(await store.get(opts), opts.branch);
+      if (!menu.peek(branch.id) || menu.peek(branch.id)?.completeness === "partial") {
+        await menu.get({ ...opts, metadataOnly: true });
+      }
+      return readItem(id, branch.id, false, opts.signal);
+    },
+    hydrate(value) {
+      hydratedBranch ??= value.branchId;
+      const previous = cache.snapshot(`menu:${value.branchId}`).value;
+      cache.set(
+        `menu:${value.branchId}${value.completeness === "partial" ? ":partial" : ""}`,
+        value,
+        value.version
+      );
+      if (previous && previous.version !== value.version) {
+        events.emit("menu:updated", {
+          branchId: value.branchId,
+          version: value.version
+        });
+      }
+    }
+  };
+  const itemValues = /* @__PURE__ */ new Map();
+  const peekItem = (id, branch) => itemValues.get(`${branch}:${id}`);
+  const readItem = async (id, branch, fresh = false, signal2) => {
+    const complete = cache.snapshot(`menu:${branch}`).value;
+    if (!fresh && complete && Object.hasOwn(complete.items, id)) {
+      return complete.items[id];
+    }
+    const load = (requestSignal = signal2) => transport.getItem({
+      ...ctx(requestSignal),
+      branchId: branch,
+      itemId: id
+    });
+    try {
+      const value = fresh ? await load() : await cache.get(
+        `item:${branch}:${id}`,
+        async (requestSignal) => ({ value: await load(requestSignal) }),
+        signal2
+      );
+      if (fresh) {
+        cache.set(`item:${branch}:${id}`, value);
+      }
+      itemValues.set(`${branch}:${id}`, value);
+      return value;
+    } catch (error) {
+      if (error.code === "item_not_found") {
+        itemValues.delete(`${branch}:${id}`);
+        cache.set(`item:${branch}:${id}`, void 0);
+      }
+      throw error;
+    }
+  };
+  const workingSet = createWorkingSet({
+    menu,
+    store,
+    transport,
+    context: ctx,
+    peekItem,
+    readItem
+  });
+  const { cart, setLegacyReader, cartCatalogue } = createCart({
+    workingSet,
+    config,
+    menu,
+    store,
+    transport,
+    context: ctx,
+    events
+  });
+  return Object.freeze({
+    cart,
+    config,
+    mode,
+    store,
+    menu,
+    format,
+    on: events.on,
+    _internal: {
+      cartCatalogue,
+      setLegacyReader,
+      transport,
+      cache,
+      emit: events.emit,
+      menuKey,
+      hydrateStore: (value) => cache.set("store", value)
+    }
+  });
+}
+function createZappie(config) {
+  const client = buildClient(config);
+  if (client.mode === "test" && typeof window !== "undefined") {
+    void import("./debug-C3UDGUED.js").then(({ installDebug }) => installDebug(client));
+  }
+  return client;
+}
+
+// ../sdk/src/cart/preview.ts
+function previewQuantity(value) {
+  return Number.isInteger(value) && value >= 0 && value <= 99 ? value : 0;
+}
+function previewItem(item, raw) {
+  const input = normalizeInput(item, raw);
+  const groups = effectiveGroups(item, input).filter(
+    (group) => group.isAvailable !== false
+  );
+  const variantId = resolveVariant(item, input)?.id;
+  const choices = (input.choices ?? []).filter(
+    ({ groupId, choiceId }) => groups.some(
+      (group) => group.id === groupId && group.choices.some((choice) => choice.id === choiceId)
+    )
+  ).map((selection) => ({
+    ...selection,
+    quantity: previewQuantity(selection.quantity)
+  }));
+  const unitPrice = estimateUnitPrice(item, {
+    choices,
+    ...variantId ? { variantId } : {}
+  });
+  const total = multiplyMoney(unitPrice, previewQuantity(input.quantity));
+  return { groups, unitPrice, total };
+}
+
+// src/fixtures.ts
+async function installFault(page, fault) {
+  if (!fault) {
+    return;
+  }
+  if (fault === "no-sold-out") {
+    await page.addInitScript(() => {
+      let debug;
+      Object.defineProperty(window, "__zappie", {
+        configurable: true,
+        get: () => debug,
+        set(value) {
+          debug = value;
+          if (value) {
+            const catalogue = value.catalogue;
+            value.catalogue = async () => {
+              const result = await catalogue();
+              return {
+                ...result,
+                menu: {
+                  ...result.menu,
+                  items: Object.fromEntries(
+                    Object.entries(result.menu.items).filter(
+                      ([, item]) => item.isAvailable
+                    )
+                  )
+                }
+              };
+            };
+          }
+        }
+      });
+    });
+  }
+  if (fault === "add-stuck") {
+    await page.addInitScript(() => {
+      document.addEventListener(
+        "click",
+        (event) => {
+          const target2 = event.target;
+          if (target2?.closest('[data-zappie-action="add-to-cart"]')) {
+            event.stopImmediatePropagation();
+            event.preventDefault();
+          }
+        },
+        true
+      );
+    });
+  }
+  if (fault === "missing-issue-fix") {
+    await page.addInitScript(() => {
+      new MutationObserver(() => {
+        for (const node of document.querySelectorAll(
+          "[data-zappie-issue-fix]"
+        )) {
+          node.removeAttribute("data-zappie-issue-fix");
+        }
+      }).observe(document, { childList: true, subtree: true });
+    });
+  }
+  if (fault === "wrong-total") {
+    await page.addInitScript(() => {
+      new MutationObserver(() => {
+        for (const node of document.querySelectorAll("[data-zappie-total]")) {
+          if (node.textContent !== "Total \u20A61") {
+            node.textContent = "Total \u20A61";
+          }
+        }
+      }).observe(document, { childList: true, subtree: true });
+    });
+  }
+}
+async function applyPageFault(page, fault) {
+  if (fault === "missing-marker") {
+    await page.locator("[data-zappie-item]").evaluateAll((nodes) => {
+      for (const node of nodes) {
+        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);
+    });
+  }
+  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)}`
+      })
+    );
+  }
+}
+
+// src/checks/catalogue.ts
+async function readMenu(options) {
+  const client = createZappie({
+    store: options.store,
+    key: options.key,
+    ...process.env.ZAPPIE_VERIFY_API_URL ? { baseUrl: process.env.ZAPPIE_VERIFY_API_URL } : {}
+  });
+  const store = await client.store.get();
+  const branch = store.branches.find((entry) => entry.isDefault) ?? store.branches[0];
+  assertion(
+    branch,
+    "default_branch_missing",
+    "The store has no branch",
+    "Mark an orderable branch as the default."
+  );
+  return client.menu.get({ branch: branch.id });
+}
+function sortedItems(menu) {
+  return Object.values(menu.items).sort((a, b) => a.id.localeCompare(b.id));
+}
+function simpleItem(menu) {
+  return sortedItems(menu).find(
+    (item) => item.isAvailable && !item.optionGroups.some((group) => group.required)
+  );
+}
+function configurableItem(menu) {
+  return sortedItems(menu).find(
+    (item) => item.isAvailable && item.optionGroups.some((group) => group.required)
+  );
+}
+
+// src/checks/menu-match.ts
+function menuCoverage(items, shownIds) {
+  const available = items.filter((item) => item.isAvailable);
+  const shown = available.filter((item) => shownIds.has(item.id)).length;
+  return {
+    available: available.length,
+    shown,
+    passes: available.length === 0 || shown / available.length >= 0.95
+  };
+}
+function priceMatches(text2, formatted) {
+  return text2?.includes(formatted) ?? false;
+}
+
+// src/checks/v03-menu.ts
+var v03 = {
+  id: "V03",
+  title: "Menu matches store",
+  viewports: "mobile",
+  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"]`
+      );
+      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 text2 = await page.locator(`[data-zappie-item="${item.id}"]`).first().textContent();
+      assertion(
+        priceMatches(text2, format.money(item.price)),
+        "price_mismatch",
+        `${item.name} does not show ${format.money(item.price)}`,
+        "Render prices with format.money from @zappie/sdk."
+      );
+    }
+  }
+};
+
+// src/checks/v04-add-simple.ts
+var v04 = {
+  id: "V04",
+  title: "Add an item without required options",
+  viewports: "both",
+  async run({ page, options, fault }, viewport) {
+    await page.setViewportSize(viewport);
+    await open(page);
+    await applyPageFault(page, fault);
+    const before = await debugValue(page, () => window.__zappie.cart().count);
+    const item = simpleItem(await readMenu(options));
+    assertion(
+      item,
+      "simple_item_missing",
+      "The test menu has no available item without required options",
+      "Keep one available item without required options in the test menu."
+    );
+    const simple = page.locator(`[data-zappie-item="${item.id}"]`).locator('[data-zappie-action="add-to-cart"]');
+    assertion(
+      await simple.count(),
+      "simple_item_missing",
+      "The item has no quick-add button",
+      "Render an available item without required options and mark its add button."
+    );
+    await simple.click();
+    const updated = await page.evaluate(
+      (count) => new Promise((resolve) => {
+        requestAnimationFrame(() => {
+          resolve(window.__zappie.cart().count > count);
+        });
+      }),
+      before
+    );
+    assertion(
+      updated,
+      "cart_not_updated",
+      "The cart count did not change within one frame of Add",
+      "Connect the marked Add control to client.cart.add and update its count immediately."
+    );
+    const event = await debugValue(
+      page,
+      () => window.__zappie.events.some((entry) => entry.name === "add_to_cart")
+    );
+    assertion(
+      event,
+      "add_event_missing",
+      "The SDK did not record add_to_cart",
+      "Use the SDK cart add action to record the test-mode event."
+    );
+  }
+};
+
+// src/checks/v05-add-options.ts
+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));
+    assertion(
+      selected,
+      "required_item_missing",
+      "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();
+    const dialog = page.getByRole("dialog");
+    await dialog.waitFor();
+    const required = dialog.locator('[data-zappie-option-group][aria-required="true"]').first();
+    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."
+    );
+    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();
+      assertion(
+        await unsatisfied.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();
+    }
+    assertion(
+      await add.isEnabled(),
+      "required_option_unselectable",
+      "Valid choices did not enable Add",
+      "Recheck the item selection when required choices change."
+    );
+    await add.click();
+    await dialog.waitFor({ state: "hidden" });
+    await page.waitForFunction(
+      (count) => window.__zappie.cart().count > count,
+      before
+    );
+    const lineHasChoices = await page.evaluate(
+      (itemId) => window.__zappie.cart().lines.some(
+        (line) => line.itemId === itemId && line.choices.length > 0
+      ),
+      selected.id
+    );
+    assertion(
+      lineHasChoices,
+      "selected_options_missing",
+      "The added line has no selected options",
+      "Pass ItemForm choices to the SDK cart add action."
+    );
+  }
+};
+
+// src/checks/v06-quote.ts
+var v06 = {
+  id: "V06",
+  title: "Cart quote and total",
+  viewports: "both",
+  async run({ page }, viewport) {
+    await page.setViewportSize(viewport);
+    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();
+    }
+    await page.waitForFunction(
+      () => window.__zappie.events.some((entry) => entry.name === "quote"),
+      void 0,
+      { timeout: 2e3 }
+    );
+    const quote = await page.evaluate(() => window.__zappie.quote());
+    assertion(
+      quote,
+      "quote_missing",
+      "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();
+    assertion(
+      rendered?.includes(format.money(quote.total)),
+      "total_mismatch",
+      `Rendered total does not match ${format.money(quote.total)}`,
+      "Render quote.total with the SDK Money formatter."
+    );
+  }
+};
+
+// src/checks/stale-cart.ts
+function orderableLine(menu, branch, item) {
+  for (const source of menu.menus ?? [{ id: menu.id }]) {
+    const menuId = resolveSourceMenu(menu, item.id, source.id);
+    if (!menuId) {
+      continue;
+    }
+    for (const variant of item.variants.filter((value) => value.isAvailable)) {
+      const line = {
+        itemId: item.id,
+        menuId,
+        variantId: variant.id,
+        quantity: Math.ceil(item.quantity.min / item.quantity.step) * item.quantity.step,
+        choices: Object.entries(variant.attributeChoices).map(
+          ([groupId, choiceId]) => ({ groupId, choiceId, quantity: 1 })
+        ),
+        inputs: {}
+      };
+      for (let round = 0; round <= item.optionGroups.length; round++) {
+        const { groups } = previewItem(item, line);
+        for (const group of groups) {
+          if (group.isAttribute || group.isInformational) {
+            continue;
+          }
+          const minimum = Math.max(group.selection.min, group.required ? 1 : 0);
+          if (group.kind === "select") {
+            const selected = line.choices.filter(
+              (choice) => choice.groupId === group.id
+            );
+            for (const choice of group.choices.filter(
+              (value) => value.isAvailable
+            )) {
+              if (selected.length >= minimum) {
+                break;
+              }
+              if (!selected.some((value) => value.choiceId === choice.id)) {
+                const value = {
+                  groupId: group.id,
+                  choiceId: choice.id,
+                  quantity: choice.quantity?.min ?? 1
+                };
+                line.choices.push(value);
+                selected.push(value);
+              }
+            }
+          } else if (group.required) {
+            const values = {
+              number: "1",
+              date: "2026-01-01",
+              time: "12:00",
+              toggle: "true",
+              text: "Verify"
+            };
+            line.inputs[group.id] = values[group.kind].slice(
+              0,
+              group.input?.maxLength
+            );
+          }
+        }
+        if (validateLine(item, line, { menu, branch }).length === 0) {
+          return {
+            ...line,
+            unitPrice: previewItem(item, line).unitPrice
+          };
+        }
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/checks/v07-quote-issues.ts
+var v07 = {
+  id: "V07",
+  title: "Handle quote issues",
+  viewports: "mobile",
+  async run({ page }, viewport) {
+    await page.setViewportSize(viewport);
+    await open(page);
+    await page.waitForFunction(() => window.__zappie?.cart().isHydrated);
+    const debug = await page.evaluate(() => ({
+      inject: typeof window.__zappie?.cart.inject === "function",
+      branch: window.__zappie?.cart().branchId
+    }));
+    assertion(
+      debug.inject,
+      "cart_inject_missing",
+      "The test cart has no inject method",
+      "Use an SDK version that exposes cart.inject with a public test key."
+    );
+    const { menu, branch } = await page.evaluate(
+      () => window.__zappie.catalogue()
+    );
+    const items = Object.values(menu.items).sort(
+      (a, b) => a.id.localeCompare(b.id)
+    );
+    const available = items.filter((item) => item.isAvailable).map((item) => orderableLine(menu, branch, item)).find((line) => line !== void 0);
+    assertion(
+      available,
+      "orderable_item_missing",
+      "The branch has no item that verify can order",
+      "Keep an available item with valid choices in this branch's menu."
+    );
+    const unavailable = items.find((item) => !item.isAvailable);
+    const lines = [
+      {
+        ...available,
+        unitPrice: {
+          ...available.unitPrice,
+          amountMinor: available.unitPrice.amountMinor === 0 ? 1 : 0
+        }
+      }
+    ];
+    if (unavailable) {
+      const menuId = (menu.menus ?? [{ id: menu.id }]).map((source) => resolveSourceMenu(menu, unavailable.id, source.id)).find(Boolean);
+      lines.push({
+        quantity: 1,
+        itemId: unavailable.id,
+        ...menuId ? { menuId } : {},
+        variantId: unavailable.variants[0].id,
+        choices: [],
+        inputs: {},
+        unitPrice: unavailable.variants[0].price
+      });
+    }
+    await page.evaluate(async (lines2) => {
+      await window.__zappie.cart.inject({ lines: lines2 });
+    }, lines);
+    await page.reload({ waitUntil: "domcontentloaded" });
+    await page.locator("[data-zappie-cart-trigger]").first().click();
+    const codes = unavailable ? ["price_changed", "item_unavailable"] : ["price_changed"];
+    for (const code of codes) {
+      const issue2 = page.locator(`[data-zappie-issue="${code}"]`).first();
+      await issue2.waitFor({ state: "visible" });
+      assertion(
+        await issue2.isVisible(),
+        "quote_issue_missing",
+        `The cart does not show ${code}`,
+        "Render each quote issue with data-zappie-issue and its fixes with data-zappie-issue-fix."
+      );
+    }
+    for (const code of codes) {
+      const issue2 = page.locator(`[data-zappie-issue="${code}"]`).first();
+      const fix = issue2.locator("[data-zappie-issue-fix]").first();
+      assertion(
+        await fix.count(),
+        "quote_fix_missing",
+        `The cart has no fix for ${code}`,
+        "Connect each marked issue fix to the SDK cart applyFix action."
+      );
+      await fix.click();
+      await issue2.waitFor({ state: "hidden" });
+    }
+    await open(page, "/checkout");
+    await page.waitForFunction(() => {
+      const cart = window.__zappie?.cart();
+      return cart && cart.issues.length === 0 && "quote" in cart.state && cart.state.quote?.checkout.ready;
+    });
+    assertion(
+      await page.locator("[data-zappie-issue]").count() === 0,
+      "quote_issues_remain",
+      "The cart still shows issues after both fixes",
+      "Remove resolved issue messages when the SDK cart updates."
+    );
+    await page.waitForFunction(() => {
+      const control = document.querySelector(
+        "[data-zappie-checkout]"
+      );
+      return control && !control.disabled;
+    });
+    assertion(
+      await page.locator("[data-zappie-checkout]").isEnabled(),
+      "checkout_not_ready",
+      "Checkout is disabled after the quote issues clear",
+      "Enable checkout when the SDK quote is ready and the cart has no blocking issue."
+    );
+    assertion(
+      unavailable,
+      "dependency_blocked",
+      "The price-change checks passed, but the unavailable-item checks need a sold-out item",
+      "Keep one sold-out item in this branch's menu to check its issue and removal fix."
+    );
+  }
+};
+
+// src/checks/v09-pickup.ts
+var v09 = {
+  id: "V09",
+  title: "Pickup",
+  viewports: "mobile",
+  async run({ page }, viewport) {
+    await page.setViewportSize(viewport);
+    await open(page, "/checkout");
+    const pickup = page.locator('[data-zappie-fulfilment="pickup"]');
+    await pickup.waitFor();
+    assertion(
+      await pickup.count(),
+      "pickup_missing",
+      "Pickup control is missing",
+      "Render a pickup control with data-zappie-fulfilment=pickup."
+    );
+    await pickup.click();
+    await page.waitForFunction(
+      () => window.__zappie.cart().fulfilment?.type === "pickup"
+    );
+    await page.waitForFunction(() => Boolean(window.__zappie.quote()));
+    const quote = await debugValue(page, () => window.__zappie.quote());
+    assertion(
+      !quote?.delivery || quote.delivery.amountMinor === 0,
+      "pickup_delivery_fee",
+      "Pickup quote includes a delivery fee",
+      "Send pickup fulfilment to the SDK cart before quoting."
+    );
+  }
+};
+
+// ../sdk/src/internal/customer-http.ts
+function stableErrorCode(status) {
+  if (status === 400 || status === 422) {
+    return "invalid_request";
+  }
+  if (status === 401) {
+    return "unauthorized";
+  }
+  if (status === 404) {
+    return "not_found";
+  }
+  if (status === 429) {
+    return "rate_limited";
+  }
+  return "server_error";
+}
+async function apiError(response, fallback) {
+  const body = await response.json().catch(() => ({}));
+  const envelope = body && typeof body === "object" ? body : {};
+  const value = "error" in envelope && envelope.error && typeof envelope.error === "object" ? envelope.error : {};
+  return {
+    apiCode: "code" in value && typeof value.code === "string" ? value.code : "server_error",
+    message: "message" in value && typeof value.message === "string" ? value.message : fallback,
+    ..."param" in value && typeof value.param === "string" ? { param: value.param } : {},
+    ..."issues" in value ? { issues: value.issues } : {}
+  };
+}
+function wait(ms, signal2) {
+  signal2?.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const done = () => {
+      signal2?.removeEventListener("abort", aborted2);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    const aborted2 = () => {
+      clearTimeout(timer);
+      signal2?.removeEventListener("abort", aborted2);
+      reject(signal2?.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    signal2?.addEventListener("abort", aborted2, { once: true });
+  });
+}
+async function requestWithRetry(fetcher, input, init, message) {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      return await fetcher(input, {
+        ...init,
+        credentials: "same-origin",
+        headers: { Accept: "application/json", ...init.headers }
+      });
+    } catch (cause) {
+      if (init.signal?.aborted) {
+        throw init.signal.reason ?? cause;
+      }
+      if (attempt === 1) {
+        throw new ZappieError("network_error", message, {
+          cause,
+          retryable: true
+        });
+      }
+      await wait(400, init.signal ?? void 0);
+    }
+  }
+  throw new ZappieError("network_error", message, { retryable: true });
+}
+
+// ../sdk/src/places/error.ts
+var PlacesError = class extends ZappieError {
+  constructor(status, apiCode, message, param, issues) {
+    super(stableErrorCode(status), message, {
+      status,
+      retryable: status === 429 || status >= 500,
+      ...param !== void 0 ? { param } : {}
+    });
+    this.apiCode = apiCode;
+    if (issues !== void 0) {
+      this.issues = issues;
+    }
+  }
+};
+
+// ../sdk/src/places/request.ts
+function createPlacesRequest(base, key, version, fetcher) {
+  return async (path4, init = {}) => {
+    const response = await requestWithRetry(
+      fetcher,
+      base + path4,
+      {
+        ...init,
+        // Workers reject redirect: "error"; !response.ok below refuses a redirect.
+        redirect: "manual",
+        headers: {
+          Authorization: `Bearer ${key}`,
+          "Zappie-Version": version,
+          ...init.headers
+        }
+      },
+      "Could not reach the places service"
+    );
+    if (!response.ok) {
+      const value = await apiError(
+        response,
+        `The places service answered ${response.status}`
+      );
+      throw new PlacesError(
+        response.status,
+        value.apiCode,
+        value.message,
+        value.param,
+        value.issues
+      );
+    }
+    return await response.json();
+  };
+}
+
+// ../sdk/src/places/search.ts
+var aborted = () => new DOMException("Superseded", "AbortError");
+function createAddressSearch(client, options = {}) {
+  const debounceMs = options.debounceMs ?? 250;
+  let token = crypto.randomUUID();
+  let controller;
+  let timer;
+  let rejectPending;
+  let revision = 0;
+  const cancel = () => {
+    revision++;
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    controller?.abort(aborted());
+    controller = void 0;
+    rejectPending?.(aborted());
+    rejectPending = void 0;
+  };
+  return {
+    suggest(query) {
+      cancel();
+      const current = revision;
+      if (!query.trim()) {
+        return Promise.resolve([]);
+      }
+      return new Promise((resolve, reject) => {
+        rejectPending = reject;
+        timer = setTimeout(async () => {
+          timer = void 0;
+          controller = new AbortController();
+          try {
+            const value = await client.autocomplete(query.trim(), token, {
+              signal: controller.signal
+            });
+            if (current === revision) {
+              resolve(value);
+            }
+          } catch (failure) {
+            if (current === revision) {
+              reject(failure);
+            }
+          } finally {
+            if (current === revision) {
+              rejectPending = void 0;
+              controller = void 0;
+            }
+          }
+        }, debounceMs);
+      });
+    },
+    async select(placeId) {
+      cancel();
+      const current = revision;
+      controller = new AbortController();
+      try {
+        const value = await client.place(placeId, {
+          ...options.branchId !== void 0 ? { branchId: options.branchId } : {},
+          sessionToken: token,
+          signal: controller.signal
+        });
+        if (current !== revision) {
+          throw aborted();
+        }
+        token = crypto.randomUUID();
+        return value;
+      } finally {
+        if (current === revision) {
+          controller = void 0;
+        }
+      }
+    },
+    dispose: cancel
+  };
+}
+
+// ../sdk/src/places/client.ts
+var DEFAULT_CUSTOMER_BASE = "/_zappie/api";
+function createPlaces(options) {
+  validateConfig({ store: "places", key: options.key });
+  const base = new RestTransport({
+    ...options.baseUrl ? { baseUrl: options.baseUrl } : {},
+    ...options.fetch ? { fetch: options.fetch } : {}
+  }).baseUrl;
+  const customerBase = (options.customerBase ?? DEFAULT_CUSTOMER_BASE).replace(
+    /\/+$/,
+    ""
+  );
+  const request = createPlacesRequest(
+    base,
+    options.key,
+    options.version ?? API_VERSION,
+    options.fetch ?? globalThis.fetch
+  );
+  const readPlace = (id, read) => {
+    const params = new URLSearchParams();
+    if (read.branchId !== void 0) {
+      params.set("branch_id", read.branchId);
+    }
+    if (read.sessionToken !== void 0) {
+      params.set("session", read.sessionToken);
+    }
+    const suffix = params.size > 0 ? `?${params}` : "";
+    return request(`/places/${encodeURIComponent(id)}${suffix}`, {
+      method: "GET",
+      ...read.signal ? { signal: read.signal } : {}
+    });
+  };
+  const client = {
+    async autocomplete(query, sessionToken, read = {}) {
+      if (!query.trim()) {
+        return [];
+      }
+      const params = new URLSearchParams({
+        q: query.trim(),
+        session: sessionToken
+      });
+      const result = await request(
+        `/places/autocomplete?${params}`,
+        { method: "GET", ...read.signal ? { signal: read.signal } : {} }
+      );
+      return result.suggestions;
+    },
+    place(id, read) {
+      return readPlace(id, read);
+    },
+    reverse(lat, lng, read = {}) {
+      const params = new URLSearchParams({
+        lat: String(lat),
+        lng: String(lng)
+      });
+      return request(`/places/reverse?${params}`, {
+        method: "GET",
+        ...read.signal ? { signal: read.signal } : {}
+      });
+    },
+    staticMapUrl(lat, lng, branchId) {
+      const params = new URLSearchParams({
+        lat: String(lat),
+        lng: String(lng)
+      });
+      if (branchId !== void 0) {
+        params.set("branch_id", branchId);
+      }
+      return `${customerBase}/places/static-map?${params}`;
+    },
+    zoneCheck(body, read = {}) {
+      return request("/delivery/zones/check", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        ...read.signal ? { signal: read.signal } : {}
+      });
+    },
+    createAddressSearch(searchOptions = {}) {
+      return createAddressSearch(
+        {
+          autocomplete: client.autocomplete,
+          place: readPlace
+        },
+        searchOptions
+      );
+    }
+  };
+  return client;
+}
+
+// src/checks/v10-delivery.ts
+var ADDRESS = "12 Admiralty Way, Lekki";
+var v10 = {
+  id: "V10",
+  title: "Delivery",
+  viewports: "mobile",
+  async run({ page, options }, viewport) {
+    await page.setViewportSize(viewport);
+    await open(page, "/checkout");
+    const delivery = page.locator('[data-zappie-fulfilment="delivery"]');
+    await delivery.waitFor();
+    assertion(
+      await delivery.count(),
+      "delivery_missing",
+      "Delivery control is missing",
+      "Render a delivery control with data-zappie-fulfilment=delivery."
+    );
+    await delivery.click();
+    const input = page.locator("[data-zappie-address-input]");
+    await input.waitFor();
+    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);
+    });
+    const fulfilment = await debugValue(
+      page,
+      () => window.__zappie.cart().fulfilment
+    );
+    assertion(
+      fulfilment?.type === "delivery",
+      "delivery_address_missing",
+      "The selected address was not stored",
+      "Store the resolved address on delivery fulfilment."
+    );
+    await page.waitForFunction(
+      () => (window.__zappie.quote()?.delivery?.amountMinor ?? 0) > 0
+    );
+    const quote = await debugValue(page, () => window.__zappie.quote());
+    assertion(
+      (quote?.delivery?.amountMinor ?? 0) > 0,
+      "delivery_fee_missing",
+      "The delivery quote has no delivery fee",
+      "Quote the selected delivery zone and include its fee."
+    );
+    const places = createPlaces({
+      key: options.key,
+      ...process.env.ZAPPIE_VERIFY_API_URL ? { baseUrl: process.env.ZAPPIE_VERIFY_API_URL } : {}
+    });
+    const zone = await places.zoneCheck({
+      branch_id: fulfilment.branchId,
+      address: {
+        line1: fulfilment.address.line1,
+        ...fulfilment.address.placeId ? { place_id: fulfilment.address.placeId } : {},
+        ...fulfilment.address.coordinates ? {
+          lat: fulfilment.address.coordinates.lat,
+          lng: fulfilment.address.coordinates.lng
+        } : {}
+      }
+    });
+    assertion(
+      zone.deliverable && zone.fee,
+      "delivery_zone_failed",
+      "The test address is not deliverable",
+      "Make the test-mode zone check accept 12 Admiralty Way, Lekki and return its fee."
+    );
+  }
+};
+
+// src/checks/v13-accessibility.ts
+import AxeBuilder from "@axe-core/playwright";
+async function severeViolations(page) {
+  const analysis = await new AxeBuilder({ page }).analyze();
+  return analysis.violations.filter(
+    (entry) => entry.impact === "critical" || entry.impact === "serious"
+  );
+}
+async function controlsAreReachable(page, selectors) {
+  const reached = /* @__PURE__ */ new Set();
+  for (let index = 0; index < 60; index++) {
+    await page.keyboard.press("Tab");
+    const match = await page.evaluate((values) => {
+      return values.findIndex(
+        (value) => document.activeElement?.closest(value)
+      );
+    }, selectors);
+    if (match >= 0) {
+      reached.add(match);
+    }
+    if (reached.size === selectors.length) {
+      return true;
+    }
+  }
+  return false;
+}
+var v13 = {
+  id: "V13",
+  title: "Accessibility",
+  viewports: "both",
+  async run({ page, context, options, fault }, viewport) {
+    await page.setViewportSize(viewport);
+    await open(page);
+    await applyPageFault(page, fault);
+    const violations = await severeViolations(page);
+    const item = sortedItems(await readMenu(options)).find(
+      (entry) => entry.isAvailable
+    );
+    assertion(
+      item,
+      "available_item_missing",
+      "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();
+    violations.push(...await severeViolations(page));
+    await page.getByRole("button", { name: "Close item" }).click();
+    await page.locator("[data-zappie-cart-trigger]").first().click();
+    violations.push(...await severeViolations(page));
+    const message = violations.flatMap(
+      (entry) => entry.nodes.map((node) => `${entry.id}: ${node.target.join(" ")}`)
+    ).join(", ");
+    assertion(
+      violations.length === 0,
+      "accessibility_violation",
+      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: "/"
+      }
+    ]);
+    await open(page, "/orders/order_fixture");
+    const order = await severeViolations(page);
+    assertion(
+      order.length === 0,
+      "order_accessibility_violation",
+      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);
+    assertion(
+      await controlsAreReachable(page, [
+        '[data-zappie-action="add-to-cart"]',
+        "[data-zappie-cart-trigger]"
+      ]),
+      "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");
+    await page.waitForFunction(
+      () => !document.querySelector("[data-zappie-checkout]")?.disabled
+    );
+    assertion(
+      await controlsAreReachable(page, ["[data-zappie-checkout]"]),
+      "checkout_keyboard_unreachable",
+      "Keyboard navigation did not reach the checkout control",
+      "Keep the enabled checkout control in the tab order and add its verify marker."
+    );
+  }
+};
+
+// src/checks/v14-performance.ts
+var v14 = {
+  id: "V14",
+  title: "Performance budget",
+  viewports: "mobile",
+  async run({ page, metrics, fault }, viewport) {
+    await page.setViewportSize(viewport);
+    const cdp = await page.context().newCDPSession(page);
+    await cdp.send("Network.enable");
+    await cdp.send("Network.setCacheDisabled", { cacheDisabled: true });
+    await cdp.send("Network.emulateNetworkConditions", {
+      offline: false,
+      latency: 150,
+      downloadThroughput: 2e5,
+      uploadThroughput: 1e5,
+      connectionType: "cellular3g"
+    });
+    await cdp.send("Emulation.setCPUThrottlingRate", { rate: 4 });
+    await page.addInitScript(() => {
+      const state = { lcp: 0, cls: 0 };
+      Object.assign(window, { __zappiePerformance: state });
+      new PerformanceObserver((list2) => {
+        state.lcp = Math.max(
+          state.lcp,
+          ...list2.getEntries().map((entry) => entry.startTime)
+        );
+      }).observe({ type: "largest-contentful-paint", buffered: true });
+      new PerformanceObserver((list2) => {
+        state.cls += list2.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" });
+    }
+    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 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 };
+    });
+    metrics.menuJsKbGz = Math.round(values.js / 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/index.ts
+var checks = [
+  v01,
+  v02,
+  v03,
+  v04,
+  v05,
+  v06,
+  v07,
+  v09,
+  v10,
+  v13,
+  v14
+];
+var blocked = [
+  [
+    "V08",
+    "Test customer sign-in",
+    "Add the PRD 12/13 test accounts to run this check."
+  ],
+  [
+    "V11",
+    "Check out with each payment method",
+    "Set up payment sandboxes and the PRD 11 embed to run this check."
+  ],
+  [
+    "V12",
+    "Order status page",
+    "Add POST /test/orders/{id}/advance to run this check."
+  ]
+];
+function skippedChecks(suite) {
+  const standard = blocked.map(([id, title, message]) => ({
+    id,
+    title,
+    result: "skipped",
+    durationMs: 0,
+    error: { code: "dependency_blocked", message, hint: message }
+  }));
+  if (suite === "standard") {
+    return standard;
+  }
+  return [
+    ...standard,
+    ...Array.from({ length: 6 }, (_, index) => ({
+      id: `E0${index + 1}`,
+      title: "Extended payment checks",
+      result: "skipped",
+      durationMs: 0,
+      error: {
+        code: "dependency_blocked",
+        message: "The extended suite needs the payment elements from PRD 27.",
+        hint: "Implement PRD 27 before you enable the extended suite."
+      }
+    }))
+  ];
+}
+
+// src/report.ts
+import { createPrivateKey, randomUUID, sign } from "crypto";
+var REPORT_SCHEMA = "https://zappie.ai/schemas/verify-report.v1.json";
+function reportId() {
+  return `ver_${randomUUID().replaceAll("-", "")}`;
+}
+function summarize(checks2) {
+  return {
+    passed: checks2.filter((check) => check.result === "passed").length,
+    failed: checks2.filter((check) => check.result === "failed").length,
+    skipped: checks2.filter((check) => check.result === "skipped").length
+  };
+}
+function signReport(report, key) {
+  if (!key) {
+    return report;
+  }
+  const payload = JSON.stringify(report);
+  return {
+    ...report,
+    signature: sign(
+      null,
+      new TextEncoder().encode(payload),
+      createPrivateKey(key)
+    ).toString("base64")
+  };
+}
+function printSummary(report) {
+  const lines = report.checks.map((check) => {
+    const suffix = check.error ? ` \u2014 ${check.error.message}` : "";
+    return `${check.result.toUpperCase().padEnd(7)} ${check.id} ${check.title}${suffix}`;
+  });
+  lines.push(
+    `${report.result.toUpperCase()}: ${report.summary.passed} passed, ${report.summary.failed} failed, ${report.summary.skipped} skipped`,
+    report.signature ? "Report signed (ed25519)." : "Report unsigned."
+  );
+  return lines.join("\n");
+}
+function target(options) {
+  const url = new URL(options.url);
+  return {
+    url: url.href,
+    origin: url.origin,
+    store: options.store,
+    ...options.siteId ? { siteId: options.siteId } : {},
+    ...options.deploymentId ? { deploymentId: options.deploymentId } : {}
+  };
+}
+
+// src/reset.ts
+async function reset(options) {
+  const started = performance.now();
+  try {
+    const response = await fetch(new URL("/test/reset", options.url), {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${options.key}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ store: options.store }),
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    if (response.ok) {
+      return {
+        id: "RESET",
+        title: "Reset test data",
+        result: "passed",
+        durationMs: performance.now() - started
+      };
+    }
+  } catch {
+  }
+  return {
+    id: "RESET",
+    title: "Reset test data",
+    result: "skipped",
+    durationMs: performance.now() - started,
+    error: {
+      code: "reset_unavailable",
+      message: "POST /test/reset is not available.",
+      hint: "Add the PRD 09 /test/reset endpoint so each verification run starts with fresh test data."
+    }
+  };
+}
+
+// src/version.ts
+var PACKAGE_VERSION = true ? "0.1.1" : "0.0.0-development";
+
+// src/runner.ts
+var VERSION = PACKAGE_VERSION;
+var browserOptions = (options) => ({
+  viewport: mobile,
+  baseURL: options.url
+});
+function selectedViewports(check, options) {
+  const configured = options.viewports ?? [mobile, desktop];
+  return check.viewports === "mobile" ? [configured[0] ?? mobile] : configured;
+}
+async function retryTimeout(task) {
+  try {
+    return { value: await task(), retried: false };
+  } catch (failure) {
+    if (!(failure instanceof errors.TimeoutError)) {
+      throw failure;
+    }
+    return { value: await task(), retried: true };
+  }
+}
+async function execute(check, run2) {
+  const started = performance.now();
+  const viewports = selectedViewports(check, run2.options);
+  let retried = false;
+  let attempts = 0;
+  try {
+    await retryTimeout(async () => {
+      retried = attempts++ > 0;
+      for (const viewport of viewports) {
+        run2.options.signal?.throwIfAborted();
+        await check.run(run2, viewport);
+      }
+    });
+    return {
+      id: check.id,
+      title: check.title,
+      result: "passed",
+      durationMs: performance.now() - started,
+      viewport: viewports.map(label).join(","),
+      ...retried ? { retried } : {}
+    };
+  } catch (failure) {
+    const error = failure instanceof VerifyError ? { code: failure.code, message: failure.message, hint: failure.hint } : {
+      code: "check_failed",
+      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") {
+      return {
+        id: check.id,
+        title: check.title,
+        result: "skipped",
+        durationMs: performance.now() - started,
+        error
+      };
+    }
+    const screenshot = path3.join(
+      run2.options.artifactsDir ?? "verify-artifacts",
+      `${check.id}.png`
+    );
+    const trace = path3.join(
+      run2.options.artifactsDir ?? "verify-artifacts",
+      "verify.trace.zip"
+    );
+    await mkdir(path3.dirname(screenshot), { recursive: true });
+    await run2.page.screenshot({ path: screenshot, fullPage: true }).catch(() => void 0);
+    return {
+      id: check.id,
+      title: check.title,
+      result: "failed",
+      durationMs: performance.now() - started,
+      viewport: viewports.map(label).join(","),
+      ...retried ? { retried } : {},
+      error,
+      artifacts: { screenshot, trace }
+    };
+  }
+}
+var label = (viewport) => `${viewport.width}x${viewport.height}`;
+async function runVerify(options, fault) {
+  if (!/^pk_test_.+/.test(options.key)) {
+    throw new VerifyError(
+      "live_key_refused",
+      "Verify accepts only pk_test_ keys",
+      "Create a test publishable key and rerun verify."
+    );
+  }
+  const started = Date.now();
+  const browser = await chromium.launch();
+  const context = await browser.newContext(browserOptions(options));
+  if (options.standInForPlatform) {
+    await context.route(
+      "**/_zappie/view",
+      (route) => route.fulfill({ status: 204 })
+    );
+  }
+  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 metrics = {};
+  const run2 = {
+    options,
+    browser,
+    context,
+    page,
+    metrics,
+    ...fault ? { fault } : {}
+  };
+  const results = [await reset(options)];
+  try {
+    const wanted = options.only ? new Set(options.only) : void 0;
+    for (const check of checks) {
+      if (wanted && !wanted.has(check.id)) {
+        continue;
+      }
+      options.onProgress?.({ id: check.id, status: "running" });
+      const result = await execute(check, run2);
+      results.push(result);
+      options.onProgress?.({ id: check.id, status: result.result });
+    }
+    if (!wanted) {
+      results.push(...skippedChecks(options.suite));
+    }
+    const sdkVersion = await page.evaluate(() => window.__zappie?.version ?? "unknown").catch(() => "unknown");
+    const summary = summarize(results);
+    const report = {
+      schema: REPORT_SCHEMA,
+      id: reportId(),
+      suite: options.suite,
+      target: target(options),
+      environment: {
+        runner: options.runner ?? "cli",
+        verifyVersion: VERSION,
+        sdkVersion,
+        browser: `chromium ${browser.version()}`
+      },
+      startedAt: new Date(started).toISOString(),
+      durationMs: Date.now() - started,
+      result: summary.failed ? "failed" : "passed",
+      summary,
+      checks: results,
+      metrics
+    };
+    return signReport(
+      report,
+      options.signingKey ?? process.env.ZAPPIE_VERIFY_SIGNING_KEY
+    );
+  } finally {
+    const trace = path3.join(
+      options.artifactsDir ?? "verify-artifacts",
+      "verify.trace.zip"
+    );
+    await mkdir(path3.dirname(trace), { recursive: true });
+    await context.tracing.stop({ path: trace }).catch(() => void 0);
+    await browser.close();
+  }
+}
+
+// src/project.ts
+async function verifyProject(options) {
+  const store = options.store ?? await readStore(options.cwd);
+  let preview;
+  try {
+    preview = options.url ? void 0 : await startLocalPreview({
+      cwd: options.cwd,
+      key: options.key,
+      store,
+      packageManager: options.packageManager,
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    return await runVerify({
+      url: normalizeUrl(options.url ?? preview?.url),
+      store,
+      key: options.key,
+      suite: options.suite,
+      runner: "cli",
+      ...options.only ? { only: options.only } : {},
+      ...options.viewports ? { viewports: options.viewports } : {},
+      ...options.artifactsDir ? { artifactsDir: options.artifactsDir } : {},
+      ...options.timeoutMs ? { timeoutMs: options.timeoutMs } : {},
+      ...options.signal ? { signal: options.signal } : {},
+      ...options.onProgress ? { onProgress: options.onProgress } : {},
+      ...options.signingKey ? { signingKey: options.signingKey } : {},
+      // A preview started here has no site host in front of it.
+      ...preview ? { standInForPlatform: true } : {}
+    });
+  } finally {
+    await preview?.close();
+  }
+}
+function normalizeUrl(value) {
+  try {
+    const url = new URL(value ?? "");
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      throw new Error("protocol");
+    }
+    return url.href;
+  } catch {
+    throw new VerifyError(
+      "invalid_url",
+      "Verify needs an http(s) storefront URL",
+      "Pass a valid URL or run the command from a supported project."
+    );
+  }
+}
+
+// src/index.ts
+function verify(options) {
+  return runVerify(options);
+}
+export {
+  VerifyError,
+  printSummary,
+  verify,
+  verifyProject
+};
+//# sourceMappingURL=index.js.map