@zappie/verify 0.0.0-stage → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# @zappie/verify
+
+## 0.1.1
+
+### Patch Changes
+
+- 38f23ac: `VERSION` (`@zappie/sdk`) and `FOUNDATIONS_VERSION` (`@zappie/foundations`) report the installed version. In 0.1.0 they said `"0.0.0"`. Verify reports now carry the real `verifyVersion`, and the test-mode debug channel the real SDK version.
+- eeccfed: First release on npm. `zappie check` and `zappie verify` now work in any project that installs these as dev dependencies. `@zappie/verify` takes `@playwright/test` as a peer dependency.
+- Updated dependencies [38f23ac]
+- Updated dependencies [1e6f420]
+  - @zappie/sdk@0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zappie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,56 @@
-# Temporary Holding Version
+# @zappie/verify
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The checks behind `zappie verify`. They open your storefront in a real browser and walk the journeys a shopper takes: the store loads, the menu matches Zappie's, an item goes in the cart, totals match Zappie's quote, issues can be fixed and checkout is ready. Each failure comes with a hint about what to fix.
+
+```sh
+npm install --save-dev @zappie/verify @playwright/test
+npx playwright install chromium
+```
+
+`@playwright/test` is a peer dependency, so you choose its version and install its browser once.
+
+## Use it
+
+Run it against your built project, or against a URL, with a publishable test key:
+
+```sh
+ZAPPIE_KEY=pk_test_... npx zappie verify
+ZAPPIE_KEY=pk_test_... npx zappie verify https://your-store.example
+```
+
+With no URL, it builds your project, starts a local preview, runs the checks and stops the preview. It only accepts test keys, so it never touches live orders.
+
+| Option                           | What it does                                         |
+| -------------------------------- | ---------------------------------------------------- |
+| `--suite standard` or `extended` | The standard checks, or those plus the extended ones |
+| `--report <file>`                | Save the full report as JSON                         |
+| `--json`                         | Print the report as JSON                             |
+
+## From code
+
+```ts
+import { printSummary, verifyProject } from "@zappie/verify";
+
+const report = await verifyProject({
+  cwd: process.cwd(),
+  key: process.env.ZAPPIE_KEY ?? "",
+  suite: "standard",
+  packageManager: "npm",
+});
+console.log(printSummary(report));
+```
+
+The report's shape is the JSON Schema at `@zappie/verify/schema/verify-report.v1.json`.
+
+## Docs
+
+- [CLI: zappie verify](https://docs.zappie.ai/cli/verify)
+- [Verify checks](https://docs.zappie.ai/verify)
+
+## Status
+
+`@zappie/verify` is at `0.x`. Its checks and report can change in a minor release while it settles. Each change is listed in `CHANGELOG.md`.
+
+## License
+
+MIT

package/dist/category-page-UBHOB5IN.js

@@ -0,0 +1,21 @@
+// ../sdk/src/transport/category-page.ts
+function categoryPage(raw, ctx, mapMenu, invalid) {
+  const menu = mapMenu(raw, ctx.branchId);
+  if (raw.next_cursor != null && (typeof raw.next_cursor !== "string" || !raw.next_cursor || raw.next_cursor === ctx.cursor) || menu.categories.some((c) => c.id !== ctx.categoryId) || Object.keys(menu.items).some(
+    (id) => !menu.categories.some((c) => c.itemIds.includes(id))
+  ) || !menu.menus?.some(
+    (m) => m.id === ctx.menuId && m.categoryIds.includes(ctx.categoryId)
+  )) {
+    throw invalid();
+  }
+  return {
+    menu: { ...menu, completeness: "partial" },
+    menuId: ctx.menuId,
+    categoryId: ctx.categoryId,
+    ...typeof raw.next_cursor === "string" && raw.next_cursor ? { nextCursor: raw.next_cursor } : {}
+  };
+}
+export {
+  categoryPage
+};
+//# sourceMappingURL=category-page-UBHOB5IN.js.map

package/dist/category-page-UBHOB5IN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../sdk/src/transport/category-page.ts"],"sourcesContent":["import type { CategoryPage, Menu } from \"../models\";\n\n/**\n * Validates and maps one category page. Only progressive catalogues read\n * pages, so this loads on the first `menu.page()` call and stays out of the\n * core bundle, like the quote client (PRD 03 §4). The mapper and error come\n * in as arguments: importing them would split the core's shared code into a\n * separate chunk, which costs the core more than this module saves.\n */\nexport function categoryPage(\n  raw: Record<string, unknown>,\n  ctx: {\n    branchId: string;\n    menuId: string;\n    categoryId: string;\n    cursor?: string;\n  },\n  mapMenu: (value: unknown, branchId: string) => Menu,\n  invalid: () => Error,\n): CategoryPage {\n  const menu = mapMenu(raw, ctx.branchId);\n  if (\n    (raw.next_cursor != null &&\n      (typeof raw.next_cursor !== \"string\" ||\n        !raw.next_cursor ||\n        raw.next_cursor === ctx.cursor)) ||\n    menu.categories.some((c) => c.id !== ctx.categoryId) ||\n    Object.keys(menu.items).some(\n      (id) => !menu.categories.some((c) => c.itemIds.includes(id)),\n    ) ||\n    !menu.menus?.some(\n      (m) => m.id === ctx.menuId && m.categoryIds.includes(ctx.categoryId),\n    )\n  ) {\n    throw invalid();\n  }\n  return {\n    menu: { ...menu, completeness: \"partial\" },\n    menuId: ctx.menuId,\n    categoryId: ctx.categoryId,\n    ...(typeof raw.next_cursor === \"string\" && raw.next_cursor\n      ? { nextCursor: raw.next_cursor }\n      : {}),\n  };\n}\n"],"mappings":";AASO,SAAS,aACd,KACA,KAMA,SACA,SACc;AACd,QAAM,OAAO,QAAQ,KAAK,IAAI,QAAQ;AACtC,MACG,IAAI,eAAe,SACjB,OAAO,IAAI,gBAAgB,YAC1B,CAAC,IAAI,eACL,IAAI,gBAAgB,IAAI,WAC5B,KAAK,WAAW,KAAK,CAAC,MAAM,EAAE,OAAO,IAAI,UAAU,KACnD,OAAO,KAAK,KAAK,KAAK,EAAE;AAAA,IACtB,CAAC,OAAO,CAAC,KAAK,WAAW,KAAK,CAAC,MAAM,EAAE,QAAQ,SAAS,EAAE,CAAC;AAAA,EAC7D,KACA,CAAC,KAAK,OAAO;AAAA,IACX,CAAC,MAAM,EAAE,OAAO,IAAI,UAAU,EAAE,YAAY,SAAS,IAAI,UAAU;AAAA,EACrE,GACA;AACA,UAAM,QAAQ;AAAA,EAChB;AACA,SAAO;AAAA,IACL,MAAM,EAAE,GAAG,MAAM,cAAc,UAAU;AAAA,IACzC,QAAQ,IAAI;AAAA,IACZ,YAAY,IAAI;AAAA,IAChB,GAAI,OAAO,IAAI,gBAAgB,YAAY,IAAI,cAC3C,EAAE,YAAY,IAAI,YAAY,IAC9B,CAAC;AAAA,EACP;AACF;","names":[]}

package/dist/chunk-WUWUDCYO.js

@@ -0,0 +1,485 @@
+// ../sdk/src/errors.ts
+var codes = [
+  "network_error",
+  "timeout",
+  "rate_limited",
+  "unauthorized",
+  "forbidden_origin",
+  "not_found",
+  "store_not_found",
+  "branch_not_found",
+  "item_not_found",
+  "cart_invalid",
+  "invalid_request",
+  "version_unsupported",
+  "server_error"
+];
+var ZappieError = class extends Error {
+  constructor(code, message, details = {}) {
+    super(message, { cause: details.cause });
+    this.code = code;
+    this.name = "ZappieError";
+    if (details.status !== void 0) {
+      this.status = details.status;
+    }
+    if (details.param !== void 0) {
+      this.param = details.param;
+    }
+    if (details.requestId !== void 0) {
+      this.requestId = details.requestId;
+    }
+    this.docUrl = details.docUrl ?? `https://docs.zappie.ai/errors#${code}`;
+    this.retryable = details.retryable ?? ["network_error", "timeout", "rate_limited", "server_error"].includes(
+      code
+    );
+  }
+};
+function isZappieError(error) {
+  return error instanceof ZappieError;
+}
+function asError(error) {
+  return isZappieError(error) ? error : new ZappieError("network_error", "The storefront request failed", {
+    cause: error
+  });
+}
+function wireError(value, status, requestId) {
+  const envelope = value && typeof value === "object" ? value : {};
+  const e = envelope.error && typeof envelope.error === "object" ? envelope.error : {};
+  const fallback = status === 401 ? "unauthorized" : status === 403 ? "forbidden_origin" : status === 404 ? "not_found" : status === 429 ? "rate_limited" : status >= 500 ? "server_error" : "invalid_request";
+  const known = typeof e.code === "string" && codes.includes(e.code);
+  const code = known ? e.code : e.code ? "server_error" : fallback;
+  const message = typeof e.message === "string" ? e.message : "The storefront request failed";
+  return new ZappieError(
+    code,
+    !known && e.code ? `${String(e.code)}: ${message}` : message,
+    {
+      status,
+      ...requestId ? { requestId } : {},
+      ...typeof e.param === "string" ? { param: e.param } : {},
+      ...typeof e.doc_url === "string" ? { docUrl: e.doc_url } : {}
+    }
+  );
+}
+
+// ../sdk/src/internal/digest.ts
+async function payloadKey(payload) {
+  const digest = await globalThis.crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(payload)
+  );
+  return Array.from(
+    new Uint8Array(digest),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
+}
+
+// ../sdk/src/money.ts
+var ZERO_DIGIT_CURRENCIES = " AFN ALL BIF CLP DJF GNF IQD IRR ISK JPY KMF KPW KRW LAK LBP MGA MMK PYG RSD RWF SLL SOS SYP UGX UYI VND VUV XAF XOF XPF YER ";
+var THREE_DIGIT_CURRENCIES = " BHD JOD KWD LYD OMR TND ";
+var FOUR_DIGIT_CURRENCIES = " CLF UYW ";
+var API_ONLY_CURRENCIES = " BOV CHE CHW CLF COU MXV USN UYI UYW VED ";
+var contains = (codes2, currency) => codes2.includes(` ${currency} `);
+var intlCurrencies;
+function isCurrency(code) {
+  if (!/^[A-Z]{3}$/.test(code)) {
+    return false;
+  }
+  if (typeof Intl.supportedValuesOf !== "function") {
+    return true;
+  }
+  intlCurrencies ??= new Set(Intl.supportedValuesOf("currency"));
+  return contains(API_ONLY_CURRENCIES, code) || intlCurrencies.has(code);
+}
+function currencyDigits(currency) {
+  if (contains(ZERO_DIGIT_CURRENCIES, currency)) {
+    return 0;
+  }
+  if (contains(THREE_DIGIT_CURRENCIES, currency)) {
+    return 3;
+  }
+  return contains(FOUR_DIGIT_CURRENCIES, currency) ? 4 : 2;
+}
+function money(amountMinor, currency) {
+  const normalized = typeof currency === "string" ? currency.trim().toUpperCase() : "";
+  if (!Number.isSafeInteger(amountMinor) || !isCurrency(normalized)) {
+    throw new ZappieError(
+      "invalid_request",
+      "Money requires safe integer minor units and a valid ISO 4217 currency"
+    );
+  }
+  return Object.freeze({ amountMinor, currency: normalized });
+}
+var format = {
+  money(value, opts = {}) {
+    const normalized = money(value.amountMinor, value.currency);
+    const locale = normalized.currency === "NGN" ? "en-NG" : "en";
+    const digits = currencyDigits(normalized.currency);
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: normalized.currency,
+      currencyDisplay: "narrowSymbol",
+      minimumFractionDigits: opts.showZeroDecimals || normalized.amountMinor % 10 ** digits !== 0 ? digits : 0,
+      maximumFractionDigits: digits,
+      notation: opts.compact ? "compact" : "standard",
+      signDisplay: opts.sign ?? "auto"
+    }).format(normalized.amountMinor / 10 ** digits);
+  }
+};
+
+// ../sdk/src/internal/money-math.ts
+function sumMoney(values, zero) {
+  let amount = zero.amountMinor;
+  for (const value of values) {
+    if (value.currency !== zero.currency) {
+      throw new ZappieError(
+        "invalid_request",
+        "Cannot combine different currencies"
+      );
+    }
+    amount = money(amount + value.amountMinor, zero.currency).amountMinor;
+  }
+  return money(amount, zero.currency);
+}
+function multiplyMoney(value, quantity) {
+  if (!Number.isSafeInteger(quantity)) {
+    throw new ZappieError(
+      "invalid_request",
+      "Money requires an integer quantity"
+    );
+  }
+  return money(value.amountMinor * quantity, value.currency);
+}
+
+// ../sdk/src/transport/mappers.ts
+var UnsupportedValue = class extends Error {
+};
+function record(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ZappieError("server_error", "Invalid storefront response object");
+  }
+  return value;
+}
+function text(value) {
+  if (typeof value !== "string") {
+    throw new ZappieError("server_error", "Invalid storefront response string");
+  }
+  return value;
+}
+function list(value) {
+  if (!Array.isArray(value)) {
+    throw new ZappieError("server_error", "Invalid storefront response list");
+  }
+  return value;
+}
+function number(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new ZappieError("server_error", "Invalid storefront response number");
+  }
+  return value;
+}
+function nonnegative(value) {
+  const result = number(value);
+  if (result < 0) {
+    throw new ZappieError(
+      "server_error",
+      "Negative selection or quantity bound"
+    );
+  }
+  return result;
+}
+function bounds(value) {
+  const input = record(value);
+  const min = nonnegative(input.min);
+  if (input.max == null) {
+    return { min };
+  }
+  const max = nonnegative(input.max);
+  if (max < min) {
+    throw new ZappieError(
+      "server_error",
+      "Maximum quantity is below its minimum"
+    );
+  }
+  return { min, max };
+}
+var isString = (value) => typeof value === "string";
+var isBoolean = (value) => typeof value === "boolean";
+function opt(key, value, is) {
+  return is(value) ? { [key]: value } : {};
+}
+function mapMoney(value) {
+  const v = record(value);
+  return money(
+    number(v.amount_minor ?? v.amountMinor),
+    text(v.currency)
+  );
+}
+function hours(value) {
+  return list(value ?? []).map((slot) => {
+    const v = record(slot);
+    const day = number(v.day);
+    if (!Number.isInteger(day) || day < 0 || day > 6) {
+      throw new ZappieError("server_error", "Invalid opening day");
+    }
+    return {
+      day,
+      opens: text(v.opens ?? v.open ?? v.start),
+      closes: text(v.closes ?? v.close ?? v.end),
+      ...opt("disabled", v.disabled, isBoolean)
+    };
+  });
+}
+function schedule(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const v = record(value);
+  return {
+    openingTimes: hours(v.opening_times ?? v.openingTimes ?? v.hours ?? []),
+    ...opt("preorder", v.preorder, isBoolean),
+    ...v.preorder_notice_hours !== void 0 ? { preorderNoticeHours: number(v.preorder_notice_hours) } : {},
+    ...v.preorder_max_days !== void 0 ? { preorderMaxDays: number(v.preorder_max_days) } : {}
+  };
+}
+function mapGroup(value) {
+  const g = record(value);
+  const selection = record(g.selection ?? { min: g.min ?? 0, max: g.max });
+  const isAttribute = g.is_attribute === true;
+  const kind = text(g.kind ?? "select");
+  if (!["select", "text", "number", "date", "time", "toggle"].includes(kind)) {
+    throw new UnsupportedValue(`option input kind "${kind}"`);
+  }
+  return {
+    id: text(g.id),
+    name: text(g.name),
+    kind,
+    required: typeof g.required === "boolean" ? g.required : number(selection.min) > 0,
+    selection: bounds(selection),
+    isAttribute,
+    choices: list(g.choices ?? []).map((raw) => {
+      const c = record(raw);
+      const price = mapMoney(c.price);
+      return {
+        id: text(c.id),
+        name: text(c.name),
+        price: isAttribute ? money(0, price.currency) : price,
+        ...isAttribute && c.price_hint !== void 0 ? { priceHint: mapMoney(c.price_hint) } : {},
+        isAvailable: (c.is_available ?? c.available) === true,
+        ...c.quantity ? { quantity: bounds(c.quantity) } : {}
+      };
+    }),
+    ...opt("helpText", g.help_text, isString),
+    ...g.input ? {
+      input: {
+        ...record(g.input).max_length !== void 0 ? { maxLength: number(record(g.input).max_length) } : {},
+        ...typeof record(g.input).placeholder === "string" ? { placeholder: text(record(g.input).placeholder) } : {}
+      }
+    } : {},
+    ...opt("isAvailable", g.is_available, isBoolean),
+    ...opt("isInformational", g.is_informational, isBoolean),
+    ...g.conditions ? {
+      conditions: list(g.conditions).map((raw) => {
+        const c = record(raw);
+        const count = c.count ? record(c.count) : void 0;
+        if (count && !["eq", "gte", "lte"].includes(text(count.op))) {
+          throw new UnsupportedValue(
+            `option count operator "${text(count.op)}"`
+          );
+        }
+        if (c.match !== void 0 && c.match !== "any" && c.match !== "all") {
+          throw new UnsupportedValue(
+            `option match operator "${String(c.match)}"`
+          );
+        }
+        if (c.set_required != null && typeof c.set_required !== "boolean") {
+          throw new ZappieError(
+            "server_error",
+            "Invalid conditional required flag"
+          );
+        }
+        return {
+          groupId: text(c.group_id),
+          choiceIds: list(c.choice_ids ?? []).map(text),
+          match: c.match === "all" ? "all" : "any",
+          ...count ? {
+            count: {
+              op: text(count.op),
+              value: nonnegative(count.value)
+            }
+          } : {},
+          ...c.set_required !== void 0 ? { setRequired: c.set_required } : {},
+          ...c.set_min !== void 0 ? { setMin: c.set_min === null ? null : nonnegative(c.set_min) } : {},
+          ...c.set_max !== void 0 ? { setMax: c.set_max === null ? null : nonnegative(c.set_max) } : {}
+        };
+      })
+    } : {}
+  };
+}
+function mapPromo(value) {
+  const p = record(value);
+  return { name: text(p.name) };
+}
+function mapItem(value) {
+  const v = record(value);
+  const id = text(v.id);
+  const optionGroups = [];
+  let unsupported = false;
+  for (const raw of list(v.option_groups ?? [])) {
+    try {
+      optionGroups.push(mapGroup(raw));
+    } catch (error) {
+      if (!(error instanceof UnsupportedValue)) {
+        throw error;
+      }
+      unsupported = true;
+      console.warn(
+        `Zappie item ${id} uses an ${error.message} this SDK can't validate; it is shown as unavailable`
+      );
+    }
+  }
+  const variants = list(v.variants).map((raw) => {
+    const x = record(raw);
+    return {
+      id: text(x.id),
+      attributeChoices: Object.fromEntries(
+        Object.entries(record(x.attribute_choices ?? {})).map(([k, v2]) => [
+          k,
+          text(v2)
+        ])
+      ),
+      price: mapMoney(x.price),
+      ...opt("lowStock", x.low_stock, isBoolean),
+      isAvailable: !unsupported && (x.is_available ?? x.available) === true
+    };
+  });
+  if (!variants.length) {
+    throw new ZappieError(
+      "server_error",
+      "An item must carry at least one exact variant"
+    );
+  }
+  const quantity = record(
+    v.quantity ?? { min: 1, step: 1, max: v.max_quantity }
+  );
+  const step = number(quantity.step);
+  if (step <= 0 || new Set(variants.map((variant) => variant.id)).size !== variants.length) {
+    throw new ZappieError(
+      "server_error",
+      "Invalid quantity step or duplicate variant identity"
+    );
+  }
+  return {
+    ...v.placements !== void 0 ? {
+      placements: list(v.placements).map((raw) => {
+        const placement = record(raw);
+        return {
+          menuId: text(placement.menu_id),
+          categoryId: text(placement.category_id)
+        };
+      })
+    } : {},
+    id,
+    name: text(v.name),
+    images: list(v.images ?? []).map(text),
+    price: mapMoney(v.price),
+    isAvailable: !unsupported && (v.is_available ?? v.available) === true,
+    quantity: { ...bounds(quantity), step },
+    variants,
+    optionGroups,
+    tags: list(v.tags ?? []).map(text),
+    ...opt("stockLabel", v.stock_label, isString),
+    ...v.promo !== void 0 ? { promo: mapPromo(v.promo) } : {},
+    ...opt("description", v.description, isString),
+    ...v.compare_at_price ? { compareAtPrice: mapMoney(v.compare_at_price) } : {}
+  };
+}
+function mapMenu(value, branchId) {
+  const v = record(value);
+  const sources = list(v.menus ?? [v]);
+  if (v.completeness !== void 0 && v.completeness !== "partial" && v.completeness !== "complete") {
+    throw new ZappieError("server_error", "Invalid catalogue completeness");
+  }
+  const categories = /* @__PURE__ */ new Map();
+  const menus = sources.map((raw) => {
+    const m = record(raw);
+    if (m.placement_count !== void 0 && (!Number.isSafeInteger(m.placement_count) || Number(m.placement_count) < 0) || m.paginated !== void 0 && typeof m.paginated !== "boolean") {
+      throw new ZappieError("server_error", "Invalid menu loading metadata");
+    }
+    const categoryIds = list(m.categories ?? []).map((rawCategory) => {
+      const c = record(rawCategory);
+      const id = text(c.id);
+      const previous = categories.get(id);
+      const itemIds = [
+        .../* @__PURE__ */ new Set([
+          ...previous?.itemIds ?? [],
+          ...list(c.item_ids ?? []).map(text)
+        ])
+      ];
+      categories.set(id, {
+        id,
+        name: text(c.name),
+        itemIds,
+        ...opt("description", c.description, isString)
+      });
+      return id;
+    });
+    const s = schedule(m.schedule);
+    return {
+      id: text(m.id),
+      name: text(m.name),
+      categoryIds,
+      ...m.placement_count !== void 0 ? { placementCount: m.placement_count } : {},
+      ...opt("paginated", m.paginated, isBoolean),
+      ...s ? { schedule: s } : {},
+      ...opt("infoBanner", m.info_banner, isString)
+    };
+  });
+  const items = Object.fromEntries(
+    Object.entries(record(v.items)).map(([id, item]) => {
+      const mapped = mapItem(item);
+      if (mapped.id !== id) {
+        throw new ZappieError(
+          "server_error",
+          "Item map key does not match its identity"
+        );
+      }
+      return [id, mapped];
+    })
+  );
+  if (v.branch_id !== void 0 && v.branch_id !== branchId) {
+    throw new ZappieError("server_error", "Menu branch mismatch");
+  }
+  return {
+    id: menus.length === 1 ? menus[0].id : `branch:${branchId}`,
+    branchId,
+    ...v.completeness === "partial" ? { completeness: "partial" } : {},
+    name: menus.length === 1 ? menus[0].name : "Catalogue",
+    version: text(v.menu_version ?? v.version),
+    categories: [...categories.values()],
+    items,
+    menus,
+    ...menus.length === 1 && menus[0].schedule ? { schedule: menus[0].schedule } : {}
+  };
+}
+
+export {
+  ZappieError,
+  asError,
+  wireError,
+  money,
+  format,
+  sumMoney,
+  multiplyMoney,
+  payloadKey,
+  record,
+  text,
+  list,
+  isString,
+  isBoolean,
+  opt,
+  mapMoney,
+  hours,
+  mapItem,
+  mapMenu
+};
+//# sourceMappingURL=chunk-WUWUDCYO.js.map