fresh-squeezy 0.2.0 → 0.3.0

package/dist/cli.js

@@ -5,6 +5,21 @@ import { readFileSync as readFileSync2 } from "fs";
 import { Command } from "commander";
 import dotenv from "dotenv";
 
+// src/core/errors.ts
+var FreshSqueezyError = class _FreshSqueezyError extends Error {
+  code;
+  status;
+  detail;
+  constructor(opts) {
+    super(opts.message);
+    this.name = "FreshSqueezyError";
+    this.code = opts.code;
+    this.status = opts.status;
+    this.detail = opts.detail;
+    Object.setPrototypeOf(this, _FreshSqueezyError.prototype);
+  }
+};
+
 // src/cli/commands/augment.ts
 import { existsSync } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
@@ -217,21 +232,6 @@ export type {
 `;
 };
 
-// src/core/errors.ts
-var FreshSqueezyError = class _FreshSqueezyError extends Error {
-  code;
-  status;
-  detail;
-  constructor(opts) {
-    super(opts.message);
-    this.name = "FreshSqueezyError";
-    this.code = opts.code;
-    this.status = opts.status;
-    this.detail = opts.detail;
-    Object.setPrototypeOf(this, _FreshSqueezyError.prototype);
-  }
-};
-
 // src/core/config.ts
 var DEFAULT_BASE_URL = "https://api.lemonsqueezy.com";
 var ENV_KEYS = {
@@ -314,46 +314,6 @@ var HttpClient = class {
     const doc = await this.request({ path: path4 });
     return doc.data;
   }
-  /**
-   * POST a JSON:API document and return the created `data` resource.
-   *
-   * @param path - API path starting with `/v1/...`.
-   * @param body - JSON:API create document.
-   * @returns The created resource.
-   */
-  async postResource(path4, body) {
-    const doc = await this.request({ method: "POST", path: path4, body });
-    return doc.data;
-  }
-  /**
-   * PATCH a JSON:API document and return the updated `data` resource.
-   *
-   * @param path - API path starting with `/v1/...`.
-   * @param body - JSON:API update document.
-   * @returns The updated resource.
-   */
-  async patchResource(path4, body) {
-    const doc = await this.request({ method: "PATCH", path: path4, body });
-    return doc.data;
-  }
-  /**
-   * DELETE a resource. Lemon Squeezy often returns an empty body on success.
-   *
-   * @param path - API path starting with `/v1/...`.
-   * @returns Nothing — single void return, not a multi-field bag.
-   */
-  async deleteResource(path4) {
-    await this.request({ method: "DELETE", path: path4 });
-  }
-  /**
-   * Fetch a single page of a JSON:API collection. Most callers want
-   * `paginate()` instead — this method is kept for one-shot lookups where
-   * the caller knows the result fits in a single page.
-   */
-  async getCollection(path4, query) {
-    const doc = await this.request({ path: path4, query });
-    return doc.data;
-  }
   /**
    * Walk a JSON:API collection across every page and concatenate the
    * results. Lemon Squeezy returns 25 items per page by default; without
@@ -416,582 +376,84 @@ var extractJsonApiErrors = (responseBody) => {
   );
 };
 
-// src/resources/affiliates.ts
-var getAffiliate = async (http, affiliateId) => {
-  return http.getResource(`/v1/affiliates/${affiliateId}`);
-};
-var listAffiliatesForStore = async (http, storeId) => {
-  return http.paginate("/v1/affiliates", {
-    "filter[store_id]": String(storeId)
-  });
-};
-
-// src/resources/checkouts.ts
-var getCheckout = async (http, checkoutId) => {
-  return http.getResource(`/v1/checkouts/${checkoutId}`);
-};
-var listCheckoutsForStore = async (http, storeId) => {
-  return http.paginate("/v1/checkouts", {
-    "filter[store_id]": String(storeId)
-  });
-};
-var createCheckout = async (http, body) => {
-  return http.postResource("/v1/checkouts", body);
-};
-
-// src/resources/customers.ts
-var getCustomer = async (http, customerId) => {
-  return http.getResource(`/v1/customers/${customerId}`);
-};
-var listCustomersForStore = async (http, storeId) => {
-  return http.paginate("/v1/customers", {
-    "filter[store_id]": String(storeId)
-  });
-};
-var createCustomer = async (http, body) => {
-  return http.postResource("/v1/customers", body);
-};
-var updateCustomer = async (http, customerId, body) => {
-  return http.patchResource(`/v1/customers/${customerId}`, body);
-};
-
-// src/resources/discountRedemptions.ts
-var getDiscountRedemption = async (http, discountRedemptionId) => {
-  return http.getResource(
-    `/v1/discount-redemptions/${discountRedemptionId}`
-  );
-};
-var listDiscountRedemptionsForDiscount = async (http, discountId) => {
-  return http.paginate("/v1/discount-redemptions", {
-    "filter[discount_id]": String(discountId)
-  });
-};
-
-// src/resources/discounts.ts
-var getDiscount = async (http, discountId) => {
-  return http.getResource(`/v1/discounts/${discountId}`);
-};
-var listDiscountsForStore = async (http, storeId) => {
-  return http.paginate("/v1/discounts", {
-    "filter[store_id]": String(storeId)
-  });
-};
-var createDiscount = async (http, body) => {
-  return http.postResource("/v1/discounts", body);
-};
-var deleteDiscount = async (http, discountId) => {
-  await http.deleteResource(`/v1/discounts/${discountId}`);
-};
-
-// src/resources/files.ts
-var getFile = async (http, fileId) => {
-  return http.getResource(`/v1/files/${fileId}`);
-};
-var listFilesForVariant = async (http, variantId) => {
-  return http.paginate("/v1/files", {
-    "filter[variant_id]": String(variantId)
-  });
-};
-
-// src/resources/licenseKeyInstances.ts
-var getLicenseKeyInstance = async (http, licenseKeyInstanceId) => {
-  return http.getResource(
-    `/v1/license-key-instances/${licenseKeyInstanceId}`
-  );
-};
-var listLicenseKeyInstancesForLicenseKey = async (http, licenseKeyId) => {
-  return http.paginate("/v1/license-key-instances", {
-    "filter[license_key_id]": String(licenseKeyId)
-  });
-};
-
-// src/resources/licenseKeys.ts
-var getLicenseKey = async (http, licenseKeyId) => {
-  return http.getResource(`/v1/license-keys/${licenseKeyId}`);
-};
-var listLicenseKeysForStore = async (http, storeId) => {
-  return http.paginate("/v1/license-keys", {
-    "filter[store_id]": String(storeId)
-  });
-};
-var updateLicenseKey = async (http, licenseKeyId, body) => {
-  return http.patchResource(`/v1/license-keys/${licenseKeyId}`, body);
-};
-
-// src/resources/orderItems.ts
-var getOrderItem = async (http, orderItemId) => {
-  return http.getResource(`/v1/order-items/${orderItemId}`);
-};
-var listOrderItemsForOrder = async (http, orderId) => {
-  return http.paginate("/v1/order-items", {
-    "filter[order_id]": String(orderId)
-  });
-};
-
-// src/resources/orders.ts
-var getOrder = async (http, orderId) => {
-  return http.getResource(`/v1/orders/${orderId}`);
-};
-var listOrdersForStore = async (http, storeId) => {
-  return http.paginate("/v1/orders", {
-    "filter[store_id]": String(storeId)
-  });
-};
-var refundOrder = async (http, orderId, body) => {
-  return http.postResource(`/v1/orders/${orderId}/refund`, body ?? {});
-};
-var generateOrderInvoice = async (http, orderId, body) => {
-  return http.request({
-    method: "POST",
-    path: `/v1/orders/${orderId}/generate-invoice`,
-    body: body ?? {}
-  });
-};
-
-// src/resources/prices.ts
-var getPrice = async (http, priceId) => {
-  return http.getResource(`/v1/prices/${priceId}`);
-};
-var listPricesForVariant = async (http, variantId) => {
-  return http.paginate("/v1/prices", {
-    "filter[variant_id]": String(variantId)
-  });
-};
-
-// src/resources/products.ts
-var getProduct = async (http, productId) => {
-  return http.getResource(`/v1/products/${productId}`);
-};
-var listProducts = async (http, storeId) => {
-  return http.paginate("/v1/products", {
-    "filter[store_id]": String(storeId)
-  });
-};
-
 // src/resources/registry.ts
-var resourceRegistry = [
-  // users
-  { resource: "user", verb: "get", docsPath: "users/retrieve-user", body: "none", idRole: "none" },
-  // stores (read-only)
-  { resource: "store", verb: "get", docsPath: "stores/retrieve-store", body: "none", idRole: "id" },
-  {
-    resource: "store",
-    verb: "list",
-    docsPath: "stores/list-all-stores",
-    body: "none",
-    idRole: "none"
-  },
-  // products (read-only)
-  {
-    resource: "product",
-    verb: "get",
-    docsPath: "products/retrieve-product",
-    body: "none",
-    idRole: "id"
-  },
-  {
-    resource: "product",
-    verb: "list",
-    docsPath: "products/list-all-products",
-    body: "none",
-    idRole: "store"
-  },
-  // variants (read-only)
-  {
-    resource: "variant",
-    verb: "get",
-    docsPath: "variants/retrieve-variant",
-    body: "none",
-    idRole: "id"
-  },
-  {
-    resource: "variant",
-    verb: "list",
-    docsPath: "variants/list-all-variants",
-    body: "none",
-    idRole: "parent"
-  },
-  // prices (read-only)
-  { resource: "price", verb: "get", docsPath: "prices/retrieve-price", body: "none", idRole: "id" },
-  {
-    resource: "price",
-    verb: "list",
-    docsPath: "prices/list-all-prices",
-    body: "none",
-    idRole: "parent"
-  },
-  // files (read-only)
-  { resource: "file", verb: "get", docsPath: "files/retrieve-file", body: "none", idRole: "id" },
-  {
-    resource: "file",
-    verb: "list",
-    docsPath: "files/list-all-files",
-    body: "none",
-    idRole: "parent"
-  },
-  // customers
-  {
-    resource: "customer",
-    verb: "get",
-    docsPath: "customers/retrieve-customer",
-    body: "none",
-    idRole: "id"
-  },
-  {
-    resource: "customer",
-    verb: "list",
-    docsPath: "customers/list-all-customers",
-    body: "none",
-    idRole: "store"
-  },
-  {
-    resource: "customer",
-    verb: "create",
-    docsPath: "customers/create-customer",
-    body: "required",
-    idRole: "none"
-  },
-  {
-    resource: "customer",
-    verb: "update",
-    docsPath: "customers/update-customer",
-    body: "required",
-    idRole: "id"
-  },
-  // orders
-  { resource: "order", verb: "get", docsPath: "orders/retrieve-order", body: "none", idRole: "id" },
-  {
-    resource: "order",
-    verb: "list",
-    docsPath: "orders/list-all-orders",
-    body: "none",
-    idRole: "store"
-  },
-  {
-    resource: "order",
-    verb: "refund",
-    docsPath: "orders/issue-refund",
-    body: "optional",
-    destructive: true,
-    idRole: "id"
-  },
-  {
-    resource: "order",
-    verb: "generate-invoice",
-    docsPath: "orders/generate-order-invoice",
-    body: "optional",
-    idRole: "id"
-  },
-  // order-items (read-only)
-  {
-    resource: "order-item",
-    verb: "get",
-    docsPath: "order-items/retrieve-order-item",
-    body: "none",
-    idRole: "id"
-  },
-  {
-    resource: "order-item",
-    verb: "list",
-    docsPath: "order-items/list-all-order-items",
-    body: "none",
-    idRole: "parent"
-  },
-  // subscriptions
-  {
-    resource: "subscription",
-    verb: "get",
-    docsPath: "subscriptions/retrieve-subscription",
-    body: "none",
-    idRole: "id"
-  },
-  {
-    resource: "subscription",
-    verb: "list",
-    docsPath: "subscriptions/list-all-subscriptions",
-    body: "none",
-    idRole: "store"
-  },
-  {
-    resource: "subscription",
-    verb: "update",
-    docsPath: "subscriptions/update-subscription",
-    body: "required",
-    idRole: "id"
-  },
-  {
-    resource: "subscription",
-    verb: "cancel",
-    docsPath: "subscriptions/cancel-subscription",
-    body: "none",
-    destructive: true,
-    idRole: "id"
-  },
-  // subscription-items
-  {
-    resource: "subscription-item",
-    verb: "get",
-    docsPath: "subscription-items/retrieve-subscription-item",
-    body: "none",
-    idRole: "id"
-  },
-  {
-    resource: "subscription-item",
-    verb: "list",
-    docsPath: "subscription-items/list-all-subscription-items",
-    body: "none",
-    idRole: "parent"
-  },
-  {
-    resource: "subscription-item",
-    verb: "update",
-    docsPath: "subscription-items/update-subscription-item",
-    body: "required",
-    idRole: "id"
-  },
-  {
-    resource: "subscription-item",
-    verb: "current-usage",
-    docsPath: "subscription-items/retrieve-subscription-item-current-usage",
-    body: "none",
-    idRole: "id"
-  },
-  // subscription-invoices
-  {
-    resource: "subscription-invoice",
-    verb: "get",
-    docsPath: "subscription-invoices/retrieve-subscription-invoice",
-    body: "none",
-    idRole: "id"
-  },
-  {
-    resource: "subscription-invoice",
-    verb: "list",
-    docsPath: "subscription-invoices/list-all-subscription-invoices",
-    body: "none",
-    idRole: "parent"
-  },
-  {
-    resource: "subscription-invoice",
-    verb: "refund",
-    docsPath: "subscription-invoices/issue-refund",
-    body: "optional",
-    destructive: true,
-    idRole: "id"
-  },
-  {
-    resource: "subscription-invoice",
-    verb: "generate-invoice",
-    docsPath: "subscription-invoices/generate-subscription-invoice",
+var VERB_RULES = {
+  get: { method: "GET", path: "/{id}", docs: "retrieve-{r}", body: "none" },
+  list: { method: "GET", path: "", docs: "list-all-{r}s", body: "none" },
+  create: { method: "POST", path: "", docs: "create-{r}", body: "required" },
+  update: { method: "PATCH", path: "/{id}", docs: "update-{r}", body: "required" },
+  delete: { method: "DELETE", path: "/{id}", docs: "delete-{r}", body: "none", destructive: true },
+  cancel: { method: "DELETE", path: "/{id}", docs: "cancel-{r}", body: "none", destructive: true },
+  refund: {
+    method: "POST",
+    path: "/{id}/refund",
+    docs: "issue-refund",
     body: "optional",
-    idRole: "id"
-  },
-  // usage-records
-  {
-    resource: "usage-record",
-    verb: "get",
-    docsPath: "usage-records/retrieve-usage-record",
-    body: "none",
-    idRole: "id"
-  },
-  {
-    resource: "usage-record",
-    verb: "list",
-    docsPath: "usage-records/list-all-usage-records",
-    body: "none",
-    idRole: "parent"
-  },
-  {
-    resource: "usage-record",
-    verb: "create",
-    docsPath: "usage-records/create-usage-record",
-    body: "required",
-    idRole: "none"
-  },
-  // discounts
-  {
-    resource: "discount",
-    verb: "get",
-    docsPath: "discounts/retrieve-discount",
-    body: "none",
-    idRole: "id"
-  },
-  {
-    resource: "discount",
-    verb: "list",
-    docsPath: "discounts/list-all-discounts",
-    body: "none",
-    idRole: "store"
-  },
-  {
-    resource: "discount",
-    verb: "create",
-    docsPath: "discounts/create-discount",
-    body: "required",
-    idRole: "none"
-  },
-  {
-    resource: "discount",
-    verb: "delete",
-    docsPath: "discounts/delete-discount",
-    body: "none",
-    destructive: true,
-    idRole: "id"
-  },
-  // discount-redemptions (read-only)
-  {
-    resource: "discount-redemption",
-    verb: "get",
-    docsPath: "discount-redemptions/retrieve-discount-redemption",
-    body: "none",
-    idRole: "id"
-  },
-  {
-    resource: "discount-redemption",
-    verb: "list",
-    docsPath: "discount-redemptions/list-all-discount-redemptions",
-    body: "none",
-    idRole: "parent"
-  },
-  // license-keys
-  {
-    resource: "license-key",
-    verb: "get",
-    docsPath: "license-keys/retrieve-license-key",
-    body: "none",
-    idRole: "id"
+    destructive: true
   },
-  {
-    resource: "license-key",
-    verb: "list",
-    docsPath: "license-keys/list-all-license-keys",
-    body: "none",
-    idRole: "store"
-  },
-  {
-    resource: "license-key",
-    verb: "update",
-    docsPath: "license-keys/update-license-key",
-    body: "required",
-    idRole: "id"
-  },
-  // license-key-instances (read-only)
-  {
-    resource: "license-key-instance",
-    verb: "get",
-    docsPath: "license-key-instances/retrieve-license-key-instance",
-    body: "none",
-    idRole: "id"
-  },
-  {
-    resource: "license-key-instance",
-    verb: "list",
-    docsPath: "license-key-instances/list-all-license-key-instances",
-    body: "none",
-    idRole: "parent"
-  },
-  // checkouts
-  {
-    resource: "checkout",
-    verb: "get",
-    docsPath: "checkouts/retrieve-checkout",
-    body: "none",
-    idRole: "id"
-  },
-  {
-    resource: "checkout",
-    verb: "list",
-    docsPath: "checkouts/list-all-checkouts",
-    body: "none",
-    idRole: "store"
-  },
-  {
-    resource: "checkout",
-    verb: "create",
-    docsPath: "checkouts/create-checkout",
-    body: "required",
-    idRole: "none"
-  },
-  // webhooks
-  {
-    resource: "webhook",
-    verb: "get",
-    docsPath: "webhooks/retrieve-webhook",
-    body: "none",
-    idRole: "id"
-  },
-  {
-    resource: "webhook",
-    verb: "list",
-    docsPath: "webhooks/list-all-webhooks",
-    body: "none",
-    idRole: "store"
-  },
-  {
-    resource: "webhook",
-    verb: "create",
-    docsPath: "webhooks/create-webhook",
-    body: "required",
-    idRole: "none"
-  },
-  {
-    resource: "webhook",
-    verb: "update",
-    docsPath: "webhooks/update-webhook",
-    body: "required",
-    idRole: "id"
-  },
-  {
-    resource: "webhook",
-    verb: "delete",
-    docsPath: "webhooks/delete-webhook",
-    body: "none",
-    destructive: true,
-    idRole: "id"
-  },
-  // affiliates (read-only)
-  {
-    resource: "affiliate",
-    verb: "get",
-    docsPath: "affiliates/retrieve-affiliate",
-    body: "none",
-    idRole: "id"
+  "generate-invoice": {
+    method: "POST",
+    path: "/{id}/generate-invoice",
+    docs: "generate-{r}-invoice",
+    body: "optional"
   },
-  {
-    resource: "affiliate",
-    verb: "list",
-    docsPath: "affiliates/list-all-affiliates",
-    body: "none",
-    idRole: "store"
-  }
+  "current-usage": {
+    method: "GET",
+    path: "/{id}/current-usage",
+    docs: "retrieve-{r}-current-usage",
+    body: "none"
+  }
+};
+var RESOURCES = [
+  ["user", ["get"]],
+  ["store", ["get", "list"]],
+  ["product", ["get", "list"], "store"],
+  ["variant", ["get", "list"], "product"],
+  ["price", ["get", "list"], "variant"],
+  ["file", ["get", "list"], "variant"],
+  ["customer", ["get", "list", "create", "update"], "store"],
+  ["order", ["get", "list", "refund", "generate-invoice"], "store"],
+  ["order-item", ["get", "list"], "order"],
+  ["subscription", ["get", "list", "update", "cancel"], "store"],
+  ["subscription-item", ["get", "list", "update", "current-usage"], "subscription"],
+  ["subscription-invoice", ["get", "list", "refund", "generate-invoice"], "subscription"],
+  ["usage-record", ["get", "list", "create"], "subscription-item"],
+  ["discount", ["get", "list", "create", "delete"], "store"],
+  ["discount-redemption", ["get", "list"], "discount"],
+  ["license-key", ["get", "list", "update"], "store"],
+  ["license-key-instance", ["get", "list"], "license-key"],
+  ["checkout", ["get", "list", "create"], "store"],
+  ["webhook", ["get", "list", "create", "update", "delete"], "store"],
+  ["affiliate", ["get", "list"], "store"]
 ];
-var RESOURCE_ALIASES = {
-  products: "product",
-  stores: "store",
-  customers: "customer",
-  orders: "order",
-  "order-items": "order-item",
-  subscriptions: "subscription",
-  "subscription-items": "subscription-item",
-  "subscription-invoices": "subscription-invoice",
-  "usage-records": "usage-record",
-  discounts: "discount",
-  "discount-redemptions": "discount-redemption",
-  "license-keys": "license-key",
-  "license-key-instances": "license-key-instance",
-  checkouts: "checkout",
-  webhooks: "webhook",
-  affiliates: "affiliate",
-  variants: "variant",
-  prices: "price",
-  files: "file",
-  users: "user"
+var DOCS_PATH_EXCEPTIONS = {
+  "subscription-invoice:generate-invoice": "subscription-invoices/generate-subscription-invoice"
+};
+var USER_ME_PATH = "/v1/users/me";
+var listIdRole = (listScope) => {
+  if (!listScope) return "none";
+  return listScope === "store" ? "store" : "parent";
+};
+var toSpec = (resource, verb, listScope) => {
+  const rule = VERB_RULES[verb];
+  const docsPath = DOCS_PATH_EXCEPTIONS[`${resource}:${verb}`] ?? `${resource}s/${rule.docs.replaceAll("{r}", resource)}`;
+  let idRole = rule.path.includes("{id}") ? "id" : "none";
+  if (verb === "list") idRole = listIdRole(listScope);
+  if (resource === "user") idRole = "none";
+  return {
+    resource,
+    verb,
+    docsPath,
+    body: rule.body,
+    ...rule.destructive ? { destructive: true } : {},
+    idRole
+  };
 };
+var resourceRegistry = RESOURCES.flatMap(
+  ([resource, verbs, listScope]) => verbs.map((verb) => toSpec(resource, verb, listScope))
+);
 var normalizeResourceName = (resource) => {
   const normalized = resource.replace(/_/g, "-").toLowerCase();
-  if (RESOURCE_ALIASES[normalized]) {
-    return RESOURCE_ALIASES[normalized];
-  }
   if (normalized.endsWith("s") && normalized !== "status") {
     return normalized.slice(0, -1);
   }
@@ -1004,271 +466,11 @@ var findResourceVerb = (resource, verb) => {
 var listRegisteredResources = () => {
   return [...new Set(resourceRegistry.map((entry) => entry.resource))].sort();
 };
-
-// src/resources/stores.ts
-var getStore = async (http, storeId) => {
-  return http.getResource(`/v1/stores/${storeId}`);
-};
-var listStores = async (http) => {
-  return http.paginate("/v1/stores");
-};
-
-// src/resources/subscriptionInvoices.ts
-var getSubscriptionInvoice = async (http, subscriptionInvoiceId) => {
-  return http.getResource(
-    `/v1/subscription-invoices/${subscriptionInvoiceId}`
-  );
-};
-var listSubscriptionInvoicesForSubscription = async (http, subscriptionId) => {
-  return http.paginate("/v1/subscription-invoices", {
-    "filter[subscription_id]": String(subscriptionId)
-  });
-};
-var refundSubscriptionInvoice = async (http, subscriptionInvoiceId, body) => {
-  return http.postResource(
-    `/v1/subscription-invoices/${subscriptionInvoiceId}/refund`,
-    body ?? {}
-  );
-};
-var generateSubscriptionInvoice = async (http, subscriptionInvoiceId, body) => {
-  return http.request({
-    method: "POST",
-    path: `/v1/subscription-invoices/${subscriptionInvoiceId}/generate-invoice`,
-    body: body ?? {}
-  });
-};
-
-// src/resources/subscriptionItems.ts
-var getSubscriptionItem = async (http, subscriptionItemId) => {
-  return http.getResource(
-    `/v1/subscription-items/${subscriptionItemId}`
-  );
-};
-var listSubscriptionItemsForSubscription = async (http, subscriptionId) => {
-  return http.paginate("/v1/subscription-items", {
-    "filter[subscription_id]": String(subscriptionId)
-  });
-};
-var updateSubscriptionItem = async (http, subscriptionItemId, body) => {
-  return http.patchResource(
-    `/v1/subscription-items/${subscriptionItemId}`,
-    body
-  );
-};
-var getSubscriptionItemCurrentUsage = async (http, subscriptionItemId) => {
-  return http.request({
-    path: `/v1/subscription-items/${subscriptionItemId}/current-usage`
-  });
-};
-
-// src/resources/subscriptions.ts
-var getSubscription = async (http, subscriptionId) => {
-  return http.getResource(`/v1/subscriptions/${subscriptionId}`);
-};
-var listSubscriptionsForStore = async (http, storeId) => {
-  return http.paginate("/v1/subscriptions", {
-    "filter[store_id]": String(storeId)
-  });
-};
-var updateSubscription = async (http, subscriptionId, body) => {
-  return http.patchResource(`/v1/subscriptions/${subscriptionId}`, body);
-};
-var cancelSubscription = async (http, subscriptionId) => {
-  const doc = await http.request({
-    method: "DELETE",
-    path: `/v1/subscriptions/${subscriptionId}`
-  });
-  return doc?.data;
-};
-
-// src/resources/usageRecords.ts
-var getUsageRecord = async (http, usageRecordId) => {
-  return http.getResource(`/v1/usage-records/${usageRecordId}`);
-};
-var listUsageRecordsForSubscriptionItem = async (http, subscriptionItemId) => {
-  return http.paginate("/v1/usage-records", {
-    "filter[subscription_item_id]": String(subscriptionItemId)
-  });
-};
-var createUsageRecord = async (http, body) => {
-  return http.postResource("/v1/usage-records", body);
-};
-
-// src/resources/users.ts
-var getAuthenticatedUser = async (http) => {
-  return http.request({ path: "/v1/users/me" });
-};
-
-// src/resources/variants.ts
-var getVariant = async (http, variantId) => {
-  return http.getResource(`/v1/variants/${variantId}`);
-};
-var listVariantsForProduct = async (http, productId) => {
-  return http.paginate("/v1/variants", {
-    "filter[product_id]": String(productId)
-  });
-};
-
-// src/resources/webhooks.ts
-var getWebhook = async (http, webhookId) => {
-  return http.getResource(`/v1/webhooks/${webhookId}`);
-};
-var listWebhooksForStore = async (http, storeId) => {
-  return http.paginate("/v1/webhooks", {
-    "filter[store_id]": String(storeId)
-  });
-};
-var createWebhook = async (http, body) => {
-  return http.postResource("/v1/webhooks", body);
-};
-var updateWebhook = async (http, webhookId, body) => {
-  return http.patchResource(`/v1/webhooks/${webhookId}`, body);
-};
-var deleteWebhook = async (http, webhookId) => {
-  await http.deleteResource(`/v1/webhooks/${webhookId}`);
-};
-
-// src/resources/invokeOp.ts
-var invokeOp = async (http, resource, verb, args = {}) => {
-  const spec = findResourceVerb(resource, verb);
-  if (!spec) {
-    throw new FreshSqueezyError({
-      code: "UNKNOWN_OP",
-      message: `Unknown or unsupported op: ${verb} ${resource}. Run \`fresh-squeezy ops --list\`.`
-    });
-  }
-  const key = `${spec.resource}:${spec.verb}`;
-  switch (key) {
-    case "user:get": {
-      const doc = await getAuthenticatedUser(http);
-      return doc.data;
-    }
-    case "store:get":
-      return getStore(http, requireId(args, "store"));
-    case "store:list":
-      return listStores(http);
-    case "product:get":
-      return getProduct(http, requireId(args, "product"));
-    case "product:list":
-      return listProducts(http, requireStore(args));
-    case "variant:get":
-      return getVariant(http, requireId(args, "variant"));
-    case "variant:list":
-      return listVariantsForProduct(http, requireParent(args, "product"));
-    case "price:get":
-      return getPrice(http, requireId(args, "price"));
-    case "price:list":
-      return listPricesForVariant(http, requireParent(args, "variant"));
-    case "file:get":
-      return getFile(http, requireId(args, "file"));
-    case "file:list":
-      return listFilesForVariant(http, requireParent(args, "variant"));
-    case "customer:get":
-      return getCustomer(http, requireId(args, "customer"));
-    case "customer:list":
-      return listCustomersForStore(http, requireStore(args));
-    case "customer:create":
-      return createCustomer(http, requireBody(args));
-    case "customer:update":
-      return updateCustomer(http, requireId(args, "customer"), requireBody(args));
-    case "order:get":
-      return getOrder(http, requireId(args, "order"));
-    case "order:list":
-      return listOrdersForStore(http, requireStore(args));
-    case "order:refund":
-      return refundOrder(http, requireId(args, "order"), args.body);
-    case "order:generate-invoice":
-      return generateOrderInvoice(http, requireId(args, "order"), args.body);
-    case "order-item:get":
-      return getOrderItem(http, requireId(args, "order-item"));
-    case "order-item:list":
-      return listOrderItemsForOrder(http, requireParent(args, "order"));
-    case "subscription:get":
-      return getSubscription(http, requireId(args, "subscription"));
-    case "subscription:list":
-      return listSubscriptionsForStore(http, requireStore(args));
-    case "subscription:update":
-      return updateSubscription(http, requireId(args, "subscription"), requireBody(args));
-    case "subscription:cancel":
-      return cancelSubscription(http, requireId(args, "subscription"));
-    case "subscription-item:get":
-      return getSubscriptionItem(http, requireId(args, "subscription-item"));
-    case "subscription-item:list":
-      return listSubscriptionItemsForSubscription(http, requireParent(args, "subscription"));
-    case "subscription-item:update":
-      return updateSubscriptionItem(http, requireId(args, "subscription-item"), requireBody(args));
-    case "subscription-item:current-usage":
-      return getSubscriptionItemCurrentUsage(http, requireId(args, "subscription-item"));
-    case "subscription-invoice:get":
-      return getSubscriptionInvoice(http, requireId(args, "subscription-invoice"));
-    case "subscription-invoice:list":
-      return listSubscriptionInvoicesForSubscription(http, requireParent(args, "subscription"));
-    case "subscription-invoice:refund":
-      return refundSubscriptionInvoice(http, requireId(args, "subscription-invoice"), args.body);
-    case "subscription-invoice:generate-invoice":
-      return generateSubscriptionInvoice(http, requireId(args, "subscription-invoice"), args.body);
-    case "usage-record:get":
-      return getUsageRecord(http, requireId(args, "usage-record"));
-    case "usage-record:list":
-      return listUsageRecordsForSubscriptionItem(http, requireParent(args, "subscription-item"));
-    case "usage-record:create":
-      return createUsageRecord(http, requireBody(args));
-    case "discount:get":
-      return getDiscount(http, requireId(args, "discount"));
-    case "discount:list":
-      return listDiscountsForStore(http, requireStore(args));
-    case "discount:create":
-      return createDiscount(http, requireBody(args));
-    case "discount:delete":
-      await deleteDiscount(http, requireId(args, "discount"));
-      return void 0;
-    case "discount-redemption:get":
-      return getDiscountRedemption(http, requireId(args, "discount-redemption"));
-    case "discount-redemption:list":
-      return listDiscountRedemptionsForDiscount(http, requireParent(args, "discount"));
-    case "license-key:get":
-      return getLicenseKey(http, requireId(args, "license-key"));
-    case "license-key:list":
-      return listLicenseKeysForStore(http, requireStore(args));
-    case "license-key:update":
-      return updateLicenseKey(http, requireId(args, "license-key"), requireBody(args));
-    case "license-key-instance:get":
-      return getLicenseKeyInstance(http, requireId(args, "license-key-instance"));
-    case "license-key-instance:list":
-      return listLicenseKeyInstancesForLicenseKey(http, requireParent(args, "license-key"));
-    case "checkout:get":
-      return getCheckout(http, requireId(args, "checkout"));
-    case "checkout:list":
-      return listCheckoutsForStore(http, requireStore(args));
-    case "checkout:create":
-      return createCheckout(http, requireBody(args));
-    case "webhook:get":
-      return getWebhook(http, requireId(args, "webhook"));
-    case "webhook:list":
-      return listWebhooksForStore(http, requireStore(args));
-    case "webhook:create":
-      return createWebhook(http, requireBody(args));
-    case "webhook:update":
-      return updateWebhook(http, requireId(args, "webhook"), requireBody(args));
-    case "webhook:delete":
-      await deleteWebhook(http, requireId(args, "webhook"));
-      return void 0;
-    case "affiliate:get":
-      return getAffiliate(http, requireId(args, "affiliate"));
-    case "affiliate:list":
-      return listAffiliatesForStore(http, requireStore(args));
-    default:
-      throw new FreshSqueezyError({
-        code: "UNKNOWN_OP",
-        message: `Op registered but not wired: ${key}`
-      });
-  }
-};
-var requireId = (args, label) => {
+var requireId = (args, spec) => {
   if (args.id === void 0 || args.id === "") {
     throw new FreshSqueezyError({
       code: "MISSING_ARG",
-      message: `--id is required for this ${label} operation.`
+      message: `--id is required for this ${spec.resource} operation.`
     });
   }
   return args.id;
@@ -1282,11 +484,11 @@ var requireStore = (args) => {
   }
   return args.storeId;
 };
-var requireParent = (args, label) => {
+var requireParent = (args, parent) => {
   if (args.parentId === void 0 || args.parentId === "") {
     throw new FreshSqueezyError({
       code: "MISSING_ARG",
-      message: `--parent-id (${label} id) is required for this list operation.`
+      message: `--parent-id (${parent} id) is required for this list operation.`
     });
   }
   return args.parentId;
@@ -1300,15 +502,44 @@ var requireBody = (args) => {
   }
   return args.body;
 };
-
-// src/core/mode.ts
-var resolveActualMode = (testMode) => {
-  if (testMode === true) return "test";
-  if (testMode === false) return "live";
+var listFilter = (spec, args) => {
+  const listScope = RESOURCES.find(([resource]) => resource === spec.resource)?.[2];
+  if (!listScope) return void 0;
+  const scopeId = listScope === "store" ? requireStore(args) : requireParent(args, listScope);
+  return { [`filter[${listScope.replace(/-/g, "_")}_id]`]: String(scopeId) };
+};
+var requestBody = (rule, args) => {
+  if (rule.body === "required") return requireBody(args);
+  if (rule.body === "optional") return args.body ?? {};
   return void 0;
 };
+var invokeOp = async (http, resource, verb, args = {}) => {
+  const spec = findResourceVerb(resource, verb);
+  if (!spec) {
+    throw new FreshSqueezyError({
+      code: "UNKNOWN_OP",
+      message: `Unknown or unsupported op: ${verb} ${resource}. Run \`fresh-squeezy ops --list\`.`
+    });
+  }
+  if (spec.resource === "user") {
+    const doc2 = await http.request({ path: USER_ME_PATH });
+    return doc2.data;
+  }
+  const collectionPath = `/v1/${spec.resource}s`;
+  if (spec.verb === "list") {
+    return http.paginate(collectionPath, listFilter(spec, args));
+  }
+  const rule = VERB_RULES[spec.verb];
+  const path4 = collectionPath + rule.path.replace("{id}", () => String(requireId(args, spec)));
+  const doc = await http.request({
+    method: rule.method,
+    path: path4,
+    body: requestBody(rule, args)
+  });
+  return doc?.data ?? doc;
+};
 
-// src/validate/rules.ts
+// src/validate/issues.ts
 var ISSUE_CODES = {
   AUTH_FAILED: "AUTH_FAILED",
   MODE_MISMATCH: "MODE_MISMATCH",
@@ -1432,11 +663,19 @@ var checkStoreOwnership = (check) => {
 };
 
 // src/validate/connection.ts
+var resolveActualMode = (testMode) => {
+  if (testMode === true) return "test";
+  if (testMode === false) return "live";
+  return void 0;
+};
+var fetchUserDocument = (http) => {
+  return http.request({ path: "/v1/users/me" });
+};
 var validateConnection = async (http, mode) => {
   const fetched = await probeCollection(
     async () => {
-      const userDoc2 = await getAuthenticatedUser(http);
-      const stores2 = await listStores(http);
+      const userDoc2 = await fetchUserDocument(http);
+      const stores2 = await http.paginate("/v1/stores");
       return { userDoc: userDoc2, stores: stores2 };
     },
     {
@@ -1492,12 +731,15 @@ var validateDiscount = async (http, mode, options) => {
     label: `discount ${options.discountId}`,
     id: String(options.discountId)
   };
-  const fetched = await probeFetch(() => getDiscount(http, options.discountId), {
-    notFoundCode: ISSUE_CODES.DISCOUNT_NOT_FOUND,
-    notFoundMessage: `Discount ${options.discountId} not found.`,
-    notFoundFix: "Verify the discount ID in the Lemon Squeezy dashboard.",
-    notFoundContext: { discountId: String(options.discountId) }
-  });
+  const fetched = await probeFetch(
+    () => http.getResource(`/v1/discounts/${options.discountId}`),
+    {
+      notFoundCode: ISSUE_CODES.DISCOUNT_NOT_FOUND,
+      notFoundMessage: `Discount ${options.discountId} not found.`,
+      notFoundFix: "Verify the discount ID in the Lemon Squeezy dashboard.",
+      notFoundContext: { discountId: String(options.discountId) }
+    }
+  );
   if (!fetched.ok) {
     return buildResult("discount", mode, [fetched.issue], void 0, target);
   }
@@ -1604,12 +846,15 @@ var validateLicenseKey = async (http, mode, options) => {
     label: `license key ${options.licenseKeyId}`,
     id: String(options.licenseKeyId)
   };
-  const fetched = await probeFetch(() => getLicenseKey(http, options.licenseKeyId), {
-    notFoundCode: ISSUE_CODES.LICENSE_KEY_NOT_FOUND,
-    notFoundMessage: `License key ${options.licenseKeyId} not found.`,
-    notFoundFix: "Verify the license key ID in the Lemon Squeezy dashboard.",
-    notFoundContext: { licenseKeyId: String(options.licenseKeyId) }
-  });
+  const fetched = await probeFetch(
+    () => http.getResource(`/v1/license-keys/${options.licenseKeyId}`),
+    {
+      notFoundCode: ISSUE_CODES.LICENSE_KEY_NOT_FOUND,
+      notFoundMessage: `License key ${options.licenseKeyId} not found.`,
+      notFoundFix: "Verify the license key ID in the Lemon Squeezy dashboard.",
+      notFoundContext: { licenseKeyId: String(options.licenseKeyId) }
+    }
+  );
   if (!fetched.ok) {
     return buildResult(
       "licenseKey",
@@ -1691,19 +936,24 @@ var validateProduct = async (http, mode, options) => {
     label: `product ${options.productId}`,
     id: String(options.productId)
   };
-  const fetched = await probeFetch(() => getProduct(http, options.productId), {
-    notFoundCode: ISSUE_CODES.PRODUCT_NOT_FOUND,
-    notFoundMessage: `Product ${options.productId} not found.`,
-    notFoundFix: "Verify the product ID in the Lemon Squeezy dashboard.",
-    notFoundContext: { productId: String(options.productId) }
-  });
+  const fetched = await probeFetch(
+    () => http.getResource(`/v1/products/${options.productId}`),
+    {
+      notFoundCode: ISSUE_CODES.PRODUCT_NOT_FOUND,
+      notFoundMessage: `Product ${options.productId} not found.`,
+      notFoundFix: "Verify the product ID in the Lemon Squeezy dashboard.",
+      notFoundContext: { productId: String(options.productId) }
+    }
+  );
   if (!fetched.ok) {
     return buildResult("product", mode, [fetched.issue], void 0, target);
   }
   const attrs = fetched.resource.attributes;
   issues.push(...checkProduct(attrs, { expectedStoreId: options.expectedStoreId }));
   const variantsProbed = await probeCollection(
-    () => listVariantsForProduct(http, options.productId)
+    () => http.paginate("/v1/variants", {
+      "filter[product_id]": String(options.productId)
+    })
   );
   if (!variantsProbed.ok) {
     issues.push({ ...variantsProbed.issue, severity: "warning" });
@@ -1772,12 +1022,15 @@ var checkProduct = (attrs, options = {}) => {
 // src/validate/store.ts
 var validateStore = async (http, mode, storeId) => {
   const target = { label: `store ${storeId}`, id: String(storeId) };
-  const fetched = await probeFetch(() => getStore(http, storeId), {
-    notFoundCode: ISSUE_CODES.STORE_NOT_FOUND,
-    notFoundMessage: `Store ${storeId} not found with the current API key.`,
-    notFoundFix: "Check the store ID and confirm the API key belongs to the account that owns it.",
-    notFoundContext: { storeId: String(storeId) }
-  });
+  const fetched = await probeFetch(
+    () => http.getResource(`/v1/stores/${storeId}`),
+    {
+      notFoundCode: ISSUE_CODES.STORE_NOT_FOUND,
+      notFoundMessage: `Store ${storeId} not found with the current API key.`,
+      notFoundFix: "Check the store ID and confirm the API key belongs to the account that owns it.",
+      notFoundContext: { storeId: String(storeId) }
+    }
+  );
   if (!fetched.ok) {
     return buildResult("store", mode, [fetched.issue], void 0, target);
   }
@@ -1795,7 +1048,7 @@ var validateSubscriptionPlan = async (http, mode, options) => {
     id: String(options.variantId)
   };
   const fetched = await probeFetch(
-    () => getVariant(http, options.variantId),
+    () => http.getResource(`/v1/variants/${options.variantId}`),
     {
       notFoundCode: ISSUE_CODES.PLAN_VARIANT_NOT_FOUND,
       notFoundMessage: `Variant ${options.variantId} not found.`,
@@ -1815,10 +1068,13 @@ var validateSubscriptionPlan = async (http, mode, options) => {
   const variant = fetched.resource;
   const attrs = variant.attributes;
   const issues = checkSubscriptionPlan(attrs, { variantId: options.variantId });
-  const productProbed = await probeFetch(() => getProduct(http, attrs.product_id), {
-    notFoundCode: ISSUE_CODES.PRODUCT_NOT_FOUND,
-    notFoundMessage: `Product ${attrs.product_id} not found.`
-  });
+  const productProbed = await probeFetch(
+    () => http.getResource(`/v1/products/${attrs.product_id}`),
+    {
+      notFoundCode: ISSUE_CODES.PRODUCT_NOT_FOUND,
+      notFoundMessage: `Product ${attrs.product_id} not found.`
+    }
+  );
   if (productProbed.ok) {
     const mismatch = checkStoreOwnership({
       expectedStoreId: options.storeId,
@@ -1929,14 +1185,6 @@ var checkSubscriptionPlan = (attrs, options) => {
   return issues;
 };
 
-// src/core/equality.ts
-var sameWebhookUrl = (a, b) => {
-  return normalizeWebhookUrl(a) === normalizeWebhookUrl(b);
-};
-var normalizeWebhookUrl = (raw) => {
-  return raw.replace(/\/+$/, "").toLowerCase();
-};
-
 // src/support/manifest.ts
 var RECOMMENDED_WEBHOOK_EVENTS = [
   "order_created",
@@ -1957,9 +1205,19 @@ var OPTIONAL_WEBHOOK_EVENTS = [
 ];
 
 // src/validate/webhook.ts
+var sameWebhookUrl = (a, b) => {
+  return normalizeWebhookUrl(a) === normalizeWebhookUrl(b);
+};
+var normalizeWebhookUrl = (raw) => {
+  return raw.replace(/\/+$/, "").toLowerCase();
+};
 var validateWebhook = async (http, mode, options) => {
   const target = { label: options.url, url: options.url };
-  const fetched = await probeCollection(() => listWebhooksForStore(http, options.storeId));
+  const fetched = await probeCollection(
+    () => http.paginate("/v1/webhooks", {
+      "filter[store_id]": String(options.storeId)
+    })
+  );
   if (!fetched.ok) {
     return buildResult("webhook", mode, [fetched.issue], void 0, target);
   }
@@ -2214,80 +1472,196 @@ var createFreshSqueezy = (config = {}) => {
   };
 };
 
-// src/cli/errors.ts
-var renderCliError = (message, hints = []) => {
-  const lines = [`fresh-squeezy: ${message}`];
-  if (hints.length > 0) {
-    lines.push("", "Try:");
-    for (const hint of hints) {
-      lines.push(`  ${hint}`);
-    }
+// src/cli/optionalValidators.ts
+var errorMessage = (err) => err instanceof Error ? err.message : String(err);
+var listChoices = async (load, toChoice) => {
+  try {
+    const items = await load();
+    return { choices: items.map(toChoice) };
+  } catch (err) {
+    return { choices: [], error: errorMessage(err) };
   }
-  return `${lines.join("\n")}
-`;
 };
-var getDoctorHints = (err) => {
-  if (!isFreshSqueezyError(err)) return [];
-  if (err.code === "MISSING_API_KEY") {
-    return ["fresh-squeezy init", `export ${ENV_KEYS.apiKey}=ls_live_or_test_key`];
-  }
-  if (err.code === "INVALID_MODE") {
-    return ["fresh-squeezy doctor --mode test", "fresh-squeezy doctor --mode live"];
-  }
-  if (err.code === "NO_STORES") {
-    return ["Check that the API key belongs to an account with a Lemon Squeezy store."];
+var discoverSubscriptionPlans = async ({
+  client,
+  listProducts
+}) => {
+  const choices = [];
+  try {
+    for (const product of await listProducts()) {
+      const variants = await client.variants.list(
+        product.id
+      );
+      for (const variant of variants) {
+        if (!variant.attributes.is_subscription) continue;
+        const { name, interval, interval_count } = variant.attributes;
+        const cadence = interval ? `${interval_count ?? 1}/${interval}` : "no interval";
+        choices.push({
+          value: variant.id,
+          label: `${product.attributes.name} / ${name} (${cadence}) - id ${variant.id}`
+        });
+      }
+    }
+    return { choices };
+  } catch (err) {
+    return { choices, error: errorMessage(err) };
   }
-  return [];
 };
-var getValidateHints = (err, target) => {
-  if (!isFreshSqueezyError(err)) return [];
-  if (err.code === "MISSING_API_KEY") {
-    return ["fresh-squeezy init", `export ${ENV_KEYS.apiKey}=ls_live_or_test_key`];
-  }
-  if (err.code === "INVALID_MODE") {
-    return [
-      `fresh-squeezy validate ${target} --mode test`,
-      `fresh-squeezy validate ${target} --mode live`
-    ];
-  }
-  if (err.code === "MISSING_ARG") {
-    return getMissingArgHints(target);
+var isHttpUrl = (value) => {
+  try {
+    return ["http:", "https:"].includes(new URL(value).protocol);
+  } catch {
+    return false;
   }
-  return [];
 };
-var getMissingArgHints = (target) => {
-  if (target === "connection") {
-    return ["fresh-squeezy validate connection"];
-  }
-  if (target === "store") {
-    return [
-      "fresh-squeezy validate store --store-ids 12",
-      "fresh-squeezy validate store --all-stores"
-    ];
-  }
-  if (target === "product") {
-    return ["fresh-squeezy validate product --product-id 987"];
-  }
-  if (target === "webhook") {
-    return [
-      "fresh-squeezy validate webhook --store-ids 12 --webhook-url https://app.example.com/api/webhooks/lemon-squeezy",
-      "fresh-squeezy validate webhook --all-stores --webhook-url https://app.example.com/api/webhooks/lemon-squeezy"
-    ];
-  }
-  if (target === "discount") {
-    return ["fresh-squeezy validate discount --store-ids 12 --discount-id 123"];
+var validateWebhookUrls = (value) => {
+  const urls = value.split(",").map((entry) => entry.trim()).filter(Boolean);
+  return urls.every(isHttpUrl) ? true : "Enter valid webhook URLs.";
+};
+var OPTIONAL_VALIDATORS = [
+  {
+    name: "product",
+    field: "productIds",
+    resultName: "product",
+    label: "Products",
+    menuLabel: "Product checkout",
+    noun: "products",
+    manualNoun: "Product IDs",
+    discover: ({ listProducts }) => listChoices(listProducts, (product) => ({
+      value: product.id,
+      label: `${product.attributes.name} (${product.attributes.status}) - id ${product.id}`
+    }))
+  },
+  {
+    name: "webhook",
+    field: "webhookUrls",
+    resultName: "webhook",
+    label: "Webhooks",
+    menuLabel: "Webhook registration",
+    noun: "webhook URLs",
+    manualNoun: "Webhook URLs",
+    validate: validateWebhookUrls,
+    discover: ({ client, storeId }) => listChoices(
+      () => client.webhooks.list(storeId),
+      (webhook) => ({
+        value: webhook.attributes.url,
+        label: `${webhook.attributes.url} - id ${webhook.id}`
+      })
+    )
+  },
+  {
+    name: "discount",
+    field: "discountIds",
+    resultName: "discount",
+    label: "Discounts",
+    menuLabel: "Discount code",
+    noun: "discounts",
+    manualNoun: "Discount IDs",
+    discover: ({ client, storeId }) => listChoices(
+      () => client.discounts.list(storeId),
+      (discount) => ({
+        value: discount.id,
+        label: `${discount.attributes.name} (${discount.attributes.code}) - id ${discount.id}`
+      })
+    )
+  },
+  {
+    name: "license-key",
+    field: "licenseKeyIds",
+    resultName: "licenseKey",
+    label: "License keys",
+    menuLabel: "License key",
+    noun: "license keys",
+    manualNoun: "License key IDs",
+    discover: ({ client, storeId }) => listChoices(
+      () => client.licenseKeys.list(storeId),
+      (key) => ({
+        value: key.id,
+        label: `${key.attributes.key_short} (${key.attributes.status}) - id ${key.id}`
+      })
+    )
+  },
+  {
+    name: "subscription-plan",
+    field: "variantIds",
+    resultName: "subscriptionPlan",
+    label: "Subscription plans",
+    menuLabel: "Subscription plan",
+    noun: "subscription plans",
+    manualNoun: "Subscription plan variant IDs",
+    discover: discoverSubscriptionPlans
   }
-  if (target === "license-key") {
-    return ["fresh-squeezy validate license-key --store-ids 12 --license-key-id 123"];
+];
+var discoverChoices = async (client, storeId, names) => {
+  let products;
+  const context = {
+    client,
+    storeId,
+    listProducts: () => {
+      products ??= client.products.list(storeId);
+      return products;
+    }
+  };
+  const choices = {};
+  for (const row of OPTIONAL_VALIDATORS) {
+    if (names.includes(row.name)) choices[row.name] = await row.discover(context);
   }
-  return ["fresh-squeezy validate subscription-plan --store-ids 12 --variant-id 123"];
-};
-var isFreshSqueezyError = (err) => {
-  return err instanceof FreshSqueezyError;
+  return choices;
 };
 
 // src/cli/render.ts
 import chalk from "chalk";
+var MISSING_API_KEY_HINTS = [
+  "fresh-squeezy init",
+  `export ${ENV_KEYS.apiKey}=ls_live_or_test_key`
+];
+var brand = chalk.green.bold("fresh-squeezy");
+var divider = chalk.dim("\u2022");
+var renderBrandHeader = (title, subtitle) => {
+  const lines = [`${brand} ${divider} ${chalk.bold(title)}`];
+  if (subtitle) lines.push(chalk.dim(subtitle));
+  lines.push("");
+  return lines.join("\n");
+};
+var renderStep = (index, total, title, detail) => {
+  const suffix = detail ? ` ${chalk.dim(detail)}` : "";
+  const prefix = index > 1 ? "\n" : "";
+  return `${prefix}${chalk.yellow("\u25CF")} ${chalk.dim(`${index}/${total}`)} ${chalk.bold(title)}${suffix}
+`;
+};
+var renderDetected = (label, value, source) => {
+  const suffix = source ? ` ${chalk.dim(`from ${source}`)}` : "";
+  return `  ${chalk.green("\u2713")} ${chalk.bold(label)} ${value}${suffix}
+`;
+};
+var renderCommandExamples = () => {
+  return [
+    renderBrandHeader("Command examples", "Direct commands stay stable for scripts and CI."),
+    `${chalk.bold("Guided setup")}`,
+    "  fresh-squeezy init",
+    "",
+    `${chalk.bold("Full doctor")}`,
+    "  fresh-squeezy doctor --all-stores",
+    "  fresh-squeezy doctor --store-ids 12 --product-id 987 --webhook-url https://app.example.com/api/webhooks/lemon-squeezy",
+    "",
+    `${chalk.bold("Single checks")}`,
+    "  fresh-squeezy validate connection",
+    "  fresh-squeezy validate webhook --store-ids 12 --webhook-url https://app.example.com/api/webhooks/lemon-squeezy",
+    "",
+    `${chalk.bold("Bulk ops (delete / cancel / refund)")}`,
+    "  fresh-squeezy delete discount --all --store-ids 12 --dry-run",
+    "  fresh-squeezy delete discount --all --store-ids 12 --match TEST --yes",
+    "  fresh-squeezy delete webhook --ids 1,2,3 --yes",
+    "",
+    `${chalk.bold("Automation")}`,
+    "  fresh-squeezy doctor --all-stores --json",
+    ""
+  ].join("\n");
+};
+var renderCancelMessage = () => {
+  return `${chalk.dim("fresh-squeezy cancelled.")}
+`;
+};
 var renderResult = (result) => {
   const lines = [];
   const badge = result.ok ? chalk.green("PASS") : chalk.red("FAIL");
@@ -2324,140 +1698,37 @@ var renderIssueLine = (issue2) => {
   const label = issue2.severity === "error" ? chalk.red("\u2717 error") : issue2.severity === "warning" ? chalk.yellow("! warn ") : chalk.blue("i info ");
   return `${label} ${chalk.gray(`[${issue2.code}]`)} ${issue2.message}`;
 };
-
-// src/cli/prompts.ts
-import path from "path";
-import { checkbox, confirm, input, password, select } from "@inquirer/prompts";
-
-// src/cli/resourceDiscovery.ts
-var EMPTY_INIT_RESOURCE_CHOICES = {
-  products: { choices: [] },
-  webhooks: { choices: [] },
-  discounts: { choices: [] },
-  licenseKeys: { choices: [] },
-  subscriptionPlans: { choices: [] }
-};
-var discoverInitResourceChoices = async (client, storeId, targets) => {
-  const choices = {
-    products: { choices: [] },
-    webhooks: { choices: [] },
-    discounts: { choices: [] },
-    licenseKeys: { choices: [] },
-    subscriptionPlans: { choices: [] }
-  };
-  let products;
-  if (targets.includes("product") || targets.includes("subscription-plan")) {
-    const result = await discover(
-      () => paginate(client, "/v1/products", { "filter[store_id]": storeId })
-    );
-    if (result.ok) {
-      products = result.value;
-      choices.products = { choices: result.value.map(toProductChoice) };
-    } else {
-      choices.products = { choices: [], error: result.error };
-    }
-  }
-  if (targets.includes("webhook")) {
-    const result = await discover(
-      () => paginate(client, "/v1/webhooks", { "filter[store_id]": storeId })
-    );
-    choices.webhooks = result.ok ? { choices: result.value.map(toWebhookChoice) } : { choices: [], error: result.error };
-  }
-  if (targets.includes("discount")) {
-    const result = await discover(
-      () => paginate(client, "/v1/discounts", { "filter[store_id]": storeId })
-    );
-    choices.discounts = result.ok ? { choices: result.value.map(toDiscountChoice) } : { choices: [], error: result.error };
-  }
-  if (targets.includes("license-key")) {
-    const result = await discover(
-      () => paginate(client, "/v1/license-keys", { "filter[store_id]": storeId })
-    );
-    choices.licenseKeys = result.ok ? { choices: result.value.map(toLicenseKeyChoice) } : { choices: [], error: result.error };
-  }
-  if (targets.includes("subscription-plan")) {
-    const listedProducts = products ?? [];
-    if (choices.products.error) {
-      choices.subscriptionPlans = { choices: [], error: choices.products.error };
-    } else {
-      choices.subscriptionPlans = await discoverSubscriptionPlans(client, listedProducts);
+var renderCliError = (message, hints = []) => {
+  const lines = [`fresh-squeezy: ${message}`];
+  if (hints.length > 0) {
+    lines.push("", "Try:");
+    for (const hint of hints) {
+      lines.push(`  ${hint}`);
     }
   }
-  return choices;
+  return `${lines.join("\n")}
+`;
 };
-var discoverSubscriptionPlans = async (client, products) => {
-  const discovered = [];
-  for (const product of products) {
-    const result = await discover(
-      () => paginate(client, "/v1/variants", {
-        "filter[product_id]": product.id
-      })
-    );
-    if (!result.ok) {
-      return { choices: discovered, error: result.error };
-    }
-    for (const variant of result.value) {
-      if (variant.attributes.is_subscription) {
-        discovered.push(toSubscriptionPlanChoice(variant, product.attributes.name));
-      }
-    }
-  }
-  return { choices: discovered };
+var isFreshSqueezyError = (err) => {
+  return err instanceof FreshSqueezyError;
 };
-var paginate = async (client, path4, query) => {
-  const all = [];
-  let pageNumber = Number(query?.["page[number]"] ?? 1);
-  while (true) {
-    const doc = await client.request({
-      path: path4,
-      query: { ...query ?? {}, "page[number]": pageNumber }
-    });
-    all.push(...doc.data);
-    const lastPage = doc.meta?.page?.lastPage;
-    if (lastPage === void 0 || pageNumber >= lastPage) return all;
-    pageNumber += 1;
+var getDoctorHints = (err) => {
+  if (!isFreshSqueezyError(err)) return [];
+  if (err.code === "MISSING_API_KEY") {
+    return MISSING_API_KEY_HINTS;
   }
-};
-var discover = async (load) => {
-  try {
-    return { ok: true, value: await load() };
-  } catch (err) {
-    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  if (err.code === "INVALID_MODE") {
+    return ["fresh-squeezy doctor --mode test", "fresh-squeezy doctor --mode live"];
   }
-};
-var toProductChoice = (product) => {
-  return {
-    value: product.id,
-    label: `${product.attributes.name} (${product.attributes.status}) - id ${product.id}`
-  };
-};
-var toWebhookChoice = (webhook) => {
-  return {
-    value: webhook.attributes.url,
-    label: `${webhook.attributes.url} - id ${webhook.id}`
-  };
-};
-var toDiscountChoice = (discount) => {
-  return {
-    value: discount.id,
-    label: `${discount.attributes.name} (${discount.attributes.code}) - id ${discount.id}`
-  };
-};
-var toLicenseKeyChoice = (licenseKey) => {
-  return {
-    value: licenseKey.id,
-    label: `${licenseKey.attributes.key_short} (${licenseKey.attributes.status}) - id ${licenseKey.id}`
-  };
-};
-var toSubscriptionPlanChoice = (variant, productName) => {
-  const interval = variant.attributes.interval ? `${variant.attributes.interval_count ?? 1}/${variant.attributes.interval}` : "no interval";
-  return {
-    value: variant.id,
-    label: `${productName} / ${variant.attributes.name} (${interval}) - id ${variant.id}`
-  };
+  if (err.code === "NO_STORES") {
+    return ["Check that the API key belongs to an account with a Lemon Squeezy store."];
+  }
+  return [];
 };
 
 // src/cli/prompts.ts
+import path from "path";
+import { checkbox, confirm, input, password, select } from "@inquirer/prompts";
 var PROMPT_THEME = {
   prefix: {
     idle: "\u203A",
@@ -2523,128 +1794,60 @@ var pickStores = async (choices) => {
     validate: (selected) => selected.length > 0 ? true : "Pick at least one store."
   });
 };
-var selectDoctorTargets = async () => {
+var selectOptionalValidators = async () => {
   return checkbox({
     message: "Add resource checks to this doctor run?",
     theme: PROMPT_THEME,
-    choices: [
-      { name: "Product checkout", value: "product" },
-      { name: "Webhook registration", value: "webhook" },
-      { name: "Discount code", value: "discount" },
-      { name: "License key", value: "license-key" },
-      { name: "Subscription plan", value: "subscription-plan" }
-    ]
+    choices: OPTIONAL_VALIDATORS.map((row) => ({ name: row.menuLabel, value: row.name }))
   });
 };
 var splitManualValues = (value) => (value ?? "").split(",").map((entry) => entry.trim()).filter(Boolean);
-var required = (label) => {
-  return (value) => value.trim().length > 0 ? true : `${label} is required.`;
-};
-var optional = (label) => {
-  return (value) => {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) return true;
-    return required(label)(trimmed);
-  };
-};
-var validateWebhookUrl = (value) => {
-  const trimmed = value.trim();
-  if (trimmed.length === 0) return "Webhook URL is required.";
-  try {
-    const url = new URL(trimmed);
-    return url.protocol === "http:" || url.protocol === "https:" ? true : "Webhook URL must start with http:// or https://.";
-  } catch {
-    return "Enter a valid webhook URL.";
-  }
-};
-var optionalWebhookUrls = (value) => {
-  const values2 = splitManualValues(value);
-  if (values2.length === 0) return true;
-  return values2.every((entry) => validateWebhookUrl(entry) === true) ? true : "Enter valid webhook URLs.";
-};
 var cleanList = (value) => {
   const values2 = Array.isArray(value) ? value : splitManualValues(value);
   const cleaned = Array.from(new Set(values2.map((entry) => entry.trim()).filter(Boolean)));
   return cleaned.length > 0 ? cleaned : void 0;
 };
-var DOCTOR_TARGET_SPECS = [
-  {
-    target: "product",
-    field: "productIds",
-    group: "products",
-    pickMessage: "Pick products to validate:",
-    emptyMessage: "No products selected. What now?",
-    manualMessage: "Product IDs to validate (comma-separated, leave empty to skip):",
-    validate: optional("Product ID")
-  },
-  {
-    target: "webhook",
-    field: "webhookUrls",
-    group: "webhooks",
-    pickMessage: "Pick webhook URLs to validate:",
-    emptyMessage: "No webhook URLs selected. What now?",
-    manualMessage: "Webhook URLs to validate (comma-separated, leave empty to skip):",
-    validate: optionalWebhookUrls
-  },
-  {
-    target: "discount",
-    field: "discountIds",
-    group: "discounts",
-    pickMessage: "Pick discounts to validate:",
-    emptyMessage: "No discounts selected. What now?",
-    manualMessage: "Discount IDs to validate (comma-separated, leave empty to skip):",
-    validate: optional("Discount ID")
-  },
-  {
-    target: "license-key",
-    field: "licenseKeyIds",
-    group: "licenseKeys",
-    pickMessage: "Pick license keys to validate:",
-    emptyMessage: "No license keys selected. What now?",
-    manualMessage: "License key IDs to validate (comma-separated, leave empty to skip):",
-    validate: optional("License key ID")
-  },
-  {
-    target: "subscription-plan",
-    field: "variantIds",
-    group: "subscriptionPlans",
-    pickMessage: "Pick subscription plans to validate:",
-    emptyMessage: "No subscription plans selected. What now?",
-    manualMessage: "Subscription plan variant IDs to validate (comma-separated, leave empty to skip):",
-    validate: optional("Variant ID")
-  }
-];
-var askForDoctorTargetValues = async (targets, choices = EMPTY_INIT_RESOURCE_CHOICES) => {
-  if (targets.length === 0) return {};
+var pickDiscoveredIds = async (row, group) => {
+  const discovered = group?.choices ?? [];
+  if (discovered.length === 0) return "manual";
+  const values2 = await checkbox({
+    message: `Pick ${row.noun} to validate:`,
+    theme: PROMPT_THEME,
+    choices: discovered.map((choice) => ({ name: choice.label, value: choice.value }))
+  });
+  if (values2.length > 0) return values2;
+  return askEmptyTargetAction(`No ${row.noun} selected. What now?`);
+};
+var askEmptyTargetAction = async (message) => {
+  return select({
+    message,
+    theme: PROMPT_THEME,
+    choices: [
+      { name: "Enter manually", value: "manual" },
+      { name: "Skip this check", value: "skip" }
+    ]
+  });
+};
+var askForValidatorIds = async (names, choices = {}) => {
+  if (names.length === 0) return {};
   const answers = {};
-  const manualQuestions = [];
-  for (const spec of DOCTOR_TARGET_SPECS) {
-    if (!targets.includes(spec.target)) continue;
-    await resolveTargetValue({
-      answers,
-      manualQuestions,
-      group: choices[spec.group],
-      field: spec.field,
-      pickMessage: spec.pickMessage,
-      emptyMessage: spec.emptyMessage,
-      manualMessage: spec.manualMessage,
-      validate: spec.validate
-    });
-  }
-  for (const question of manualQuestions) {
-    answers[question.field] = await input({
-      message: question.message,
+  const manualRows = [];
+  for (const row of OPTIONAL_VALIDATORS) {
+    if (!names.includes(row.name)) continue;
+    const picked = await pickDiscoveredIds(row, choices[row.name]);
+    if (picked === "manual") manualRows.push(row);
+    else if (picked !== "skip") answers[row.field] = picked;
+  }
+  for (const row of manualRows) {
+    answers[row.field] = await input({
+      message: `${row.manualNoun} to validate (comma-separated, leave empty to skip):`,
       theme: PROMPT_THEME,
-      validate: question.validate
+      validate: row.validate
     });
   }
-  return {
-    productIds: cleanList(answers.productIds),
-    webhookUrls: cleanList(answers.webhookUrls),
-    discountIds: cleanList(answers.discountIds),
-    licenseKeyIds: cleanList(answers.licenseKeyIds),
-    variantIds: cleanList(answers.variantIds)
-  };
+  const targetValues = {};
+  for (const row of OPTIONAL_VALIDATORS) targetValues[row.field] = cleanList(answers[row.field]);
+  return targetValues;
 };
 var confirmLiveModeRun = async () => {
   return confirm({
@@ -2667,46 +1870,6 @@ var confirmResourceOp = async (message) => {
     theme: PROMPT_THEME
   });
 };
-var resolveTargetValue = async (input2) => {
-  if (input2.group.choices.length === 0) {
-    input2.manualQuestions.push({
-      field: input2.field,
-      message: input2.manualMessage,
-      validate: input2.validate
-    });
-    return;
-  }
-  const values2 = await checkbox({
-    message: input2.pickMessage,
-    theme: PROMPT_THEME,
-    choices: input2.group.choices.map((choice) => ({
-      name: choice.label,
-      value: choice.value
-    }))
-  });
-  if (values2.length > 0) {
-    input2.answers[input2.field] = values2;
-    return;
-  }
-  const action = await askEmptyTargetAction(input2.emptyMessage);
-  if (action === "manual") {
-    input2.manualQuestions.push({
-      field: input2.field,
-      message: input2.manualMessage,
-      validate: input2.validate
-    });
-  }
-};
-var askEmptyTargetAction = async (message) => {
-  return select({
-    message,
-    theme: PROMPT_THEME,
-    choices: [
-      { name: "Enter manually", value: "manual" },
-      { name: "Skip this check", value: "skip" }
-    ]
-  });
-};
 var formatPromptPath = (filePath) => {
   const relative = path.relative(process.cwd(), filePath);
   if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) return relative;
@@ -2714,7 +1877,7 @@ var formatPromptPath = (filePath) => {
 };
 var isPromptCancel = (error) => {
   if (!(error instanceof Error)) return false;
-  return error.name === "ExitPromptError" || error.message.includes("User force closed");
+  return error.name === "ExitPromptError";
 };
 var pickManageOperation = async (ops) => {
   return select({
@@ -2741,6 +1904,14 @@ var pickBulkTargets = async (verb, items) => {
 };
 
 // src/cli/resolveStores.ts
+var listStoreChoices = async (client) => {
+  const stores = await client.stores.list();
+  return stores.map((store) => ({
+    id: store.id,
+    name: store.attributes.name,
+    slug: store.attributes.slug
+  }));
+};
 var resolveStores = async (client, input2) => {
   if (input2.storeIds && input2.storeIds.length > 0) {
     return { storeIds: dedupe(input2.storeIds), skipped: false };
@@ -2768,17 +1939,7 @@ var resolveStores = async (client, input2) => {
   if (ids.length === 1) {
     return { storeIds: ids, skipped: false };
   }
-  const detailed = await Promise.all(
-    ids.map(async (id) => {
-      const result = await client.validateStore(id);
-      return {
-        id,
-        name: result.resource?.name ?? "(unnamed)",
-        slug: result.resource?.slug ?? ""
-      };
-    })
-  );
-  const picked = await pickStores(detailed);
+  const picked = await pickStores(await listStoreChoices(client));
   if (picked.length === 0) {
     throw new FreshSqueezyError({
       code: "NO_SELECTION",
@@ -2805,13 +1966,6 @@ var dedupe = (values2) => {
 };
 
 // src/cli/commands/doctor.ts
-var ALL_RESOURCE_TARGETS = [
-  "product",
-  "webhook",
-  "discount",
-  "license-key",
-  "subscription-plan"
-];
 var runDoctorCommand = async (options) => {
   try {
     const client = createFreshSqueezy({ mode: options.mode });
@@ -2825,8 +1979,8 @@ var runDoctorCommand = async (options) => {
     }
     const reports = await Promise.all(
       resolved.storeIds.map(async (storeId) => {
-        const targets = await resolveDoctorTargets(client, storeId, options);
-        return client.doctor({ storeId, ...targets });
+        const validatorIds = await resolveValidatorIds(client, storeId, options);
+        return client.doctor({ storeId, ...validatorIds });
       })
     );
     const ok = reports.every((report) => report.ok);
@@ -2852,55 +2006,47 @@ var runDoctorCommand = async (options) => {
     return 2;
   }
 };
-var resolveDoctorTargets = async (client, storeId, options) => {
-  const explicit = {
-    productIds: one(options.productId),
-    webhookUrls: one(options.webhookUrl),
-    discountIds: one(options.discountId),
-    licenseKeyIds: one(options.licenseKeyId),
-    variantIds: one(options.variantId)
-  };
+var one = (value) => value ? [value] : void 0;
+var explicitValidatorIds = (options) => ({
+  productIds: one(options.productId),
+  webhookUrls: one(options.webhookUrl),
+  discountIds: one(options.discountId),
+  licenseKeyIds: one(options.licenseKeyId),
+  variantIds: one(options.variantId)
+});
+var values = (group) => group?.choices.length ? group.choices.map((choice) => choice.value) : void 0;
+var mergeValues = (explicit, discovered) => {
+  const merged = Array.from(/* @__PURE__ */ new Set([...explicit ?? [], ...discovered ?? []]));
+  return merged.length > 0 ? merged : void 0;
+};
+var resolveValidatorIds = async (client, storeId, options) => {
+  const explicit = explicitValidatorIds(options);
   if (!options.allResources) return explicit;
-  const discovered = await discoverInitResourceChoices(client, storeId, ALL_RESOURCE_TARGETS);
-  reportDiscoveryErrors(discovered);
-  if (!options.json) {
-    process.stderr.write(
-      `fresh-squeezy: discovered store ${storeId} resources: ${formatDiscoveryCounts(discovered)}.
+  const allNames = OPTIONAL_VALIDATORS.map((row) => row.name);
+  const discovered = await discoverChoices(client, storeId, allNames);
+  for (const row of OPTIONAL_VALIDATORS) {
+    const error = discovered[row.name]?.error;
+    if (error) {
+      process.stderr.write(
+        `fresh-squeezy: discovery skipped ${row.label.toLowerCase()}: ${error}
 `
-    );
+      );
+    }
   }
-  return {
-    productIds: mergeValues(explicit.productIds, values(discovered.products)),
-    webhookUrls: mergeValues(explicit.webhookUrls, values(discovered.webhooks)),
-    discountIds: mergeValues(explicit.discountIds, values(discovered.discounts)),
-    licenseKeyIds: mergeValues(explicit.licenseKeyIds, values(discovered.licenseKeys)),
-    variantIds: mergeValues(explicit.variantIds, values(discovered.subscriptionPlans))
-  };
-};
-var DISCOVERY_LABELS = [
-  ["products", "products"],
-  ["webhooks", "webhooks"],
-  ["discounts", "discounts"],
-  ["licenseKeys", "license keys"],
-  ["subscriptionPlans", "subscription plans"]
-];
-var formatDiscoveryCounts = (choices) => DISCOVERY_LABELS.map(([key, label]) => `${label} ${choices[key].choices.length}`).join(", ");
-var reportDiscoveryErrors = (choices) => {
-  for (const [key, label] of DISCOVERY_LABELS) {
-    const error = choices[key].error;
-    if (error) process.stderr.write(`fresh-squeezy: discovery skipped ${label}: ${error}
+  if (!options.json) {
+    const counts = OPTIONAL_VALIDATORS.map(
+      (row) => `${row.label.toLowerCase()} ${discovered[row.name]?.choices.length ?? 0}`
+    ).join(", ");
+    process.stderr.write(`fresh-squeezy: discovered store ${storeId} resources: ${counts}.
 `);
   }
+  const merged = {};
+  for (const row of OPTIONAL_VALIDATORS) {
+    merged[row.field] = mergeValues(explicit[row.field], values(discovered[row.name]));
+  }
+  return merged;
 };
-var values = (group) => group.choices.length > 0 ? group.choices.map((choice) => choice.value) : void 0;
-var one = (value) => value ? [value] : void 0;
-var mergeValues = (explicit, discovered) => {
-  const merged = Array.from(/* @__PURE__ */ new Set([...explicit ?? [], ...discovered ?? []]));
-  return merged.length > 0 ? merged : void 0;
-};
-var hasExplicitResourceSelection = (options) => Boolean(
-  options.productId || options.webhookUrl || options.discountId || options.licenseKeyId || options.variantId
-);
+var hasExplicitResourceSelection = (options) => Object.values(explicitValidatorIds(options)).some((ids) => ids !== void 0);
 var runConnectionOnly = async (client, options) => {
   const connection = await client.validateConnection();
   const report = {
@@ -2937,59 +2083,7 @@ var writeFatal = (err, asJson) => {
 // src/cli/commands/init.ts
 import fs from "fs/promises";
 import path2 from "path";
-import chalk3 from "chalk";
-
-// src/cli/brand.ts
 import chalk2 from "chalk";
-var brand = chalk2.green.bold("fresh-squeezy");
-var divider = chalk2.dim("\u2022");
-var renderBrandHeader = (title, subtitle) => {
-  const lines = [`${brand} ${divider} ${chalk2.bold(title)}`];
-  if (subtitle) lines.push(chalk2.dim(subtitle));
-  lines.push("");
-  return lines.join("\n");
-};
-var renderStep = (index, total, title, detail) => {
-  const suffix = detail ? ` ${chalk2.dim(detail)}` : "";
-  const prefix = index > 1 ? "\n" : "";
-  return `${prefix}${chalk2.yellow("\u25CF")} ${chalk2.dim(`${index}/${total}`)} ${chalk2.bold(title)}${suffix}
-`;
-};
-var renderDetected = (label, value, source) => {
-  const suffix = source ? ` ${chalk2.dim(`from ${source}`)}` : "";
-  return `  ${chalk2.green("\u2713")} ${chalk2.bold(label)} ${value}${suffix}
-`;
-};
-var renderCommandExamples = () => {
-  return [
-    renderBrandHeader("Command examples", "Direct commands stay stable for scripts and CI."),
-    `${chalk2.bold("Guided setup")}`,
-    "  fresh-squeezy init",
-    "",
-    `${chalk2.bold("Full doctor")}`,
-    "  fresh-squeezy doctor --all-stores",
-    "  fresh-squeezy doctor --store-ids 12 --product-id 987 --webhook-url https://app.example.com/api/webhooks/lemon-squeezy",
-    "",
-    `${chalk2.bold("Single checks")}`,
-    "  fresh-squeezy validate connection",
-    "  fresh-squeezy validate webhook --store-ids 12 --webhook-url https://app.example.com/api/webhooks/lemon-squeezy",
-    "",
-    `${chalk2.bold("Bulk ops (delete / cancel / refund)")}`,
-    "  fresh-squeezy delete discount --all --store-ids 12 --dry-run",
-    "  fresh-squeezy delete discount --all --store-ids 12 --match TEST --yes",
-    "  fresh-squeezy delete webhook --ids 1,2,3 --yes",
-    "",
-    `${chalk2.bold("Automation")}`,
-    "  fresh-squeezy doctor --all-stores --json",
-    ""
-  ].join("\n");
-};
-var renderCancelMessage = () => {
-  return `${chalk2.dim("fresh-squeezy cancelled.")}
-`;
-};
-
-// src/cli/commands/init.ts
 var runInitCommand = async (options = {}) => {
   try {
     return await runInitFlow(options);
@@ -3020,7 +2114,8 @@ var runInitFlow = async (options) => {
   process.stdout.write(renderStep(1, 5, "Credentials", "reuse env when available"));
   const apiKey = await resolveApiKey();
   process.stdout.write(renderStep(2, 5, "Account probe", "detect mode and reachable stores"));
-  const { client, mode, connection } = await createDetectedClient(apiKey);
+  const { client, connection } = await connectWithDetectedMode(apiKey);
+  const mode = client.mode;
   if (!connection.ok) {
     process.stdout.write(`${renderReport({ ok: false, mode, results: [connection] })}
 `);
@@ -3030,81 +2125,60 @@ var runInitFlow = async (options) => {
     process.stderr.write(renderCancelMessage());
     return 130;
   }
-  const storeIds = connection.resource?.storeIds ?? [];
-  if (storeIds.length === 0) {
+  const stores = await listStoreChoices(client);
+  if (stores.length === 0) {
     process.stdout.write(
-      chalk3.yellow(
+      chalk2.yellow(
         "No stores reachable with this key. Create a store in Lemon Squeezy and retry.\n"
       )
     );
     return 1;
   }
-  process.stdout.write(renderDetected("Stores", String(storeIds.length), "Lemon Squeezy API"));
-  const stores = await Promise.all(storeIds.map((id) => client.validateStore(id)));
-  const pickable = stores.filter((entry) => entry.ok && entry.resource).map((entry, index) => ({
-    id: storeIds[index] ?? "",
-    name: entry.resource?.name ?? "(unnamed)",
-    slug: entry.resource?.slug ?? ""
-  })).filter((entry) => entry.id !== "");
-  if (pickable.length === 0) {
-    process.stdout.write(
-      chalk3.yellow(
-        "Stores were discovered, but none could be validated. Check account access and retry.\n"
-      )
-    );
-    return 1;
-  }
+  process.stdout.write(renderDetected("Stores", String(stores.length), "Lemon Squeezy API"));
   process.stdout.write(renderStep(3, 5, "Store selection", "auto-select when unambiguous"));
-  const storeId = await resolveStoreSelection(pickable);
+  const storeId = await resolveStoreSelection(stores);
   process.stdout.write(renderStep(4, 5, "Optional checks", "pick resources before manual IDs"));
-  const selectedTargets = await selectDoctorTargets();
-  const resourceChoices = await discoverChoices(client, storeId, selectedTargets);
-  process.stdout.write(renderDiscoverySummary(resourceChoices, selectedTargets));
-  const doctorTargets = await askForDoctorTargetValues(selectedTargets, resourceChoices);
+  const selectedValidators = await selectOptionalValidators();
+  const resourceChoices = await discoverChoices(client, storeId, selectedValidators);
+  process.stdout.write(renderDiscoverySummary(resourceChoices, selectedValidators));
+  const validatorIds = await askForValidatorIds(selectedValidators, resourceChoices);
   const envPath = path2.resolve(process.cwd(), options.envFile ?? ".env");
-  const checkNames = getDoctorCheckNames(doctorTargets);
+  const checkNames = listValidatorNames(validatorIds);
   process.stdout.write(renderSetupSummary({ envPath, mode, storeId, checkNames }));
   const shouldWrite = await confirmWriteEnvFile(envPath);
   if (shouldWrite) {
     await writeEnvFile(envPath, { apiKey, mode, storeId });
-    process.stdout.write(chalk3.green(`Wrote ${envPath}
+    process.stdout.write(chalk2.green(`Wrote ${envPath}
 `));
   }
-  process.stdout.write(chalk3.dim(`
+  process.stdout.write(chalk2.dim(`
 Running doctor (${checkNames.join(", ")})...
 
 `));
-  const report = await client.doctor({ storeId, ...doctorTargets });
+  const report = await client.doctor({ storeId, ...validatorIds });
   process.stdout.write(`${renderReport(report)}
 `);
   return report.ok ? 0 : 1;
 };
-var resolveStoreSelection = async (pickable) => {
-  if (pickable.length === 1) {
-    const store = pickable[0];
-    if (!store) throw new Error("Expected one reachable store.");
-    process.stdout.write(
-      renderDetected("Store", `${store.name} (${store.slug})`, `id ${store.id}`)
-    );
-    return store.id;
+var resolveStoreSelection = async (stores) => {
+  const [only, ...others] = stores;
+  if (only && others.length === 0) {
+    process.stdout.write(renderDetected("Store", `${only.name} (${only.slug})`, `id ${only.id}`));
+    return only.id;
   }
-  return pickStore(pickable);
-};
-var discoverChoices = async (client, storeId, selectedTargets) => {
-  if (selectedTargets.length === 0) return EMPTY_INIT_RESOURCE_CHOICES;
-  return discoverInitResourceChoices(client, storeId, selectedTargets);
+  return pickStore(stores);
 };
 var resolveApiKey = async () => {
   const envApiKey = process.env[ENV_KEYS.apiKey]?.trim();
   if (envApiKey) {
-    process.stdout.write(chalk3.dim(`Using ${ENV_KEYS.apiKey} from environment.
+    process.stdout.write(chalk2.dim(`Using ${ENV_KEYS.apiKey} from environment.
 `));
     return envApiKey;
   }
   const answers = await askForApiKey();
   return answers.apiKey;
 };
-var createDetectedClient = async (apiKey) => {
+var connectWithDetectedMode = async (apiKey) => {
   const envMode = parseEnvMode();
   const initialMode = envMode ?? "test";
   let client = createFreshSqueezy({ apiKey, mode: initialMode });
@@ -3112,58 +2186,53 @@ var createDetectedClient = async (apiKey) => {
   const actualMode = connection.resource?.actualMode;
   if (actualMode && actualMode !== initialMode) {
     const message = envMode ? `Detected ${actualMode}-mode API key; ignoring ${ENV_KEYS.mode}=${initialMode} for this run.` : `Detected ${actualMode}-mode API key.`;
-    process.stdout.write(chalk3.yellow(`${message}
+    process.stdout.write(chalk2.yellow(`${message}
 `));
     client = createFreshSqueezy({ apiKey, mode: actualMode });
     connection = await client.validateConnection();
-    return { client, mode: actualMode, connection };
+    return { client, connection };
   }
   if (actualMode) {
-    process.stdout.write(chalk3.dim(`Detected ${actualMode}-mode API key.
+    process.stdout.write(chalk2.dim(`Detected ${actualMode}-mode API key.
 `));
-    return { client, mode: actualMode, connection };
+    return { client, connection };
   }
   if (envMode) {
     process.stdout.write(
-      chalk3.dim(`Using ${ENV_KEYS.mode}=${envMode}; API mode was not exposed.
+      chalk2.dim(`Using ${ENV_KEYS.mode}=${envMode}; API mode was not exposed.
 `)
     );
-    return { client, mode: envMode, connection };
+    return { client, connection };
   }
-  process.stdout.write(chalk3.dim("Could not auto-detect key mode; using test mode.\n"));
-  return { client, mode: initialMode, connection };
+  process.stdout.write(chalk2.dim("Could not auto-detect key mode; using test mode.\n"));
+  return { client, connection };
 };
 var parseEnvMode = () => {
   const value = process.env[ENV_KEYS.mode]?.trim();
   if (value === "test" || value === "live") return value;
   if (value) {
     process.stdout.write(
-      chalk3.yellow(`Ignoring invalid ${ENV_KEYS.mode}=${value}; expected test or live.
+      chalk2.yellow(`Ignoring invalid ${ENV_KEYS.mode}=${value}; expected test or live.
 `)
     );
   }
   return void 0;
 };
-var getDoctorCheckNames = (targets) => {
+var listValidatorNames = (validatorIds) => {
   const names = ["connection", "store"];
-  pushCheckName(names, "product", targets.productIds);
-  pushCheckName(names, "webhook", targets.webhookUrls);
-  pushCheckName(names, "discount", targets.discountIds);
-  pushCheckName(names, "licenseKey", targets.licenseKeyIds);
-  pushCheckName(names, "subscriptionPlan", targets.variantIds);
+  for (const row of OPTIONAL_VALIDATORS) {
+    const count = validatorIds[row.field]?.length ?? 0;
+    if (count > 0) names.push(count === 1 ? row.resultName : `${row.resultName} x${count}`);
+  }
   return names;
 };
-var pushCheckName = (names, name, values2) => {
-  if (!values2 || values2.length === 0) return;
-  names.push(values2.length === 1 ? name : `${name} x${values2.length}`);
-};
 var renderSetupSummary = (input2) => {
   return [
     renderStep(5, 5, "Ready to verify", "review before writing env"),
-    `  ${chalk3.dim("mode")}   ${input2.mode}`,
-    `  ${chalk3.dim("store")}  ${input2.storeId}`,
-    `  ${chalk3.dim("checks")} ${input2.checkNames.join(", ")}`,
-    `  ${chalk3.dim("env")}    ${input2.envPath}`,
+    `  ${chalk2.dim("mode")}   ${input2.mode}`,
+    `  ${chalk2.dim("store")}  ${input2.storeId}`,
+    `  ${chalk2.dim("checks")} ${input2.checkNames.join(", ")}`,
+    `  ${chalk2.dim("env")}    ${input2.envPath}`,
     ""
   ].join("\n");
 };
@@ -3205,32 +2274,25 @@ var readEnvFile = async (envPath) => {
     throw err;
   }
 };
-var renderDiscoverySummary = (choices, selectedTargets) => {
-  if (selectedTargets.length === 0) return chalk3.dim("  No optional resource checks selected.\n");
-  const groups = [
-    ["product", "Products", choices.products],
-    ["webhook", "Webhooks", choices.webhooks],
-    ["discount", "Discounts", choices.discounts],
-    ["license-key", "License keys", choices.licenseKeys],
-    ["subscription-plan", "Subscription plans", choices.subscriptionPlans]
-  ];
-  const lines = [];
-  for (const [target, label, group] of groups) {
-    if (!selectedTargets.includes(target)) continue;
-    if (group.error) {
-      lines.push(chalk3.yellow(`  ! ${label} discovery failed; manual entry is available.`));
-    } else {
-      lines.push(
-        renderDetected(label, String(group.choices.length), "Lemon Squeezy API").trimEnd()
-      );
+var renderDiscoverySummary = (choices, selectedValidators) => {
+  if (selectedValidators.length === 0)
+    return chalk2.dim("  No optional resource checks selected.\n");
+  const lines = OPTIONAL_VALIDATORS.filter((row) => selectedValidators.includes(row.name)).map(
+    (row) => {
+      const group = choices[row.name];
+      if (group?.error) {
+        return chalk2.yellow(`  ! ${row.label} discovery failed; manual entry is available.`);
+      }
+      const count = String(group?.choices.length ?? 0);
+      return renderDetected(row.label, count, "Lemon Squeezy API").trimEnd();
     }
-  }
+  );
   return `${lines.join("\n")}
 `;
 };
 
 // src/cli/commands/launcher.ts
-import chalk4 from "chalk";
+import chalk3 from "chalk";
 
 // src/cli/projectInstall.ts
 import { spawn } from "child_process";
@@ -3518,7 +2580,7 @@ var runLauncherCommand = async (options) => {
       return 130;
     }
     const message = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`${chalk4.red("fresh-squeezy bootstrap failed:")} ${message}
+    process.stderr.write(`${chalk3.red("fresh-squeezy bootstrap failed:")} ${message}
 
 `);
     process.stderr.write(renderCommandExamples());
@@ -3561,9 +2623,9 @@ var renderProjectInstallResult = (result) => {
     return renderDetected("Project", "fresh-squeezy source repo", "package.json");
   }
   if (result.status === "skipped") {
-    return chalk4.dim("  Skipped dev dependency install (--no-install).\n");
+    return chalk3.dim("  Skipped dev dependency install (--no-install).\n");
   }
-  return chalk4.yellow("  No package.json found; running without installing a dev dependency.\n");
+  return chalk3.yellow("  No package.json found; running without installing a dev dependency.\n");
 };
 
 // src/cli/commands/resourceOps.ts
@@ -3600,14 +2662,13 @@ var runResourceOpCommand = async (options) => {
         message: "This op requires a JSON body (--body, --body-file, or stdin)."
       });
     }
-    const client = createFreshSqueezy({ mode: options.mode });
     const config = resolveConfig({ mode: options.mode });
     const http = new HttpClient(config);
     const storeId = options.storeIds?.[0] ?? config.storeId;
     if (options.all || options.ids) {
-      return await runBulk(http, spec, client.mode, options, { storeId, body });
+      return await runBulk(http, spec, config.mode, options, { storeId, body });
     }
-    const allowed = await assertWriteSafety(spec, client.mode, options);
+    const allowed = await assertWriteSafety(spec, config.mode, options);
     if (!allowed) return 2;
     const opBody = await invokeOp(http, options.resource, options.verb, {
       id: options.id,
@@ -3617,7 +2678,7 @@ var runResourceOpCommand = async (options) => {
     });
     const envelope = {
       ok: true,
-      mode: client.mode,
+      mode: config.mode,
       resource: spec.resource,
       verb: spec.verb,
       docs: `https://docs.lemonsqueezy.com/api/${spec.docsPath}`,
@@ -3628,7 +2689,7 @@ var runResourceOpCommand = async (options) => {
 `);
     } else {
       process.stdout.write(
-        `${spec.verb} ${spec.resource} \u2014 ok (mode=${client.mode})
+        `${spec.verb} ${spec.resource} \u2014 ok (mode=${config.mode})
 ${JSON.stringify(opBody ?? null, null, 2)}
 `
       );
@@ -3768,44 +2829,15 @@ var writeFatal2 = (err, json) => {
 };
 
 // src/cli/commands/validate.ts
-var runValidateCommand = async (target, options) => {
-  try {
-    const client = createFreshSqueezy({ mode: options.mode });
-    if (target === "connection") {
-      return emit(await client.validateConnection(), options);
-    }
-    if (target === "product") {
-      return emit(await runProduct(client, options), options);
-    }
-    if (target === "discount") {
-      return emit(await runDiscount(client, options), options);
-    }
-    if (target === "license-key") {
-      return emit(await runLicenseKey(client, options), options);
-    }
-    if (target === "subscription-plan") {
-      return emit(await runSubscriptionPlan(client, options), options);
-    }
-    const storeIds = await resolveStoresForTarget(client, target, options);
-    const results = await runPerStore(client, target, storeIds, options);
-    if (options.json) {
-      process.stdout.write(`${JSON.stringify(results, null, 2)}
-`);
-    } else {
-      for (const result of results) {
-        process.stdout.write(`${renderResult(result)}
-
-`);
-      }
-    }
-    return results.every((result) => result.ok) ? 0 : 1;
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    process.stderr.write(renderCliError(message, getValidateHints(err, target)));
-    return 2;
+var EXAMPLE_WEBHOOK_URL = "https://app.example.com/api/webhooks/lemon-squeezy";
+var required = (value, message) => {
+  if (value === void 0 || value === null || value === "") {
+    throw new FreshSqueezyError({ code: "MISSING_ARG", message });
   }
+  return value;
 };
-var resolveStoresForTarget = async (client, target, options) => {
+var requiredStoreId = (options, target) => required(options.storeIds?.[0], `--store-ids is required for \`validate ${target}\`.`);
+var resolveStoresForSubcommand = async (client, target, options) => {
   const resolved = await resolveStores(client, {
     storeIds: options.storeIds,
     allStores: options.allStores,
@@ -3819,72 +2851,127 @@ var resolveStoresForTarget = async (client, target, options) => {
   }
   return resolved.storeIds;
 };
-var runPerStore = async (client, target, storeIds, options) => {
-  if (target === "store") {
-    return Promise.all(storeIds.map((id) => client.validateStore(id)));
+var VALIDATE_SUBCOMMANDS = {
+  connection: {
+    description: "Check that the API key authenticates",
+    stores: "none",
+    examples: ["fresh-squeezy validate connection"],
+    run: (client) => client.validateConnection()
+  },
+  store: {
+    description: "Check one or more stores are reachable",
+    stores: "multi",
+    storeIdsHelp: "Comma-separated store IDs",
+    examples: [
+      "fresh-squeezy validate store --store-ids 12",
+      "fresh-squeezy validate store --all-stores"
+    ],
+    run: async (client, options) => {
+      const storeIds = await resolveStoresForSubcommand(client, "store", options);
+      return Promise.all(storeIds.map((storeId) => client.validateStore(storeId)));
+    }
+  },
+  product: {
+    description: "Check a product is published with at least one variant",
+    stores: "ownership",
+    required: ["--product-id <id>", "Product ID to validate"],
+    storeIdsHelp: "Expected owning store IDs (first is used for cross-check)",
+    examples: ["fresh-squeezy validate product --product-id 987"],
+    run: (client, options) => client.validateProduct({
+      productId: required(options.productId, "--product-id is required for `validate product`."),
+      expectedStoreId: options.storeIds?.[0]
+    })
+  },
+  webhook: {
+    description: "Check a webhook is registered with the recommended events",
+    stores: "multi",
+    required: ["--webhook-url <url>", "Public webhook URL"],
+    storeIdsHelp: "Comma-separated store IDs",
+    examples: [
+      `fresh-squeezy validate webhook --store-ids 12 --webhook-url ${EXAMPLE_WEBHOOK_URL}`,
+      `fresh-squeezy validate webhook --all-stores --webhook-url ${EXAMPLE_WEBHOOK_URL}`
+    ],
+    run: async (client, options) => {
+      const storeIds = await resolveStoresForSubcommand(client, "webhook", options);
+      const url = required(options.webhookUrl, "--webhook-url is required for `validate webhook`.");
+      return Promise.all(storeIds.map((storeId) => client.validateWebhook({ storeId, url })));
+    }
+  },
+  discount: {
+    description: "Check a discount code is valid and redeemable",
+    stores: "ownership",
+    required: ["--discount-id <id>", "Discount ID to validate"],
+    storeIdsHelp: "Store ID for ownership check (first ID used)",
+    examples: ["fresh-squeezy validate discount --store-ids 12 --discount-id 123"],
+    run: (client, options) => client.validateDiscount({
+      discountId: required(
+        options.discountId,
+        "--discount-id is required for `validate discount`."
+      ),
+      storeId: requiredStoreId(options, "discount")
+    })
+  },
+  "license-key": {
+    description: "Check a license key is active and not at its activation limit",
+    stores: "ownership",
+    required: ["--license-key-id <id>", "License key ID to validate"],
+    storeIdsHelp: "Store ID for ownership check (first ID used)",
+    examples: ["fresh-squeezy validate license-key --store-ids 12 --license-key-id 123"],
+    run: (client, options) => client.validateLicenseKey({
+      licenseKeyId: required(
+        options.licenseKeyId,
+        "--license-key-id is required for `validate license-key`."
+      ),
+      storeId: requiredStoreId(options, "license-key")
+    })
+  },
+  "subscription-plan": {
+    description: "Check a subscription plan variant has valid billing interval and trial config",
+    stores: "ownership",
+    required: ["--variant-id <id>", "Variant ID of the subscription plan"],
+    storeIdsHelp: "Store ID for ownership check (first ID used)",
+    examples: ["fresh-squeezy validate subscription-plan --store-ids 12 --variant-id 123"],
+    run: (client, options) => client.validateSubscriptionPlan({
+      variantId: required(
+        options.variantId,
+        "--variant-id is required for `validate subscription-plan`."
+      ),
+      storeId: requiredStoreId(options, "subscription-plan")
+    })
   }
-  if (target === "webhook") {
-    const url = required2(options.webhookUrl, "--webhook-url is required for `validate webhook`.");
-    return Promise.all(storeIds.map((storeId) => client.validateWebhook({ storeId, url })));
+};
+var errorHints = (err, target) => {
+  if (!(err instanceof FreshSqueezyError)) return [];
+  if (err.code === "MISSING_API_KEY") return MISSING_API_KEY_HINTS;
+  if (err.code === "INVALID_MODE") {
+    return [
+      `fresh-squeezy validate ${target} --mode test`,
+      `fresh-squeezy validate ${target} --mode live`
+    ];
   }
+  if (err.code === "MISSING_ARG") return VALIDATE_SUBCOMMANDS[target].examples;
   return [];
 };
-var runProduct = async (client, options) => {
-  const productId = required2(options.productId, "--product-id is required for `validate product`.");
-  const expected = options.storeIds?.[0];
-  return client.validateProduct({
-    productId,
-    expectedStoreId: expected
-  });
-};
-var runDiscount = async (client, options) => {
-  const discountId = required2(
-    options.discountId,
-    "--discount-id is required for `validate discount`."
-  );
-  const storeId = required2(
-    options.storeIds?.[0],
-    "--store-ids is required for `validate discount`."
-  );
-  return client.validateDiscount({ storeId, discountId });
-};
-var runLicenseKey = async (client, options) => {
-  const licenseKeyId = required2(
-    options.licenseKeyId,
-    "--license-key-id is required for `validate license-key`."
-  );
-  const storeId = required2(
-    options.storeIds?.[0],
-    "--store-ids is required for `validate license-key`."
-  );
-  return client.validateLicenseKey({ storeId, licenseKeyId });
-};
-var runSubscriptionPlan = async (client, options) => {
-  const variantId = required2(
-    options.variantId,
-    "--variant-id is required for `validate subscription-plan`."
-  );
-  const storeId = required2(
-    options.storeIds?.[0],
-    "--store-ids is required for `validate subscription-plan`."
-  );
-  return client.validateSubscriptionPlan({ storeId, variantId });
-};
-var emit = (result, options) => {
+var writeResults = (results, options) => {
+  const list = Array.isArray(results) ? results : [results];
   if (options.json) {
-    process.stdout.write(`${JSON.stringify(result, null, 2)}
+    process.stdout.write(`${JSON.stringify(results, null, 2)}
 `);
   } else {
-    process.stdout.write(`${renderResult(result)}
-`);
+    const separator = Array.isArray(results) ? "\n\n" : "\n";
+    for (const result of list) process.stdout.write(`${renderResult(result)}${separator}`);
   }
-  return result.ok ? 0 : 1;
+  return list.every((result) => result.ok) ? 0 : 1;
 };
-var required2 = (value, message) => {
-  if (value === void 0 || value === null || value === "") {
-    throw new FreshSqueezyError({ code: "MISSING_ARG", message });
+var runValidateCommand = async (target, options) => {
+  try {
+    const client = createFreshSqueezy({ mode: options.mode });
+    return writeResults(await VALIDATE_SUBCOMMANDS[target].run(client, options), options);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(renderCliError(message, errorHints(err, target)));
+    return 2;
   }
-  return value;
 };
 
 // src/cli/main.ts
@@ -3902,7 +2989,10 @@ var OP_VERBS = [
 ];
 var parseMode = (value) => {
   if (value === "test" || value === "live") return value;
-  throw new Error(`Mode must be "test" or "live", got "${value}"`);
+  throw new FreshSqueezyError({
+    code: "INVALID_MODE",
+    message: `Mode must be "test" or "live", got "${value}"`
+  });
 };
 var parseCsv = (value) => value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
 var readPackageVersion = () => {
@@ -3921,69 +3011,9 @@ var readPackageVersion = () => {
 };
 var isInteractive = Boolean(process.stdin.isTTY);
 var packageVersion = readPackageVersion();
-var VALIDATE_COMMANDS = [
-  {
-    name: "connection",
-    description: "Check that the API key authenticates",
-    stores: "none"
-  },
-  {
-    name: "store",
-    description: "Check one or more stores are reachable",
-    stores: "multi",
-    storeIdsHelp: "Comma-separated store IDs"
-  },
-  {
-    name: "product",
-    description: "Check a product is published with at least one variant",
-    stores: "ownership",
-    required: ["--product-id <id>", "Product ID to validate"],
-    storeIdsHelp: "Expected owning store IDs (first is used for cross-check)"
-  },
-  {
-    name: "webhook",
-    description: "Check a webhook is registered with the recommended events",
-    stores: "multi",
-    required: ["--webhook-url <url>", "Public webhook URL"],
-    storeIdsHelp: "Comma-separated store IDs"
-  },
-  {
-    name: "discount",
-    description: "Check a discount code is valid and redeemable",
-    stores: "ownership",
-    required: ["--discount-id <id>", "Discount ID to validate"],
-    storeIdsHelp: "Store ID for ownership check (first ID used)"
-  },
-  {
-    name: "license-key",
-    description: "Check a license key is active and not at its activation limit",
-    stores: "ownership",
-    required: ["--license-key-id <id>", "License key ID to validate"],
-    storeIdsHelp: "Store ID for ownership check (first ID used)"
-  },
-  {
-    name: "subscription-plan",
-    description: "Check a subscription plan variant has valid billing interval and trial config",
-    stores: "ownership",
-    required: ["--variant-id <id>", "Variant ID of the subscription plan"],
-    storeIdsHelp: "Store ID for ownership check (first ID used)"
-  }
-];
 var exitWith = async (code) => {
-  process.exit(await code);
-};
-var toValidateOptions = (opts) => ({
-  mode: opts.mode,
-  storeIds: opts.storeIds,
-  allStores: Boolean(opts.allStores),
-  productId: opts.productId,
-  webhookUrl: opts.webhookUrl,
-  discountId: opts.discountId,
-  licenseKeyId: opts.licenseKeyId,
-  variantId: opts.variantId,
-  json: Boolean(opts.json),
-  isInteractive
-});
+  process.exitCode = await code;
+};
 var attachModeJson = (cmd) => cmd.option("-m, --mode <mode>", "test or live", parseMode).option("--json", "Emit machine-readable JSON");
 var attachValidateFlags = (cmd, spec) => {
   if (spec.required) cmd.requiredOption(spec.required[0], spec.required[1]);
@@ -4035,7 +3065,8 @@ program.action(async (opts) => {
         "fresh-squeezy validate connection"
       ])
     );
-    process.exit(2);
+    process.exitCode = 2;
+    return;
   }
   await exitWith(
     runLauncherCommand({
@@ -4049,12 +3080,7 @@ var doctor2 = program.command("doctor").description("Run the full integration do
   "--all-resources",
   "Discover and validate every supported resource in each selected store"
 ).option("--product-id <id>", "Product to validate").option("--webhook-url <url>", "Webhook URL to validate").option("--discount-id <id>", "Discount to validate").option("--license-key-id <id>", "License key to validate").option("--variant-id <id>", "Subscription plan variant to validate").option("--json", "Emit machine-readable JSON").action(async (opts) => {
-  await exitWith(
-    runDoctorCommand({
-      ...toValidateOptions(opts),
-      allResources: Boolean(opts.allResources)
-    })
-  );
+  await exitWith(runDoctorCommand({ ...opts, isInteractive }));
 });
 doctor2.addHelpText(
   "after",
@@ -4077,13 +3103,13 @@ Examples:
   fresh-squeezy validate webhook --store-ids 12 --webhook-url https://app.example.com/api/webhooks/lemon-squeezy
 
 Targets:
-  connection, store, product, webhook, discount, license-key, subscription-plan
+  ${Object.keys(VALIDATE_SUBCOMMANDS).join(", ")}
 `
 );
-for (const spec of VALIDATE_COMMANDS) {
-  attachValidateFlags(validate.command(spec.name).description(spec.description), spec).action(
+for (const [name, spec] of Object.entries(VALIDATE_SUBCOMMANDS)) {
+  attachValidateFlags(validate.command(name).description(spec.description), spec).action(
     async (opts) => {
-      await exitWith(runValidateCommand(spec.name, toValidateOptions(opts)));
+      await exitWith(runValidateCommand(name, { ...opts, isInteractive }));
     }
   );
 }
@@ -4164,6 +3190,6 @@ program.parseAsync(process.argv).catch((err) => {
   const message = err instanceof Error ? err.message : String(err);
   const hints = message.includes("Mode must be") ? ["fresh-squeezy doctor --mode test", "fresh-squeezy doctor --mode live"] : ["fresh-squeezy --help"];
   process.stderr.write(renderCliError(message, hints));
-  process.exit(2);
+  process.exitCode = 2;
 });
 //# sourceMappingURL=cli.js.map