@fire-spark/cli 0.0.0-stage → 0.13.3

package/bin/firespark.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { register } from "tsx/esm/api";
+
+// Piping into `head` closes stdout early; that is not an error.
+process.stdout.on("error", error => {
+  if (error.code === "EPIPE") process.exit(process.exitCode ?? 0);
+  throw error;
+});
+
+register();
+
+const { run } = await import("../src/main.ts");
+
+process.exitCode = await run(process.argv.slice(2));

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@fire-spark/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.13.3",
+  "description": "Fire Spark command line: doctor and future commands",
+  "type": "module",
+  "bin": {
+    "firespark": "./bin/firespark.mjs"
+  },
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "files": [
+    "bin",
+    "src",
+    "!src/**/*.test.ts"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "big.js": "6.2.1",
+    "tsx": "^4.23.15"
+  },
+  "devDependencies": {
+    "@types/big.js": "6.2.2",
+    "vitest": "^2.1.8"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "start": "node ./bin/firespark.mjs",
+    "doctor": "node ./bin/firespark.mjs doctor",
+    "check-types": "tsc --noEmit",
+    "test:utils": "vitest run",
+    "lint": "oxlint ./src --max-warnings=0",
+    "format": "oxfmt ./src",
+    "check-format": "oxfmt --check ./src"
+  }
 }

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

@@ -0,0 +1,553 @@
+import { randomUUID } from "node:crypto";
+
+import type { Copy } from "../../../core/i18n";
+import { fromLive, isOutcome, isRecord, openLive, prepare } from "./flow";
+import { isActive, queryOf, rowsOf, say, textOf, trpcCall } from "./flow";
+import { withSafeFix } from "./flow";
+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 = {
+  channel: line(
+    "{id} no aplica al canal {template}.",
+    "{id} does not apply to the {template} channel.",
+    "{id} não se aplica ao canal {template}."
+  ),
+  need: line(
+    "{id} se omite: falta {field}.",
+    "{id} is skipped: {field} is missing.",
+    "{id} é omitido: falta {field}."
+  ),
+  redeem: line(
+    "MKT-04 se omite: no hay un payment REDEMPTION activo.",
+    "MKT-04 is skipped: there is no active REDEMPTION payment.",
+    "MKT-04 é omitido: não há um payment REDEMPTION ativo."
+  ),
+  analytics: line(
+    "MKT-05 se omite: preferences no trae analytics.",
+    "MKT-05 is skipped: preferences has no analytics.",
+    "MKT-05 é omitido: preferences não traz analytics."
+  ),
+  named: line(
+    "{id} solo corre cuando lo nombras. No envié nada.",
+    "{id} runs only when you name it. Nothing was sent.",
+    "{id} só roda quando você o nomeia. Nada foi enviado."
+  ),
+  masivo: line(
+    "MKT-03 se omite: Masivo no está habilitado.",
+    "MKT-03 is skipped: Masivo is not enabled.",
+    "MKT-03 é omitido: o Masivo não está habilitado."
+  ),
+  receiver: line(
+    "ADM-02 el receiver no respondió.",
+    "ADM-02 the receiver did not respond.",
+    "ADM-02 o receiver não respondeu."
+  ),
+  floor: line(
+    "MES-03 la respuesta de /pos/floor no es JSON.",
+    "MES-03 /pos/floor did not return JSON.",
+    "MES-03 /pos/floor não devolveu JSON."
+  )
+};
+
+const LIVE = [
+  "api_url",
+  "channel_id",
+  "FIRESPARK_DOCTOR_CUSTOMER_EMAIL",
+  "FIRESPARK_DOCTOR_CUSTOMER_PASSWORD",
+  "FIRESPARK_DOCTOR_FIREBASE_API_KEY"
+] as const;
+
+const NAMES = ["menu_viewed", "product_viewed", "add_to_cart", "purchase"];
+
+const applies = (ctx: RunCtx, id: string, allowed: ReadonlySet<string>) => {
+  const ready = prepare(ctx, ["channel_id"]);
+  if (isOutcome(ready)) return ready;
+  const template = textOf(ready.template);
+  if (allowed.has(template)) return null;
+  return say(ctx.locale, "skip", COPY.channel, { id, template });
+};
+
+const need = (ctx: RunCtx, id: string, field: string) => {
+  return say(ctx.locale, "skip", COPY.need, { id, field });
+};
+
+const onlyNamed = (ctx: RunCtx, id: string) => {
+  if (ctx.named.has(id)) return null;
+  return say(ctx.locale, "skip", COPY.named, { id });
+};
+
+const methodOf = (row: Record<string, unknown>) => {
+  if (!isRecord(row.method)) return "";
+  return typeof row.method.method === "string" ? row.method.method : "";
+};
+
+const preferencesOf = async (ctx: RunCtx, channel: YamlChannel) => {
+  const live = openLive(ctx, channel);
+  const codes = [200];
+  const args = ["preferences", "GET", "/preferences", codes] as const;
+  const step = await live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  return { live, value: step.value };
+};
+
+const runMkt04 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "MKT-04", new Set(["kiosk", "web", "app"]));
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const loaded = await preferencesOf(ctx, ready);
+  if (isOutcome(loaded)) return loaded;
+  const path = queryOf("/payments", { channel_id: textOf(ready.channel_id) });
+  const codes = [200];
+  const args = ["payments", "GET", path, codes] as const;
+  const step = await loaded.live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  const found = rowsOf(step.value).some(row => {
+    return isActive(row) && methodOf(row) === "REDEMPTION";
+  });
+  if (!found) return say(ctx.locale, "skip", COPY.redeem);
+  return need(ctx, "MKT-04", "orders.total");
+};
+
+const runMkt05 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set([
+    "kiosk",
+    "web",
+    "app",
+    "chat",
+    "call-center",
+    "dashboard"
+  ]);
+  const skipped = applies(ctx, "MKT-05", allowed);
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const loaded = await preferencesOf(ctx, ready);
+  if (isOutcome(loaded)) return loaded;
+  const analytics = isRecord(loaded.value) ? loaded.value.analytics : undefined;
+  if (!isRecord(analytics)) return say(ctx.locale, "skip", COPY.analytics);
+  const plans = analytics.plans ?? analytics.tracking_plans;
+  if (!Array.isArray(plans) || plans.length === 0) {
+    return need(ctx, "MKT-05", "trackingPlans");
+  }
+  const destinations = analytics.destinations;
+  if (!Array.isArray(destinations) || destinations.length === 0) {
+    return need(ctx, "MKT-05", "analytics.destinations");
+  }
+  return { status: "pass" };
+};
+
+const eventOf = (channel: YamlChannel, name: string) => {
+  const id = randomUUID();
+  const session_id = randomUUID();
+  const head = { id, session_id, is_anonymous: false, name };
+  const when = { timestamp: new Date().toISOString(), platform: "web" };
+  const channel_id = textOf(channel.channel_id);
+  const store_id = textOf(channel.store_id);
+  const scope = { channel_id, store_id };
+  const properties = name === "menu_viewed" ? undefined : { product_id: "p1" };
+  if (name === "purchase") {
+    const order = { order_id: "o1" };
+    return { ...head, ...when, ...scope, properties: order };
+  }
+  if (name === "add_to_cart") {
+    const cart = { product_id: "p1", quantity: 1 };
+    return { ...head, ...when, ...scope, properties: cart };
+  }
+  if (!properties) return { ...head, ...when, ...scope };
+  return { ...head, ...when, ...scope, properties };
+};
+
+const runMkt07 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set([
+    "kiosk",
+    "web",
+    "app",
+    "chat",
+    "call-center",
+    "dashboard"
+  ]);
+  const skipped = applies(ctx, "MKT-07", allowed);
+  if (skipped) return skipped;
+  const named = onlyNamed(ctx, "MKT-07");
+  if (named) return named;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const loaded = await preferencesOf(ctx, ready);
+  if (isOutcome(loaded)) return loaded;
+  const events = NAMES.map(name => eventOf(ready, name));
+  const codes = [200, 201, 202];
+  const body = { events };
+  const args = ["analytics", "POST", "/analytics/events", codes, body] as const;
+  const step = await loaded.live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  return { status: "pass" };
+};
+
+const runMkt03 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "MKT-03", new Set(["dashboard"]));
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const loaded = await preferencesOf(ctx, ready);
+  if (isOutcome(loaded)) return loaded;
+  const masivo = isRecord(loaded.value) ? loaded.value.masivo : null;
+  const coupons = isRecord(masivo) && masivo.coupons_enabled;
+  const loyalty = isRecord(masivo) && masivo.loyalty_enabled;
+  const enabled = coupons || loyalty;
+  if (!enabled) return say(ctx.locale, "skip", COPY.masivo);
+  const path = queryOf("/payments", { channel_id: textOf(ready.channel_id) });
+  const codes = [200];
+  const args = ["redemptions", "GET", path, codes] as const;
+  const step = await loaded.live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  const reflected = rowsOf(step.value).some(row => {
+    return methodOf(row) === "REDEMPTION" && typeof row.id === "string";
+  });
+  if (!reflected) return need(ctx, "MKT-03", "masivo.redemption");
+  return { status: "pass" };
+};
+
+const runAdm06 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set([
+    "kiosk",
+    "pos",
+    "web",
+    "app",
+    "chat",
+    "call-center",
+    "dashboard"
+  ]);
+  const skipped = applies(ctx, "ADM-06", allowed);
+  if (skipped) return skipped;
+  const named = onlyNamed(ctx, "ADM-06");
+  if (named) return named;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const loaded = await preferencesOf(ctx, ready);
+  if (isOutcome(loaded)) return loaded;
+  const entry = {
+    level: "info",
+    message: "firespark doctor",
+    channel_id: textOf(ready.channel_id)
+  };
+  const codes = [200, 201, 202];
+  const body = { logs: [entry] };
+  const args = ["logs", "POST", "/logs", codes, body] as const;
+  const step = await loaded.live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  return { status: "pass" };
+};
+
+const customerOf = async (ctx: RunCtx, channel: YamlChannel, id: string) => {
+  const live = openLive(ctx, channel);
+  const codes = [200];
+  const args = ["customer", "GET", "/customers/me", codes] as const;
+  const step = await live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  if (!isRecord(step.value)) return need(ctx, id, "customers.me");
+  return step.value;
+};
+
+const runMkt01 = async (ctx: RunCtx): Promise<Outcome> => {
+  const channels = new Set(["kiosk", "pos", "dashboard"]);
+  const skipped = applies(ctx, "MKT-01", channels);
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const live = openLive(ctx, ready);
+  const path = queryOf("/menus", { channel_id: textOf(ready.channel_id) });
+  const codes = [200];
+  const args = ["menus", "GET", path, codes] as const;
+  const step = await live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  const rows = rowsOf(step.value);
+  const types = new Set<string>();
+  for (const row of rows) {
+    const products = Array.isArray(row.products) ? row.products : [];
+    for (const product of products.filter(isRecord)) {
+      const recs = product.recommendations;
+      if (!Array.isArray(recs)) continue;
+      for (const rec of recs) {
+        if (isRecord(rec) && typeof rec.type === "string") types.add(rec.type);
+      }
+    }
+  }
+  if (types.size === 0) return need(ctx, "MKT-01", "recommendations");
+  const known = ["UPSELL", "CROSS_SELL", "DOWNSELL"];
+  if (!known.some(type => types.has(type))) {
+    return need(ctx, "MKT-01", "recommendations.type");
+  }
+  return { status: "pass" };
+};
+
+const runMkt02 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "MKT-02", new Set(["dashboard"]));
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const live = openLive(ctx, ready);
+  const codes = [200];
+  const args = ["preferences", "GET", "/preferences", codes] as const;
+  const step = await live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  const masivo = isRecord(step.value) ? step.value.masivo : undefined;
+  const coupons = isRecord(masivo) && masivo.coupons_enabled === true;
+  const loyalty = isRecord(masivo) && masivo.loyalty_enabled === true;
+  if (!coupons && !loyalty)
+    return need(ctx, "MKT-02", "masivo.coupons_enabled");
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  if (!cookie) return need(ctx, "MKT-02", "FIRESPARK_DOCTOR_DASHBOARD_COOKIE");
+  const dash = textOf(ready.dashboard_url);
+  if (!dash) return need(ctx, "MKT-02", "dashboard_url");
+  const root = dash.replace(/\/$/, "");
+  const products = coupons ? ["coupons"] : [];
+  if (loyalty) products.push("loyalty");
+  for (const product of products) {
+    const url = `${root}/masivo?product=${product}`;
+    try {
+      const page = await fetch(url, { headers: { cookie } });
+      if (page.status < 200 || page.status >= 300) {
+        return need(ctx, "MKT-02", `masivo.product=${product}`);
+      }
+    } catch {
+      return need(ctx, "MKT-02", `masivo.product=${product}`);
+    }
+  }
+  return { status: "pass" };
+};
+
+const runMkt08 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set(["kiosk", "web", "app", "chat", "call-center"]);
+  const skipped = applies(ctx, "MKT-08", allowed);
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const customer = await customerOf(ctx, ready, "MKT-08");
+  if (isOutcome(customer)) return customer;
+  const consent = isRecord(customer.consent) ? customer.consent : undefined;
+  const notes = customer.notification_preferences;
+  if (!isRecord(consent) || typeof consent.marketing !== "boolean") {
+    return need(ctx, "MKT-08", "customers.consent.marketing");
+  }
+  if (!isRecord(notes) || typeof notes.email !== "boolean") {
+    return need(ctx, "MKT-08", "notification_preferences.email");
+  }
+  if (typeof notes.push !== "boolean") {
+    return need(ctx, "MKT-08", "notification_preferences.push");
+  }
+  return { status: "pass" };
+};
+
+const dashboardRead = async (ctx: RunCtx, id: string, procedure: string) => {
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  if (!cookie) return need(ctx, id, "FIRESPARK_DOCTOR_DASHBOARD_COOKIE");
+  const dash = textOf(ready.dashboard_url);
+  if (!dash) return need(ctx, id, "dashboard_url");
+  const input = {
+    merchant_id: textOf(ready.merchant_id),
+    env: textOf(ready.env)
+  };
+  const step = await trpcCall(dash, cookie, procedure, input);
+  if (step.status < 200 || step.status >= 300) {
+    return say(ctx.locale, "fail", COPY.receiver);
+  }
+  return { status: "pass" as const };
+};
+
+const runAdm01 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "ADM-01", new Set(["dashboard"]));
+  if (skipped) return skipped;
+  const procedures = [
+    "merchants.selectByRange",
+    "organizations.selectByRange",
+    "environments.selectByRange",
+    "stores.selectByRange",
+    "brands.selectByRange",
+    "channels.selectByRange",
+    "entityLabels.selectByRange"
+  ];
+  for (const procedure of procedures) {
+    const step = await dashboardRead(ctx, "ADM-01", procedure);
+    if (step.status !== "pass") return step;
+  }
+  return { status: "pass" };
+};
+
+const runAdm02 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "ADM-02", new Set(["server", "dashboard"]));
+  if (skipped) return skipped;
+  const ready = prepare(ctx, ["receiver"]);
+  if (isOutcome(ready)) return ready;
+  const body = JSON.stringify({ event: "order.fulfilled" });
+  const headers: Record<string, string> = {
+    "content-type": "application/json"
+  };
+  const secret = textOf(ctx.env.FIRESPARK_DOCTOR_WEBHOOK_SECRET);
+  if (secret) headers["x-firespark-signature"] = secret;
+  try {
+    const signal = AbortSignal.timeout(15000);
+    const url = textOf(ready.receiver);
+    const init = { method: "POST", headers, body, signal };
+    const page = await fetch(url, init);
+    if (page.status < 200 || page.status >= 300) {
+      return say(ctx.locale, "fail", COPY.receiver);
+    }
+    return { status: "pass" };
+  } catch {
+    return say(ctx.locale, "fail", COPY.receiver);
+  }
+};
+
+const runAdm03 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "ADM-03", new Set(["dashboard"]));
+  if (skipped) return skipped;
+  const procedures = [
+    "orderMigrations.selectByRange",
+    "customerMigrations.selectByRange",
+    "exports.selectByRange",
+    "auditLogs.selectByRange"
+  ];
+  for (const procedure of procedures) {
+    const step = await dashboardRead(ctx, "ADM-03", procedure);
+    if (step.status !== "pass") return step;
+  }
+  return { status: "pass" };
+};
+
+const runAdm04 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "ADM-04", new Set(["dashboard"]));
+  if (skipped) return skipped;
+  const named = onlyNamed(ctx, "ADM-04");
+  if (named) return named;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  if (!cookie) return need(ctx, "ADM-04", "FIRESPARK_DOCTOR_DASHBOARD_COOKIE");
+  const template = textOf(ready.template);
+  if (!template) return need(ctx, "ADM-04", "template");
+  const dash = textOf(ready.dashboard_url);
+  if (!dash) return need(ctx, "ADM-04", "dashboard_url");
+  const input = {
+    merchant_id: textOf(ready.merchant_id),
+    env: textOf(ready.env),
+    template
+  };
+  const step = await trpcCall(dash, cookie, "builder.insert", input);
+  if (step.status < 200 || step.status >= 300) {
+    return say(ctx.locale, "fail", COPY.receiver);
+  }
+  return { status: "pass" };
+};
+
+const runAdm05 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set([
+    "kiosk",
+    "web",
+    "app",
+    "chat",
+    "call-center",
+    "dashboard"
+  ]);
+  const skipped = applies(ctx, "ADM-05", allowed);
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const customer = await customerOf(ctx, ready, "ADM-05");
+  if (isOutcome(customer)) return customer;
+  const email = typeof customer.email === "string" ? customer.email : "";
+  if (!email.includes("@")) return need(ctx, "ADM-05", "customers.email");
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  if (!cookie) return need(ctx, "ADM-05", "FIRESPARK_DOCTOR_DASHBOARD_COOKIE");
+  const dash = textOf(ready.dashboard_url);
+  if (!dash) return need(ctx, "ADM-05", "dashboard_url");
+  const input = {
+    merchant_id: textOf(ready.merchant_id),
+    env: textOf(ready.env),
+    q: email
+  };
+  const step = await trpcCall(dash, cookie, "customers.selectByRange", input);
+  if (step.status < 200 || step.status >= 300) {
+    return say(ctx.locale, "fail", COPY.receiver);
+  }
+  if (!step.text.includes(email)) return need(ctx, "ADM-05", "customers.email");
+  return { status: "pass" };
+};
+
+const floorOf = async (ctx: RunCtx, id: string) => {
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const uid = textOf(ctx.env.FIRESPARK_DOCTOR_DEVICE_UID);
+  const secret = textOf(ctx.env.FIRESPARK_DOCTOR_DEVICE_SECRET);
+  if (!uid) return need(ctx, id, "FIRESPARK_DOCTOR_DEVICE_UID");
+  if (!secret) return need(ctx, id, "FIRESPARK_DOCTOR_DEVICE_SECRET");
+  const live = openLive(ctx, ready);
+  const body = { device_uid: uid, device_secret: secret };
+  const codes = [200];
+  const args = ["floor", "POST", "/pos/floor", codes, body] as const;
+  const step = await live.probe(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  return step.value.text;
+};
+
+const runMes01 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "MES-01", new Set(["pos", "dashboard"]));
+  if (skipped) return skipped;
+  const body = await floorOf(ctx, "MES-01");
+  if (isOutcome(body)) return body;
+  return { status: "pass" };
+};
+
+const runMes02 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "MES-02", new Set(["pos"]));
+  if (skipped) return skipped;
+  const body = await floorOf(ctx, "MES-02");
+  if (isOutcome(body)) return body;
+  return { status: "pass" };
+};
+
+const runMes03 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "MES-03", new Set(["pos", "dashboard"]));
+  if (skipped) return skipped;
+  const body = await floorOf(ctx, "MES-03");
+  if (isOutcome(body)) return body;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return say(ctx.locale, "fail", COPY.floor);
+  }
+  const data = isRecord(parsed) && isRecord(parsed.data) ? parsed.data : parsed;
+  const occupancy = isRecord(data) ? data.occupancy : undefined;
+  const rows = isRecord(occupancy) ? occupancy.reservations : undefined;
+  if (!Array.isArray(rows) || rows.length === 0) {
+    return need(ctx, "MES-03", "occupancy.reservations");
+  }
+  return { status: "pass" };
+};
+
+export const ADMIN_BINDINGS: Record<string, CheckBinding> = {
+  "MKT-01": withSafeFix(runMkt01),
+  "MKT-02": withSafeFix(runMkt02),
+  "MKT-03": withSafeFix(runMkt03),
+  "MKT-04": withSafeFix(runMkt04),
+  "MKT-05": withSafeFix(runMkt05),
+  "MKT-07": withSafeFix(runMkt07),
+  "MKT-08": withSafeFix(runMkt08),
+  "ADM-01": withSafeFix(runAdm01),
+  "ADM-02": withSafeFix(runAdm02),
+  "ADM-03": withSafeFix(runAdm03),
+  "ADM-04": withSafeFix(runAdm04),
+  "ADM-05": withSafeFix(runAdm05),
+  "ADM-06": withSafeFix(runAdm06),
+  "MES-01": withSafeFix(runMes01),
+  "MES-02": withSafeFix(runMes02),
+  "MES-03": withSafeFix(runMes03)
+};