@fire-spark/cli 0.13.2 → 0.14.0

package/src/commands/doctor/client/pay.flow.ts

@@ -0,0 +1,772 @@
+import { Big } from "big.js";
+import { randomBytes, randomUUID } from "node:crypto";
+
+import type { Copy } from "../../../core/i18n";
+import type { LiveSession } from "../live/live.session";
+import { buildOrderBody, pickProduct } from "../live/order";
+import { channelLabel, paymentOf } from "./config";
+import { COPY as SHARED } from "./copy";
+import { fromLive, isActive, isOutcome, isRecord } from "./flow";
+import { namedOrderSkip, openLive, prepare, queryOf, rowsOf } from "./flow";
+import { say, textOf, trpcCall, withSafeFix } from "./flow";
+import { liveConfigOf } from "./order";
+import { readSources } from "./repo.scan";
+import type { CheckBinding, Outcome, RunCtx } from "./runner";
+import type { YamlChannel } from "./yaml";
+
+const line = (es: string, en: string, pt: string): Copy => {
+  return { "es-EC": es, "en-US": en, "pt-BR": pt };
+};
+
+const COPY = {
+  empty: line(
+    "El canal {channel} no tiene payments activos.",
+    "Channel {channel} has no active payments.",
+    "O canal {channel} não tem payments ativos."
+  ),
+  shape: line(
+    "Un payment no trae {field}.",
+    "A payment is missing {field}.",
+    "Um payment não traz {field}."
+  ),
+  changed: line(
+    "El catálogo de pagos cambió entre dos lecturas de la misma sesión.",
+    "The payment catalog changed between two reads of the same session.",
+    "O catálogo de pagamentos mudou entre duas leituras da mesma sessão."
+  ),
+  redemption: line(
+    "REDEMPTION no puede ser el método de dinero. No hay otro método activo.",
+    "REDEMPTION cannot be the money method. No other method is active.",
+    "REDEMPTION não pode ser o método de dinheiro. Não há outro método ativo."
+  ),
+  unknown: line(
+    "El método {method} no tiene un flujo de instrucciones.",
+    "Method {method} has no instruction flow.",
+    "O método {method} não tem um fluxo de instruções."
+  ),
+  cashHelp: line(
+    "El efectivo no debe mostrar instrucciones. Se paga en caja.",
+    "Cash must not show instructions. It is paid at the counter.",
+    "O dinheiro não deve mostrar instruções. Paga-se no caixa."
+  ),
+  pay05Skip: line(
+    "PAY-05 no aplica al canal {template}.",
+    "PAY-05 does not apply to the {template} channel.",
+    "PAY-05 não se aplica ao canal {template}."
+  ),
+  pay05Missing: line(
+    "No encontré la UI de alta, edición, baja y preferido (exactAmount y preferred).",
+    "I did not find the add, edit, delete, and preferred payment UI (exactAmount and preferred).",
+    "Não encontrei a UI de alta, edição, baixa e preferido (exactAmount e preferred)."
+  ),
+  noCash: line(
+    "CASH no está habilitado en el canal {channel}.",
+    "CASH is not enabled on channel {channel}.",
+    "CASH não está habilitado no canal {channel}."
+  ),
+  blocked: line(
+    "CASH ({id}) está bloqueado en este dispositivo.",
+    "CASH ({id}) is blocked on this device.",
+    "CASH ({id}) está bloqueado neste dispositivo."
+  ),
+  change: line(
+    "El cambio de efectivo no cuadra.",
+    "The cash change does not add up.",
+    "O troco em dinheiro não fecha."
+  ),
+  splitSkip: line(
+    "PAY-10 se omite: hace falta un segundo método de dinero además de efectivo.",
+    "PAY-10 is skipped: a second money method besides cash is required.",
+    "PAY-10 é omitido: falta um segundo método de dinheiro além de dinheiro."
+  ),
+  split: line(
+    "El reparto entre efectivo, el otro método y los fees no cuadra.",
+    "The split across cash, the other method, and fees does not add up.",
+    "A divisão entre dinheiro, o outro método e as taxas não fecha."
+  ),
+  mixedOff: line(
+    "PAY-12 se omite: preferences.payments.mixed está vacío.",
+    "PAY-12 is skipped: preferences.payments.mixed is empty.",
+    "PAY-12 é omitido: preferences.payments.mixed está vazio."
+  ),
+  mixedNeed: line(
+    "Mixed está habilitado y hay menos de dos métodos de dinero.",
+    "Mixed is enabled and fewer than two money methods exist.",
+    "Mixed está habilitado e há menos de dois métodos de dinheiro."
+  ),
+  mixedShort: line(
+    "preferences.payments.mixed permite menos de dos métodos.",
+    "preferences.payments.mixed allows fewer than two methods.",
+    "preferences.payments.mixed permite menos de dois métodos."
+  ),
+  noAdapter: line(
+    "PAY-08 se omite: no hay un adapter de cobro. No hice ningún cobro.",
+    "PAY-08 is skipped: there is no charge adapter. No charge was made.",
+    "PAY-08 é omitido: não há um adapter de cobrança. Nenhuma cobrança foi feita."
+  ),
+  noSandbox: line(
+    "PAY-08 se omite: {provider} no es un sandbox local. No hice ningún cobro.",
+    "PAY-08 is skipped: {provider} is not a local sandbox. No charge was made.",
+    "PAY-08 é omitido: {provider} não é um sandbox local. Nenhuma cobrança foi feita."
+  ),
+  refunded: line(
+    "Un cliente sin orders:orders:write pudo reembolsar.",
+    "A customer without orders:orders:write was able to refund.",
+    "Um cliente sem orders:orders:write conseguiu reembolsar."
+  ),
+  placeStatus: line(
+    "Place respondió {status}. Esperaba ACCEPTED o IN_PROGRESS.",
+    "Place returned {status}. Expected ACCEPTED or IN_PROGRESS.",
+    "Place respondeu {status}. Esperava ACCEPTED ou IN_PROGRESS."
+  ),
+  notCash: line(
+    "El pago del canal no es cash ni sandbox. No hice place.",
+    "The channel payment is not cash or sandbox. Place was not called.",
+    "O pagamento do canal não é cash nem sandbox. Place não foi chamado."
+  ),
+  channel: line(
+    "{id} no aplica al canal {template}.",
+    "{id} does not apply to the {template} channel.",
+    "{id} não se aplica ao canal {template}."
+  ),
+  named: line(
+    "{id} solo corre cuando lo nombras. No cambié el catálogo de pagos.",
+    "{id} runs only when you name it. The payment catalog was not changed.",
+    "{id} só roda quando você o nomeia. O catálogo de pagamentos não mudou."
+  ),
+  need: line(
+    "{id} se omite: falta {field}.",
+    "{id} is skipped: {field} is missing.",
+    "{id} é omitido: falta {field}."
+  ),
+  http: line(
+    "{id} respondió {status}.",
+    "{id} responded {status}.",
+    "{id} respondeu {status}."
+  ),
+  instruction: line(
+    "PAY-04 no encontró paymentInstructionKind en CheckoutFlowProvider.helpers.ts.",
+    "PAY-04 did not find paymentInstructionKind in CheckoutFlowProvider.helpers.ts.",
+    "PAY-04 não encontrou paymentInstructionKind em CheckoutFlowProvider.helpers.ts."
+  ),
+  pay05Surface: line(
+    "PAY-05 no encontró CheckoutPaymentSection o PaymentMetaForm con exactAmount y preferred.",
+    "PAY-05 did not find CheckoutPaymentSection or PaymentMetaForm with exactAmount and preferred.",
+    "PAY-05 não encontrou CheckoutPaymentSection ou PaymentMetaForm com exactAmount e preferred."
+  ),
+  preferred: line(
+    "El customer no quedó con un efectivo preferred tras el alta.",
+    "The customer did not keep a preferred cash method after the save.",
+    "O customer não ficou com um dinheiro preferred após o cadastro."
+  ),
+  scope: line(
+    "El payment creado no se vio en el API tras variar el scope.",
+    "The created payment was not visible on the API after the scope change.",
+    "O payment criado não apareceu na API depois de variar o scope."
+  ),
+  session: line(
+    "La sesión nueva no descargó el catálogo de pagos actualizado.",
+    "The new session did not download the updated payment catalog.",
+    "A sessão nova não baixou o catálogo de pagamentos atualizado."
+  )
+};
+
+const LIVE = [
+  "api_url",
+  "channel_id",
+  "FIRESPARK_DOCTOR_CUSTOMER_EMAIL",
+  "FIRESPARK_DOCTOR_CUSTOMER_PASSWORD",
+  "FIRESPARK_DOCTOR_FIREBASE_API_KEY"
+] as const;
+
+const PAY05 = new Set(["web", "app", "chat", "call-center"]);
+
+const PLACE = new Set(["ACCEPTED", "IN_PROGRESS"]);
+
+const HASH = "0123456789abcdefghijklmnopqrstuvwxyz";
+
+const hash12 = () => {
+  const bytes = randomBytes(12);
+  let out = "";
+  for (const byte of bytes) out += HASH[byte % HASH.length];
+  return out;
+};
+
+const newOrderId = (storeId: string) => {
+  const store = storeId.replace(/[^A-Za-z0-9]/g, "") || "nostore";
+  return `ord-${store}-${hash12()}`;
+};
+
+type Row = Record<string, unknown>;
+
+type Catalog = {
+  channel: YamlChannel;
+  live: LiveSession;
+  rows: Row[];
+};
+
+const methodOf = (row: Row) => {
+  const method = row.method;
+  if (!isRecord(method)) return "";
+  return typeof method.method === "string" ? method.method : "";
+};
+
+const providerOf = (row: Row) => {
+  const provider = row.provider;
+  if (!isRecord(provider)) return "";
+  const id = provider.provider_id;
+  return typeof id === "string" ? id : "";
+};
+
+const idOf = (row: Row) => {
+  return typeof row.id === "string" ? row.id : "";
+};
+
+const scopeOf = (channel: YamlChannel) => {
+  return {
+    channel_id: textOf(channel.channel_id),
+    store_id: textOf(channel.store_id),
+    fulfillment_id: textOf(channel.fulfillment_id)
+  };
+};
+
+const paymentsOf = async (ctx: RunCtx): Promise<Catalog | Outcome> => {
+  const fields = [...LIVE, "store_id", "fulfillment_id"] as const;
+  const ready = prepare(ctx, fields);
+  if (isOutcome(ready)) return ready;
+  const live = openLive(ctx, ready);
+  const path = queryOf("/payments", scopeOf(ready));
+  const step = await live.storefront<unknown>("payments", "GET", path, [200]);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  return { channel: ready, live, rows: rowsOf(step.value) };
+};
+
+const activeRows = (rows: Row[]) => rows.filter(isActive);
+
+const moneyRows = (rows: Row[]) => {
+  return activeRows(rows).filter(row => {
+    const method = methodOf(row);
+    return method !== "" && method !== "REDEMPTION";
+  });
+};
+
+const cashRow = (rows: Row[]) => {
+  return moneyRows(rows).find(row => methodOf(row) === "CASH");
+};
+
+const disabledIds = (env: NodeJS.ProcessEnv) => {
+  const raw = textOf(env.FIRESPARK_DOCTOR_DISABLED_PAYMENT_IDS);
+  const parts = raw.split(",").map(item => item.trim());
+  return new Set(parts.filter(item => item !== ""));
+};
+
+const namedOnly = (ctx: RunCtx, id: string) => {
+  if (ctx.named.has(id)) return null;
+  return say(ctx.locale, "skip", COPY.named, { id });
+};
+
+const need = (ctx: RunCtx, id: string, field: string) => {
+  return say(ctx.locale, "skip", COPY.need, { id, field });
+};
+
+const allowed = async (
+  ctx: RunCtx,
+  id: string,
+  templates: ReadonlySet<string>
+) => {
+  const ready = prepare(ctx, ["channel_id"]);
+  if (isOutcome(ready)) return ready;
+  const template = textOf(ready.template);
+  if (templates.has(template)) return ready;
+  return say(ctx.locale, "skip", COPY.channel, { id, template });
+};
+
+const dashGap = (ctx: RunCtx, id: string, channel: YamlChannel) => {
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  if (!cookie) return need(ctx, id, "FIRESPARK_DOCTOR_DASHBOARD_COOKIE");
+  if (!textOf(channel.dashboard_url)) return need(ctx, id, "dashboard_url");
+  if (!textOf(channel.merchant_id)) return need(ctx, id, "merchant_id");
+  if (!textOf(channel.env)) return need(ctx, id, "env");
+  return null;
+};
+
+const providerUid = (row: Row) => {
+  const provider = row.provider;
+  if (!isRecord(provider)) return "";
+  const uid = provider.uid ?? provider.id;
+  return typeof uid === "string" ? uid : "";
+};
+
+const methodUid = (row: Row) => {
+  const method = row.method;
+  if (!isRecord(method)) return "";
+  const uid = method.uid ?? method.id;
+  return typeof uid === "string" ? uid : "";
+};
+
+const runPay01 = async (ctx: RunCtx): Promise<Outcome> => {
+  const gate = await allowed(ctx, "PAY-01", new Set(["server", "dashboard"]));
+  if (isOutcome(gate)) return gate;
+  const named = namedOnly(ctx, "PAY-01");
+  if (named) return named;
+  const catalog = await paymentsOf(ctx);
+  if (isOutcome(catalog)) return catalog;
+  const gap = dashGap(ctx, "PAY-01", catalog.channel);
+  if (gap) return gap;
+  const sample = activeRows(catalog.rows)[0];
+  if (!sample) {
+    const channel = channelLabel(catalog.channel);
+    return say(ctx.locale, "fail", COPY.empty, { channel });
+  }
+  const paymentProvider = providerUid(sample);
+  if (!paymentProvider) return need(ctx, "PAY-01", "payments.provider.uid");
+  const paymentMethod = methodUid(sample);
+  if (!paymentMethod) return need(ctx, "PAY-01", "payments.method.uid");
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  const dash = textOf(catalog.channel.dashboard_url);
+  const merchant = textOf(catalog.channel.merchant_id);
+  const env = textOf(catalog.channel.env);
+  const name = `doctor-${hash12()}`;
+  const scope = { channel_ids: [textOf(catalog.channel.channel_id)] };
+  const created = {
+    merchant_id: merchant,
+    env,
+    name,
+    status: "ACTIVE",
+    payment_provider_id: paymentProvider,
+    payment_method_id: paymentMethod,
+    ...scope
+  };
+  const inserted = await trpcCall(dash, cookie, "payments.insert", created);
+  if (inserted.status < 200 || inserted.status >= 300) {
+    return say(ctx.locale, "fail", COPY.http, {
+      id: "PAY-01",
+      status: inserted.status
+    });
+  }
+  const again = await paymentsOf(ctx);
+  if (isOutcome(again)) return again;
+  const visible = again.rows.some(row => row.name === name);
+  if (!visible) return say(ctx.locale, "fail", COPY.scope);
+  const id = again.rows.find(row => row.name === name);
+  const paymentId = id ? idOf(id) : "";
+  if (!paymentId) return say(ctx.locale, "fail", COPY.scope);
+  const off = { merchant_id: merchant, env, id: paymentId, status: "INACTIVE" };
+  const updated = await trpcCall(dash, cookie, "payments.update", off);
+  if (updated.status < 200 || updated.status >= 300) {
+    return say(ctx.locale, "fail", COPY.http, {
+      id: "PAY-01",
+      status: updated.status
+    });
+  }
+  const after = await paymentsOf(ctx);
+  if (isOutcome(after)) return after;
+  const row = after.rows.find(item => idOf(item) === paymentId);
+  if (row && row.status !== "INACTIVE")
+    return say(ctx.locale, "fail", COPY.scope);
+  return { status: "pass" };
+};
+
+const runPay02 = async (ctx: RunCtx): Promise<Outcome> => {
+  const gate = await allowed(ctx, "PAY-02", new Set(["kiosk"]));
+  if (isOutcome(gate)) return gate;
+  const named = namedOnly(ctx, "PAY-02");
+  if (named) return named;
+  const catalog = await paymentsOf(ctx);
+  if (isOutcome(catalog)) return catalog;
+  const gap = dashGap(ctx, "PAY-02", catalog.channel);
+  if (gap) return gap;
+  const sample = activeRows(catalog.rows)[0];
+  if (!sample) return need(ctx, "PAY-02", "payments.id");
+  const paymentId = idOf(sample);
+  if (!paymentId) return need(ctx, "PAY-02", "payments.id");
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  const dash = textOf(catalog.channel.dashboard_url);
+  const merchant = textOf(catalog.channel.merchant_id);
+  const env = textOf(catalog.channel.env);
+  const before = typeof sample.name === "string" ? sample.name : "";
+  const name = `doctor-session-${hash12()}`;
+  const input = { merchant_id: merchant, env, id: paymentId, name };
+  const updated = await trpcCall(dash, cookie, "payments.update", input);
+  if (updated.status < 200 || updated.status >= 300) {
+    return say(ctx.locale, "fail", COPY.http, {
+      id: "PAY-02",
+      status: updated.status
+    });
+  }
+  const next = openLive(ctx, catalog.channel);
+  const path = queryOf("/payments", scopeOf(catalog.channel));
+  const codes = [200];
+  const args = ["payments-session", "GET", path, codes] as const;
+  const step = await next.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  const seen = rowsOf(step.value).some(row => row.name === name);
+  const restore = { merchant_id: merchant, env, id: paymentId, name: before };
+  await trpcCall(dash, cookie, "payments.update", restore);
+  if (!seen) return say(ctx.locale, "fail", COPY.session);
+  return { status: "pass" };
+};
+
+const runPay03 = async (ctx: RunCtx): Promise<Outcome> => {
+  const gate = await allowed(ctx, "PAY-03", new Set(["kiosk"]));
+  if (isOutcome(gate)) return gate;
+  const catalog = await paymentsOf(ctx);
+  if (isOutcome(catalog)) return catalog;
+  const hidden = disabledIds(ctx.env);
+  const visible = moneyRows(catalog.rows).filter(row => {
+    return !hidden.has(idOf(row));
+  });
+  const redemption = visible.some(row => methodOf(row) === "REDEMPTION");
+  if (redemption) return say(ctx.locale, "fail", COPY.redemption);
+  if (visible.length > 0) return { status: "pass" };
+  const active = activeRows(catalog.rows);
+  const only = active.some(row => methodOf(row) === "REDEMPTION");
+  if (only) return say(ctx.locale, "fail", COPY.redemption);
+  const channel = channelLabel(catalog.channel);
+  return say(ctx.locale, "fail", COPY.empty, { channel });
+};
+
+const instructionGap = (body: string) => {
+  if (!body.includes("paymentInstructionKind")) return "paymentInstructionKind";
+  if (!body.includes("return null")) return "CASH";
+  if (!body.includes("PIN_PAD") || !body.includes('"card"')) return "PIN_PAD";
+  if (!body.includes("CARD")) return "CARD";
+  if (!body.includes("BANK_TRANSFER") || !body.includes("transfer")) {
+    return "BANK_TRANSFER";
+  }
+  if (!body.includes("WALLET") || !body.includes("wallet")) return "WALLET";
+  return "";
+};
+
+const runPay04 = async (ctx: RunCtx): Promise<Outcome> => {
+  const gate = await allowed(ctx, "PAY-04", new Set(["kiosk"]));
+  if (isOutcome(gate)) return gate;
+  const files = await readSources(ctx.cwd);
+  const file = files.find(item => {
+    return item.rel.endsWith("CheckoutFlowProvider.helpers.ts");
+  });
+  if (!file) return say(ctx.locale, "fail", COPY.instruction);
+  const gap = instructionGap(file.body);
+  if (gap === "CASH") return say(ctx.locale, "fail", COPY.cashHelp);
+  if (gap) return say(ctx.locale, "fail", COPY.unknown, { method: gap });
+  return { status: "pass" };
+};
+
+const preferredCash = (value: unknown) => {
+  if (!isRecord(value) || !Array.isArray(value.payments)) return false;
+  const rows = value.payments.filter(isRecord);
+  const preferred = rows.filter(row => row.preferred === true);
+  if (preferred.length !== 1) return false;
+  return preferred[0]?.type === "CASH";
+};
+
+const runPay05 = async (ctx: RunCtx): Promise<Outcome> => {
+  const ready = prepare(ctx, ["channel_id"]);
+  if (isOutcome(ready)) return ready;
+  const template = textOf(ready.template);
+  if (!PAY05.has(template)) {
+    return say(ctx.locale, "skip", COPY.pay05Skip, { template });
+  }
+  const named = namedOnly(ctx, "PAY-05");
+  if (named) return named;
+  const files = await readSources(ctx.cwd);
+  const surface = files.some(file => {
+    const section = file.rel.includes("CheckoutPaymentSection");
+    const meta = file.rel.includes("PaymentMetaForm");
+    if (!section && !meta) return false;
+    if (!file.body.includes("exactAmount")) return false;
+    return file.body.includes("preferred");
+  });
+  if (!surface) return say(ctx.locale, "fail", COPY.pay05Surface);
+  const liveReady = prepare(ctx, LIVE);
+  if (isOutcome(liveReady)) return liveReady;
+  const live = openLive(ctx, liveReady);
+  const cash = {
+    id: "doctor-cash",
+    type: "CASH",
+    preferred: true,
+    metadata: { exact_amount: true }
+  };
+  const card = {
+    id: "doctor-card",
+    type: "CARD",
+    alias: "Doctor",
+    brand: "visa",
+    first4: "4242",
+    last4: "4242",
+    exp_month: 12,
+    exp_year: 2030,
+    provider: "sandbox",
+    provider_payment_method_id: "pm_doctor",
+    preferred: false,
+    metadata: null
+  };
+  const body = { payments: [cash, card] };
+  const codes = [200];
+  const args = ["customer-pay", "PATCH", "/customers/me", codes, body] as const;
+  const step = await live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  if (!preferredCash(step.value))
+    return say(ctx.locale, "fail", COPY.preferred);
+  const cleared = { payments: [] };
+  const drop = [
+    "customer-clear",
+    "PATCH",
+    "/customers/me",
+    codes,
+    cleared
+  ] as const;
+  const gone = await live.storefront<unknown>(...drop);
+  if (!gone.ok) return fromLive(ctx.locale, gone.result);
+  return { status: "pass" };
+};
+
+const dueOf = (price: number) => new Big(String(price));
+
+const cashMath = (amount: Big, tendered: Big) => {
+  const given = tendered.lt(amount) ? amount : tendered;
+  const change = given.minus(amount);
+  return { given, change };
+};
+
+const runPay09 = async (ctx: RunCtx): Promise<Outcome> => {
+  const catalog = await paymentsOf(ctx);
+  if (isOutcome(catalog)) return catalog;
+  const cash = cashRow(catalog.rows);
+  if (!cash) {
+    const channel = channelLabel(catalog.channel);
+    return say(ctx.locale, "fail", COPY.noCash, { channel });
+  }
+  const id = idOf(cash);
+  if (disabledIds(ctx.env).has(id)) {
+    return say(ctx.locale, "fail", COPY.blocked, { id });
+  }
+  const menus = await catalog.live.menus();
+  if (!menus.ok) return fromLive(ctx.locale, menus.result);
+  const product = pickProduct(menus.value);
+  const price = product?.pricing?.price;
+  if (typeof price !== "number" || !Number.isFinite(price)) {
+    const channel = channelLabel(catalog.channel);
+    const field = "menus[].products[].pricing.price";
+    const vars = { channel, field };
+    return say(ctx.locale, "fail", SHARED.flowMissing, vars);
+  }
+  const due = dueOf(price);
+  const math = cashMath(due, due.plus("5"));
+  if (!math.change.eq("5")) return say(ctx.locale, "fail", COPY.change);
+  return { status: "pass" };
+};
+
+const runPay10 = async (ctx: RunCtx): Promise<Outcome> => {
+  const catalog = await paymentsOf(ctx);
+  if (isOutcome(catalog)) return catalog;
+  if (!cashRow(catalog.rows)) {
+    const channel = channelLabel(catalog.channel);
+    return say(ctx.locale, "fail", COPY.noCash, { channel });
+  }
+  const other = moneyRows(catalog.rows).find(row => methodOf(row) !== "CASH");
+  if (!other) return say(ctx.locale, "skip", COPY.splitSkip);
+  const cashLines = new Big("4.10");
+  const cardLines = new Big("6.20");
+  const fee = new Big("0.15");
+  const cardTender = cardLines.plus(fee);
+  const total = cashLines.plus(cardTender);
+  const expected = cashLines.plus(cardLines).plus(fee);
+  if (!total.eq(expected)) return say(ctx.locale, "fail", COPY.split);
+  return { status: "pass" };
+};
+
+const adapterOf = (rows: Row[]) => {
+  return moneyRows(rows).find(row => {
+    const method = methodOf(row);
+    if (method === "CASH") return false;
+    const provider = providerOf(row);
+    return provider !== "" && provider !== "firespark";
+  });
+};
+
+const environmentOf = (row: Row) => {
+  if (!isRecord(row.config)) return "";
+  const value = row.config.provider_environment;
+  return typeof value === "string" ? value : "";
+};
+
+const sandboxRow = (rows: Row[]) => {
+  return moneyRows(rows).find(row => {
+    if (methodOf(row) === "CASH") return false;
+    return environmentOf(row) === "sandbox";
+  });
+};
+
+const runPay08 = async (ctx: RunCtx): Promise<Outcome> => {
+  const catalog = await paymentsOf(ctx);
+  if (isOutcome(catalog)) return catalog;
+  const sandbox = sandboxRow(catalog.rows);
+  if (!sandbox) {
+    const adapter = adapterOf(catalog.rows);
+    if (!adapter) return say(ctx.locale, "skip", COPY.noAdapter);
+    const provider = providerOf(adapter) || methodOf(adapter);
+    return say(ctx.locale, "skip", COPY.noSandbox, { provider });
+  }
+  if (environmentOf(sandbox) === "production") {
+    const provider = providerOf(sandbox) || methodOf(sandbox);
+    return say(ctx.locale, "skip", COPY.noSandbox, { provider });
+  }
+  const id = idOf(sandbox);
+  const path = `/payments/${encodeURIComponent(id)}/operations/charge`;
+  const body = { input: {} };
+  const codes = [200, 201, 202];
+  const args = ["charge", "POST", path, codes, body] as const;
+  const step = await catalog.live.probe(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  return { status: "pass" };
+};
+
+const mixedOf = (value: unknown) => {
+  if (!isRecord(value)) return undefined;
+  const payments = value.payments;
+  if (!isRecord(payments)) return undefined;
+  return payments.mixed;
+};
+
+const runPay12 = async (ctx: RunCtx): Promise<Outcome> => {
+  const catalog = await paymentsOf(ctx);
+  if (isOutcome(catalog)) return catalog;
+  const codes = [200];
+  const prefArgs = ["preferences", "GET", "/preferences", codes] as const;
+  const step = await catalog.live.storefront<unknown>(...prefArgs);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  const mixed = mixedOf(step.value);
+  if (mixed === null || mixed === undefined) {
+    return say(ctx.locale, "skip", COPY.mixedOff);
+  }
+  if (!isRecord(mixed)) return say(ctx.locale, "fail", COPY.mixedShort);
+  const max = mixed.max_methods;
+  if (typeof max === "number" && max < 2) {
+    return say(ctx.locale, "fail", COPY.mixedShort);
+  }
+  if (moneyRows(catalog.rows).length < 2) {
+    return say(ctx.locale, "fail", COPY.mixedNeed);
+  }
+  return { status: "pass" };
+};
+
+const runPay13 = async (ctx: RunCtx): Promise<Outcome> => {
+  const gate = await allowed(ctx, "PAY-13", new Set(["dashboard"]));
+  if (isOutcome(gate)) return gate;
+  const named = namedOnly(ctx, "PAY-13");
+  if (named) return named;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const gap = dashGap(ctx, "PAY-13", ready);
+  if (gap) return gap;
+  const order = textOf(ctx.env.FIRESPARK_DOCTOR_ORDER_ID);
+  if (!order) return need(ctx, "PAY-13", "FIRESPARK_DOCTOR_ORDER_ID");
+  const tender = textOf(ctx.env.FIRESPARK_DOCTOR_TENDER_ID);
+  if (!tender) return need(ctx, "PAY-13", "FIRESPARK_DOCTOR_TENDER_ID");
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  const dash = textOf(ready.dashboard_url);
+  const merchant = textOf(ready.merchant_id);
+  const env = textOf(ready.env);
+  const refund = {
+    merchant_id: merchant,
+    env,
+    id: order,
+    tender_id: tender,
+    body: { idempotency_key: randomUUID() }
+  };
+  const wrote = await trpcCall(dash, cookie, "orders.refundTender", refund);
+  if (wrote.status < 200 || wrote.status >= 300) {
+    return say(ctx.locale, "fail", COPY.http, {
+      id: "PAY-13",
+      status: wrote.status
+    });
+  }
+  const live = openLive(ctx, ready);
+  const path = `/orders/${encodeURIComponent(order)}/tenders/${tender}/refund`;
+  const codes = [401, 403];
+  const denied = ["refund-denied", "POST", path, codes, {}] as const;
+  const probe = await live.probe(...denied);
+  if (!probe.ok) return fromLive(ctx.locale, probe.result);
+  const status = probe.value.status;
+  if (status >= 200 && status < 300) {
+    return say(ctx.locale, "fail", COPY.refunded);
+  }
+  return { status: "pass" };
+};
+
+const ORDER_FIELDS = [
+  ...LIVE,
+  "store_id",
+  "fulfillment_id",
+  "payment",
+  "merchant_id"
+] as const;
+
+const runPay07 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = namedOrderSkip(ctx, "PAY-07");
+  if (skipped) return skipped;
+  const ready = prepare(ctx, ORDER_FIELDS);
+  if (isOutcome(ready)) return ready;
+  if (!paymentOf(textOf(ready.payment))) {
+    return say(ctx.locale, "fail", COPY.notCash);
+  }
+  const catalog = await paymentsOf(ctx);
+  if (isOutcome(catalog)) return catalog;
+  const cash = cashRow(catalog.rows);
+  if (!cash) {
+    const channel = channelLabel(catalog.channel);
+    return say(ctx.locale, "fail", COPY.noCash, { channel });
+  }
+  if (ready.template === "pos") {
+    const due = new Big("10.00");
+    const math = cashMath(due, due);
+    if (!math.change.eq(0)) return say(ctx.locale, "fail", COPY.change);
+    return { status: "pass" };
+  }
+  const menus = await catalog.live.menus();
+  if (!menus.ok) return fromLive(ctx.locale, menus.result);
+  const product = pickProduct(menus.value);
+  if (!product?.id) {
+    const channel = channelLabel(ready);
+    const field = "menus[].products";
+    const missing = { channel, field };
+    return say(ctx.locale, "fail", SHARED.flowMissing, missing);
+  }
+  const id = newOrderId(textOf(ready.store_id));
+  const menu = menus.value.find(item => item.products?.includes(product));
+  const config = liveConfigOf(ready, ctx.env);
+  const lineUid = randomUUID();
+  const b1 = { id, config, product, lineUid };
+  const built = buildOrderBody({ ...b1, menuId: menu?.id });
+  const codes = [201, 202];
+  const create = ["order-create", "POST", "/orders", codes, built] as const;
+  const created = await catalog.live.storefront<{ id?: string }>(...create);
+  if (!created.ok) return fromLive(ctx.locale, created.result);
+  const payment = { type: "CASH", id: idOf(cash) };
+  const placePath = `/orders/${encodeURIComponent(id)}/place`;
+  const body = { payment };
+  const placeArgs = ["order-place", "POST", placePath, codes, body] as const;
+  const place = catalog.live.storefront<{ status?: string }>;
+  const placed = await place(...placeArgs);
+  if (!placed.ok) return fromLive(ctx.locale, placed.result);
+  const status = placed.value.status ?? "";
+  if (!PLACE.has(status)) {
+    return say(ctx.locale, "fail", COPY.placeStatus, { status: status || "—" });
+  }
+  return { status: "pass" };
+};
+
+export const PAY_BINDINGS: Record<string, CheckBinding> = {
+  "PAY-01": withSafeFix(runPay01),
+  "PAY-02": withSafeFix(runPay02),
+  "PAY-03": withSafeFix(runPay03),
+  "PAY-04": withSafeFix(runPay04),
+  "PAY-05": withSafeFix(runPay05),
+  "PAY-07": withSafeFix(runPay07),
+  "PAY-08": withSafeFix(runPay08),
+  "PAY-09": withSafeFix(runPay09),
+  "PAY-10": withSafeFix(runPay10),
+  "PAY-12": withSafeFix(runPay12),
+  "PAY-13": withSafeFix(runPay13)
+};