fresh-squeezy 0.1.11 → 0.1.13

package/dist/index.cjs

@@ -32,6 +32,10 @@ __export(src_exports, {
   SUPPORTED_RESOURCES: () => SUPPORTED_RESOURCES,
   buildResult: () => buildResult,
   buildSubscriptionItemUpdateBody: () => buildSubscriptionItemUpdateBody,
+  checkDiscount: () => checkDiscount,
+  checkLicenseKey: () => checkLicenseKey,
+  checkProduct: () => checkProduct,
+  checkSubscriptionPlan: () => checkSubscriptionPlan,
   createFreshSqueezy: () => createFreshSqueezy,
   doctor: () => doctor,
   fetchActualMode: () => fetchActualMode,
@@ -73,7 +77,11 @@ __export(src_exports, {
   sameWebhookUrl: () => sameWebhookUrl,
   userResource: () => userResource,
   validateConnection: () => validateConnection,
+  validateDiscount: () => validateDiscount,
+  validateLicenseKey: () => validateLicenseKey,
   validateProduct: () => validateProduct,
+  validateStore: () => validateStore,
+  validateSubscriptionPlan: () => validateSubscriptionPlan,
   validateWebhook: () => validateWebhook
 });
 module.exports = __toCommonJS(src_exports);
@@ -240,24 +248,12 @@ function extractJsonApiErrors(body) {
   );
 }
 
-// src/resources/users.ts
-async function getAuthenticatedUser(http) {
-  return http.request({ path: "/v1/users/me" });
-}
-function userResource(doc) {
-  return doc.data;
-}
-
 // src/core/mode.ts
 function resolveActualMode(testMode) {
   if (testMode === true) return "test";
   if (testMode === false) return "live";
   return void 0;
 }
-async function fetchActualMode(http) {
-  const doc = await getAuthenticatedUser(http);
-  return resolveActualMode(doc.meta?.test_mode);
-}
 
 // src/resources/stores.ts
 async function getStore(http, storeId) {
@@ -267,6 +263,14 @@ async function listStores(http) {
   return http.paginate("/v1/stores");
 }
 
+// src/resources/users.ts
+async function getAuthenticatedUser(http) {
+  return http.request({ path: "/v1/users/me" });
+}
+function userResource(doc) {
+  return doc.data;
+}
+
 // src/validate/rules.ts
 var ISSUE_CODES = {
   AUTH_FAILED: "AUTH_FAILED",
@@ -355,20 +359,20 @@ function mapErrorToIssue(err, mapping = {}) {
   return issue(ISSUE_CODES.UNKNOWN, "error", message);
 }
 async function probeFetch(fetcher, options) {
+  return probeCollection(fetcher, {
+    notFound: {
+      code: options.notFoundCode,
+      message: options.notFoundMessage,
+      ...options.notFoundFix !== void 0 ? { suggestedFix: options.notFoundFix } : {},
+      ...options.notFoundContext !== void 0 ? { context: options.notFoundContext } : {}
+    }
+  });
+}
+async function probeCollection(fetcher, mapping = {}) {
   try {
     return { ok: true, resource: await fetcher() };
   } catch (err) {
-    return {
-      ok: false,
-      issue: mapErrorToIssue(err, {
-        notFound: {
-          code: options.notFoundCode,
-          message: options.notFoundMessage,
-          ...options.notFoundFix !== void 0 ? { suggestedFix: options.notFoundFix } : {},
-          ...options.notFoundContext !== void 0 ? { context: options.notFoundContext } : {}
-        }
-      })
-    };
+    return { ok: false, issue: mapErrorToIssue(err, mapping) };
   }
 }
 function checkStoreOwnership(check) {
@@ -394,187 +398,538 @@ function checkStoreOwnership(check) {
 // src/validate/connection.ts
 async function validateConnection(http, mode) {
   const issues = [];
-  try {
-    const userDoc = await getAuthenticatedUser(http);
-    const stores = await listStores(http);
-    const actualMode = resolveActualMode(userDoc.meta?.test_mode);
-    const summary = {
-      user: userDoc.data.attributes,
-      storeCount: stores.length,
-      storeIds: stores.map((store) => store.id),
-      declaredMode: mode,
-      ...actualMode ? { actualMode } : {}
-    };
-    if (actualMode && actualMode !== mode) {
-      issues.push(
-        issue(
-          ISSUE_CODES.MODE_MISMATCH,
-          "error",
-          `API key is a ${actualMode}-mode key but was run with --mode ${mode}.`,
-          {
-            suggestedFix: `Either pass --mode ${actualMode} or use a ${mode}-mode key from https://app.lemonsqueezy.com/settings/api.`,
-            context: { declared: mode, actual: actualMode }
-          }
-        )
-      );
-    }
-    if (stores.length === 0) {
-      issues.push(
-        issue(
-          ISSUE_CODES.STORE_NOT_FOUND,
-          "warning",
-          "API key authenticated but no stores are reachable.",
-          { suggestedFix: "Confirm the API key belongs to an account that owns at least one store." }
-        )
-      );
+  const fetched = await probeCollection(
+    async () => {
+      const userDoc2 = await getAuthenticatedUser(http);
+      const stores2 = await listStores(http);
+      return { userDoc: userDoc2, stores: stores2 };
+    },
+    {
+      unauthorized: {
+        code: ISSUE_CODES.AUTH_FAILED,
+        message: "API key rejected by Lemon Squeezy.",
+        suggestedFix: "Regenerate the key at https://app.lemonsqueezy.com/settings/api."
+      }
     }
-    return buildResult("connection", mode, issues, summary);
-  } catch (err) {
+  );
+  if (!fetched.ok) {
+    issues.push(fetched.issue);
+    return buildResult("connection", mode, issues);
+  }
+  const { userDoc, stores } = fetched.resource;
+  const actualMode = resolveActualMode(userDoc.meta?.test_mode);
+  const summary = {
+    user: userDoc.data.attributes,
+    storeCount: stores.length,
+    storeIds: stores.map((store) => store.id),
+    declaredMode: mode,
+    ...actualMode ? { actualMode } : {}
+  };
+  if (actualMode && actualMode !== mode) {
     issues.push(
-      mapErrorToIssue(err, {
-        unauthorized: {
-          code: ISSUE_CODES.AUTH_FAILED,
-          message: "API key rejected by Lemon Squeezy.",
-          suggestedFix: "Regenerate the key at https://app.lemonsqueezy.com/settings/api."
+      issue(
+        ISSUE_CODES.MODE_MISMATCH,
+        "error",
+        `API key is a ${actualMode}-mode key but was run with --mode ${mode}.`,
+        {
+          suggestedFix: `Either pass --mode ${actualMode} or use a ${mode}-mode key from https://app.lemonsqueezy.com/settings/api.`,
+          context: { declared: mode, actual: actualMode }
         }
-      })
+      )
     );
-    return buildResult("connection", mode, issues);
   }
-}
-
-// src/validate/store.ts
-async function validateStore(http, mode, storeId) {
-  const issues = [];
-  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) }
-  });
-  if (!fetched.ok) {
-    issues.push(fetched.issue);
-    return buildResult("store", mode, issues, void 0, {
-      label: `store ${storeId}`,
-      id: String(storeId)
-    });
+  if (stores.length === 0) {
+    issues.push(
+      issue(
+        ISSUE_CODES.STORE_NOT_FOUND,
+        "warning",
+        "API key authenticated but no stores are reachable.",
+        { suggestedFix: "Confirm the API key belongs to an account that owns at least one store." }
+      )
+    );
   }
-  return buildResult("store", mode, issues, fetched.resource.attributes, {
-    label: fetched.resource.attributes.name,
-    id: String(storeId)
-  });
-}
-
-// src/resources/products.ts
-async function getProduct(http, productId) {
-  return http.getResource(`/v1/products/${productId}`);
+  return buildResult("connection", mode, issues, summary);
 }
-async function listProducts(http, storeId) {
-  return http.paginate("/v1/products", {
-    "filter[store_id]": String(storeId)
-  });
+async function fetchActualMode(http) {
+  const doc = await getAuthenticatedUser(http);
+  return resolveActualMode(doc.meta?.test_mode);
 }
 
-// src/resources/variants.ts
-async function getVariant(http, variantId) {
-  return http.getResource(`/v1/variants/${variantId}`);
-}
-async function listVariantsForProduct(http, productId) {
-  return http.paginate("/v1/variants", {
-    "filter[product_id]": String(productId)
-  });
+// src/resources/discounts.ts
+async function getDiscount(http, discountId) {
+  return http.getResource(`/v1/discounts/${discountId}`);
 }
 
-// src/validate/product.ts
-async function validateProduct(http, mode, options) {
+// src/validate/discount.ts
+async function validateDiscount(http, mode, options) {
   const issues = [];
-  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(() => 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) }
   });
   if (!fetched.ok) {
     issues.push(fetched.issue);
-    return buildResult("product", mode, issues, void 0, {
-      label: `product ${options.productId}`,
-      id: String(options.productId)
+    return buildResult("discount", mode, issues, void 0, {
+      label: `discount ${options.discountId}`,
+      id: String(options.discountId)
     });
   }
   const attrs = fetched.resource.attributes;
-  if (options.expectedStoreId !== void 0) {
-    const mismatch = checkStoreOwnership({
-      expectedStoreId: options.expectedStoreId,
-      actualStoreId: attrs.store_id,
-      code: ISSUE_CODES.PRODUCT_WRONG_STORE,
-      label: "Product",
-      suggestedFix: "Either use the correct store ID or the correct product ID \u2014 IDs should not cross stores."
-    });
-    if (mismatch) issues.push(mismatch);
+  issues.push(...checkDiscount(attrs, { storeId: options.storeId }));
+  return buildResult("discount", mode, issues, attrs, {
+    label: `${attrs.name} (${attrs.code})`,
+    id: String(options.discountId)
+  });
+}
+function checkDiscount(attrs, options) {
+  const issues = [];
+  const mismatch = checkStoreOwnership({
+    expectedStoreId: options.storeId,
+    actualStoreId: attrs.store_id,
+    code: ISSUE_CODES.DISCOUNT_STORE_MISMATCH,
+    label: "Discount",
+    suggestedFix: "Use the correct store ID or discount ID \u2014 discounts should not cross stores."
+  });
+  if (mismatch) issues.push(mismatch);
+  if (attrs.status === "draft") {
+    issues.push(
+      issue(
+        ISSUE_CODES.DISCOUNT_DRAFT,
+        "warning",
+        `Discount "${attrs.name}" is in draft status \u2014 customers cannot redeem it.`,
+        {
+          suggestedFix: "Publish the discount in the Lemon Squeezy dashboard before sharing the code.",
+          context: { name: attrs.name, code: attrs.code }
+        }
+      )
+    );
   }
-  if (attrs.status !== "published") {
+  const now = /* @__PURE__ */ new Date();
+  if (attrs.expires_at && new Date(attrs.expires_at) < now) {
     issues.push(
       issue(
-        ISSUE_CODES.PRODUCT_UNPUBLISHED,
+        ISSUE_CODES.DISCOUNT_EXPIRED,
         "error",
-        `Product is in "${attrs.status}" state, not "published".`,
+        `Discount "${attrs.name}" expired at ${attrs.expires_at}.`,
         {
-          suggestedFix: "Publish the product in the Lemon Squeezy dashboard before selling.",
-          context: { status: attrs.status }
+          suggestedFix: "Extend the expiration date or create a new discount.",
+          context: { name: attrs.name, expiresAt: attrs.expires_at }
         }
       )
     );
   }
-  if (!attrs.buy_now_url) {
+  if (attrs.starts_at && new Date(attrs.starts_at) > now) {
     issues.push(
       issue(
-        ISSUE_CODES.PRODUCT_NO_BUY_URL,
+        ISSUE_CODES.DISCOUNT_NOT_STARTED,
         "warning",
-        "Product has no buy-now URL. Hosted checkout may be disabled.",
-        { suggestedFix: "Enable buy-now in product settings, or use a custom checkout flow." }
+        `Discount "${attrs.name}" starts at ${attrs.starts_at} \u2014 not yet active.`,
+        {
+          suggestedFix: "Wait for the start date or adjust it in the dashboard.",
+          context: { name: attrs.name, startsAt: attrs.starts_at }
+        }
       )
     );
   }
-  try {
-    const variants = await listVariantsForProduct(http, options.productId);
-    if (variants.length === 0) {
-      issues.push(
-        issue(
-          ISSUE_CODES.VARIANT_MISSING,
-          "error",
-          "Product has no variants. Customers cannot purchase it.",
-          { suggestedFix: "Add at least one variant in the product configuration." }
-        )
-      );
-    } else if (!variants.some((variant) => variant.attributes.status === "published")) {
-      issues.push(
-        issue(
-          ISSUE_CODES.VARIANT_UNPUBLISHED,
-          "error",
-          "Product has variants but none are published.",
-          { suggestedFix: "Publish at least one variant." }
-        )
-      );
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Unknown error fetching variants";
-    issues.push(issue(ISSUE_CODES.UNKNOWN, "warning", message));
+  if (attrs.is_limited_redemptions && attrs.max_redemptions <= 0) {
+    issues.push(
+      issue(
+        ISSUE_CODES.DISCOUNT_REDEMPTIONS_EXHAUSTED,
+        "warning",
+        `Discount "${attrs.name}" has limited redemptions with max_redemptions \u2264 0.`,
+        {
+          suggestedFix: "Increase max_redemptions or disable the redemption limit.",
+          context: { name: attrs.name, maxRedemptions: attrs.max_redemptions }
+        }
+      )
+    );
   }
-  return buildResult("product", mode, issues, attrs, {
-    label: attrs.name,
-    id: String(options.productId)
-  });
+  if (attrs.amount <= 0) {
+    issues.push(
+      issue(
+        ISSUE_CODES.DISCOUNT_INVALID_AMOUNT,
+        "error",
+        `Discount "${attrs.name}" has amount ${attrs.amount} \u2014 must be positive.`,
+        {
+          suggestedFix: "Set a positive discount amount in the dashboard.",
+          context: { name: attrs.name, amount: attrs.amount }
+        }
+      )
+    );
+  } else if (attrs.amount_type === "percent" && attrs.amount > 100) {
+    issues.push(
+      issue(
+        ISSUE_CODES.DISCOUNT_INVALID_AMOUNT,
+        "error",
+        `Discount "${attrs.name}" is ${attrs.amount}% \u2014 percent discounts cannot exceed 100%.`,
+        {
+          suggestedFix: "Set the discount to 100% or less.",
+          context: { name: attrs.name, amount: attrs.amount, amountType: attrs.amount_type }
+        }
+      )
+    );
+  }
+  return issues;
 }
 
-// src/core/equality.ts
-function sameWebhookUrl(a, b) {
-  return normalizeWebhookUrl(a) === normalizeWebhookUrl(b);
-}
-function normalizeWebhookUrl(raw) {
-  return raw.replace(/\/+$/, "").toLowerCase();
+// src/resources/licenseKeys.ts
+async function getLicenseKey(http, licenseKeyId) {
+  return http.getResource(`/v1/license-keys/${licenseKeyId}`);
 }
 
-// src/resources/webhooks.ts
+// src/validate/licenseKey.ts
+async function validateLicenseKey(http, mode, options) {
+  const issues = [];
+  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) }
+  });
+  if (!fetched.ok) {
+    issues.push(fetched.issue);
+    return buildResult("licenseKey", mode, issues, void 0, {
+      label: `license key ${options.licenseKeyId}`,
+      id: String(options.licenseKeyId)
+    });
+  }
+  const attrs = fetched.resource.attributes;
+  issues.push(...checkLicenseKey(attrs, { storeId: options.storeId }));
+  return buildResult("licenseKey", mode, issues, attrs, {
+    label: attrs.key_short,
+    id: String(options.licenseKeyId)
+  });
+}
+function checkLicenseKey(attrs, options) {
+  const issues = [];
+  const mismatch = checkStoreOwnership({
+    expectedStoreId: options.storeId,
+    actualStoreId: attrs.store_id,
+    code: ISSUE_CODES.LICENSE_KEY_STORE_MISMATCH,
+    label: "License key",
+    suggestedFix: "Use the correct store ID or license key ID \u2014 keys should not cross stores."
+  });
+  if (mismatch) issues.push(mismatch);
+  if (attrs.disabled) {
+    issues.push(
+      issue(
+        ISSUE_CODES.LICENSE_KEY_DISABLED,
+        "error",
+        `License key ${attrs.key_short} is disabled.`,
+        {
+          suggestedFix: "Re-enable the license key in the Lemon Squeezy dashboard.",
+          context: { keyShort: attrs.key_short }
+        }
+      )
+    );
+  }
+  if (attrs.expires_at && new Date(attrs.expires_at) < /* @__PURE__ */ new Date()) {
+    issues.push(
+      issue(
+        ISSUE_CODES.LICENSE_KEY_EXPIRED,
+        "error",
+        `License key ${attrs.key_short} expired at ${attrs.expires_at}.`,
+        {
+          suggestedFix: "Extend the expiration date or issue a new license key.",
+          context: { keyShort: attrs.key_short, expiresAt: attrs.expires_at }
+        }
+      )
+    );
+  }
+  if (attrs.activation_limit !== null && attrs.instances_count >= attrs.activation_limit) {
+    issues.push(
+      issue(
+        ISSUE_CODES.LICENSE_KEY_AT_ACTIVATION_LIMIT,
+        "warning",
+        `License key ${attrs.key_short} has reached its activation limit (${attrs.instances_count}/${attrs.activation_limit}).`,
+        {
+          suggestedFix: "Increase the activation limit or deactivate unused instances.",
+          context: {
+            keyShort: attrs.key_short,
+            instancesCount: attrs.instances_count,
+            activationLimit: attrs.activation_limit
+          }
+        }
+      )
+    );
+  }
+  return issues;
+}
+
+// src/resources/products.ts
+async function getProduct(http, productId) {
+  return http.getResource(`/v1/products/${productId}`);
+}
+async function listProducts(http, storeId) {
+  return http.paginate("/v1/products", {
+    "filter[store_id]": String(storeId)
+  });
+}
+
+// src/resources/variants.ts
+async function getVariant(http, variantId) {
+  return http.getResource(`/v1/variants/${variantId}`);
+}
+async function listVariantsForProduct(http, productId) {
+  return http.paginate("/v1/variants", {
+    "filter[product_id]": String(productId)
+  });
+}
+
+// src/validate/product.ts
+async function validateProduct(http, mode, options) {
+  const issues = [];
+  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) }
+  });
+  if (!fetched.ok) {
+    issues.push(fetched.issue);
+    return buildResult("product", mode, issues, void 0, {
+      label: `product ${options.productId}`,
+      id: String(options.productId)
+    });
+  }
+  const attrs = fetched.resource.attributes;
+  issues.push(...checkProduct(attrs, { expectedStoreId: options.expectedStoreId }));
+  try {
+    const variants = await listVariantsForProduct(http, options.productId);
+    if (variants.length === 0) {
+      issues.push(
+        issue(
+          ISSUE_CODES.VARIANT_MISSING,
+          "error",
+          "Product has no variants. Customers cannot purchase it.",
+          { suggestedFix: "Add at least one variant in the product configuration." }
+        )
+      );
+    } else if (!variants.some((variant) => variant.attributes.status === "published")) {
+      issues.push(
+        issue(
+          ISSUE_CODES.VARIANT_UNPUBLISHED,
+          "error",
+          "Product has variants but none are published.",
+          { suggestedFix: "Publish at least one variant." }
+        )
+      );
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error fetching variants";
+    issues.push(issue(ISSUE_CODES.UNKNOWN, "warning", message));
+  }
+  return buildResult("product", mode, issues, attrs, {
+    label: attrs.name,
+    id: String(options.productId)
+  });
+}
+function checkProduct(attrs, options = {}) {
+  const issues = [];
+  if (options.expectedStoreId !== void 0) {
+    const mismatch = checkStoreOwnership({
+      expectedStoreId: options.expectedStoreId,
+      actualStoreId: attrs.store_id,
+      code: ISSUE_CODES.PRODUCT_WRONG_STORE,
+      label: "Product",
+      suggestedFix: "Either use the correct store ID or the correct product ID \u2014 IDs should not cross stores."
+    });
+    if (mismatch) issues.push(mismatch);
+  }
+  if (attrs.status !== "published") {
+    issues.push(
+      issue(
+        ISSUE_CODES.PRODUCT_UNPUBLISHED,
+        "error",
+        `Product is in "${attrs.status}" state, not "published".`,
+        {
+          suggestedFix: "Publish the product in the Lemon Squeezy dashboard before selling.",
+          context: { status: attrs.status }
+        }
+      )
+    );
+  }
+  if (!attrs.buy_now_url) {
+    issues.push(
+      issue(
+        ISSUE_CODES.PRODUCT_NO_BUY_URL,
+        "warning",
+        "Product has no buy-now URL. Hosted checkout may be disabled.",
+        { suggestedFix: "Enable buy-now in product settings, or use a custom checkout flow." }
+      )
+    );
+  }
+  return issues;
+}
+
+// src/validate/store.ts
+async function validateStore(http, mode, storeId) {
+  const issues = [];
+  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) }
+  });
+  if (!fetched.ok) {
+    issues.push(fetched.issue);
+    return buildResult("store", mode, issues, void 0, {
+      label: `store ${storeId}`,
+      id: String(storeId)
+    });
+  }
+  return buildResult("store", mode, issues, fetched.resource.attributes, {
+    label: fetched.resource.attributes.name,
+    id: String(storeId)
+  });
+}
+
+// src/validate/subscriptionPlan.ts
+var VALID_INTERVALS = /* @__PURE__ */ new Set(["day", "week", "month", "year"]);
+async function validateSubscriptionPlan(http, mode, options) {
+  const issues = [];
+  const fetched = await probeFetch(
+    () => getVariant(http, options.variantId),
+    {
+      notFoundCode: ISSUE_CODES.PLAN_VARIANT_NOT_FOUND,
+      notFoundMessage: `Variant ${options.variantId} not found.`,
+      notFoundFix: "Verify the variant ID in the Lemon Squeezy dashboard.",
+      notFoundContext: { variantId: String(options.variantId) }
+    }
+  );
+  if (!fetched.ok) {
+    issues.push(fetched.issue);
+    return buildResult("subscriptionPlan", mode, issues, void 0, {
+      label: `variant ${options.variantId}`,
+      id: String(options.variantId)
+    });
+  }
+  const variant = fetched.resource;
+  const attrs = variant.attributes;
+  issues.push(...checkSubscriptionPlan(attrs, { variantId: options.variantId }));
+  try {
+    const product = await getProduct(http, attrs.product_id);
+    const mismatch = checkStoreOwnership({
+      expectedStoreId: options.storeId,
+      actualStoreId: product.attributes.store_id,
+      code: ISSUE_CODES.PLAN_STORE_MISMATCH,
+      label: `Subscription variant (via product ${attrs.product_id})`,
+      suggestedFix: "Use the correct store ID or variant ID \u2014 plans should not cross stores.",
+      extraContext: { productId: String(attrs.product_id) }
+    });
+    if (mismatch) issues.push(mismatch);
+  } catch {
+  }
+  const summary = {
+    variantId: variant.id,
+    interval: attrs.interval,
+    intervalCount: attrs.interval_count,
+    price: attrs.price,
+    hasFreeTrial: attrs.has_free_trial,
+    status: attrs.status
+  };
+  return buildResult("subscriptionPlan", mode, issues, summary, {
+    label: attrs.name,
+    id: String(options.variantId)
+  });
+}
+function checkSubscriptionPlan(attrs, options) {
+  const issues = [];
+  if (!attrs.is_subscription) {
+    issues.push(
+      issue(
+        ISSUE_CODES.PLAN_NOT_SUBSCRIPTION,
+        "error",
+        `Variant ${options.variantId} is not a subscription variant (is_subscription is false).`,
+        {
+          suggestedFix: "Use a variant that has subscription billing enabled, or use the regular variant validator.",
+          context: { variantId: String(options.variantId) }
+        }
+      )
+    );
+  }
+  if (!attrs.interval || !VALID_INTERVALS.has(attrs.interval)) {
+    issues.push(
+      issue(
+        ISSUE_CODES.PLAN_INVALID_INTERVAL,
+        "error",
+        `Subscription variant has invalid interval: "${attrs.interval ?? "missing"}". Expected one of: day, week, month, year.`,
+        {
+          suggestedFix: "Set a valid billing interval in the variant configuration.",
+          context: { interval: attrs.interval ?? null }
+        }
+      )
+    );
+  }
+  if (attrs.interval_count === null || attrs.interval_count <= 0) {
+    issues.push(
+      issue(
+        ISSUE_CODES.PLAN_INVALID_INTERVAL,
+        "error",
+        `Subscription variant has invalid interval_count: ${attrs.interval_count}. Must be a positive integer.`,
+        {
+          suggestedFix: "Set interval_count to a positive value (e.g. 1 for monthly, 2 for biweekly).",
+          context: { intervalCount: attrs.interval_count }
+        }
+      )
+    );
+  }
+  if (attrs.price === 0 && attrs.is_subscription) {
+    issues.push(
+      issue(
+        ISSUE_CODES.PLAN_FREE_PRICE,
+        "warning",
+        "Subscription variant has a price of 0 \u2014 this is almost always a misconfiguration for paid plans.",
+        {
+          suggestedFix: "Set the variant price to the intended amount in cents, or confirm this is intentionally free.",
+          context: { price: attrs.price }
+        }
+      )
+    );
+  }
+  if (attrs.has_free_trial && (!attrs.trial_interval || (attrs.trial_interval_count ?? 0) <= 0)) {
+    issues.push(
+      issue(
+        ISSUE_CODES.PLAN_TRIAL_INCONSISTENT,
+        "warning",
+        `Subscription variant has free trial enabled but trial interval is misconfigured (interval: "${attrs.trial_interval ?? "missing"}", count: ${attrs.trial_interval_count ?? 0}).`,
+        {
+          suggestedFix: "Set a valid trial interval and count, or disable the free trial.",
+          context: {
+            trialInterval: attrs.trial_interval ?? null,
+            trialIntervalCount: attrs.trial_interval_count ?? null
+          }
+        }
+      )
+    );
+  }
+  if (attrs.status === "draft") {
+    issues.push(
+      issue(
+        ISSUE_CODES.PLAN_DRAFT,
+        "warning",
+        "Subscription variant is in draft status \u2014 customers cannot subscribe.",
+        {
+          suggestedFix: "Publish the variant in the Lemon Squeezy dashboard.",
+          context: { status: attrs.status }
+        }
+      )
+    );
+  }
+  return issues;
+}
+
+// src/core/equality.ts
+function sameWebhookUrl(a, b) {
+  return normalizeWebhookUrl(a) === normalizeWebhookUrl(b);
+}
+function normalizeWebhookUrl(raw) {
+  return raw.replace(/\/+$/, "").toLowerCase();
+}
+
+// src/resources/webhooks.ts
 async function listWebhooksForStore(http, storeId) {
   return http.paginate("/v1/webhooks", {
     "filter[store_id]": String(storeId)
@@ -709,447 +1064,111 @@ var ACKNOWLEDGED_CHANGELOG_ENTRIES = [
   },
   {
     date: "2024-02-12",
-    summary: "Added Generate subscription invoice endpoint and invoice_immediately / disable_prorations parameters.",
-    handledBy: "SubscriptionItemUpdateAttributes.invoice_immediately / disable_prorations; invoice endpoint reachable via client.request()."
-  },
-  {
-    date: "2024-02-05",
-    summary: "Added tax_inclusive parameter to Order objects and Subscription invoice objects.",
-    handledBy: "OrderAttributes.tax_inclusive, SubscriptionInvoiceAttributes.tax_inclusive."
-  },
-  {
-    date: "2024-01-21",
-    summary: "Added setup_fee_enabled / setup_fee to Price objects; setup_fee* to Subscription invoice.",
-    handledBy: "PriceAttributes.setup_fee*, OrderAttributes.setup_fee*."
-  },
-  {
-    date: "2024-01-15",
-    summary: "Added unit_price_decimal to Price objects.",
-    handledBy: "PriceAttributes.unit_price_decimal."
-  },
-  {
-    date: "2024-01-05",
-    summary: "Added test_mode flag to /v1/users/me meta.",
-    handledBy: "Read in validateConnection to emit MODE_MISMATCH when the key's true mode differs from the caller's declared mode."
-  },
-  {
-    date: "2023-09-19",
-    summary: "Added customer_portal URLs to Subscription and Customer objects.",
-    handledBy: "SubscriptionUrls.customer_portal and CustomerUrls.customer_portal."
-  },
-  {
-    date: "2023-08-23",
-    summary: "Added checkout_data.variant_quantities, subscription items, prices, and usage-based billing.",
-    handledBy: "CheckoutData.variant_quantities, SubscriptionItemAttributes, UsageRecordAttributes, PriceAttributes."
-  },
-  {
-    date: "2023-08-14",
-    summary: "Added customer_id, user_name, user_email to Subscription invoice objects.",
-    handledBy: "SubscriptionInvoiceAttributes customer fields."
-  },
-  {
-    date: "2023-03-30",
-    summary: "Added receipt URL to Order objects.",
-    handledBy: "OrderUrls.receipt."
-  }
-];
-
-// src/validate/webhook.ts
-async function validateWebhook(http, mode, options) {
-  const issues = [];
-  let webhooks;
-  try {
-    webhooks = await listWebhooksForStore(http, options.storeId);
-  } catch (err) {
-    if (err instanceof FreshSqueezyError) {
-      issues.push(
-        issue(ISSUE_CODES.UNKNOWN, "error", err.message, {
-          context: { status: err.status ?? null, code: err.code }
-        })
-      );
-      return buildResult("webhook", mode, issues, void 0, {
-        label: options.url,
-        url: options.url
-      });
-    }
-    const message = err instanceof Error ? err.message : "Unknown error";
-    issues.push(issue(ISSUE_CODES.UNKNOWN, "error", message));
-    return buildResult("webhook", mode, issues, void 0, {
-      label: options.url,
-      url: options.url
-    });
-  }
-  const match = webhooks.find((webhook) => sameWebhookUrl(webhook.attributes.url, options.url));
-  if (!match) {
-    issues.push(
-      issue(
-        ISSUE_CODES.WEBHOOK_NOT_FOUND,
-        "error",
-        `No webhook registered for URL ${options.url} on store ${options.storeId}.`,
-        {
-          suggestedFix: "Register the webhook in Lemon Squeezy (Settings \u2192 Webhooks) and subscribe to the recommended events.",
-          context: { storeId: String(options.storeId), url: options.url }
-        }
-      )
-    );
-    return buildResult("webhook", mode, issues, void 0, {
-      label: options.url,
-      url: options.url
-    });
-  }
-  const subscribed = new Set(match.attributes.events);
-  const missingRecommended = RECOMMENDED_WEBHOOK_EVENTS.filter((event) => !subscribed.has(event));
-  const missingOptional = OPTIONAL_WEBHOOK_EVENTS.filter((event) => !subscribed.has(event));
-  if (missingRecommended.length > 0) {
-    issues.push(
-      issue(
-        ISSUE_CODES.WEBHOOK_EVENTS_MISSING,
-        "error",
-        `Webhook is missing recommended events: ${missingRecommended.join(", ")}.`,
-        {
-          suggestedFix: "Subscribe to all recommended events so the integration survives plan changes and refunds.",
-          context: { missing: missingRecommended.join(",") }
-        }
-      )
-    );
-  }
-  if (missingOptional.length > 0) {
-    issues.push(
-      issue(
-        ISSUE_CODES.WEBHOOK_OPTIONAL_EVENTS,
-        "info",
-        `Optional events not subscribed: ${missingOptional.join(", ")}.`,
-        { context: { missing: missingOptional.join(",") } }
-      )
-    );
-  }
-  return buildResult("webhook", mode, issues, match.attributes, {
-    label: match.attributes.url,
-    id: match.id,
-    url: match.attributes.url
-  });
-}
-
-// src/resources/discounts.ts
-async function getDiscount(http, discountId) {
-  return http.getResource(`/v1/discounts/${discountId}`);
-}
-
-// src/validate/discount.ts
-async function validateDiscount(http, mode, options) {
-  const issues = [];
-  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) }
-  });
-  if (!fetched.ok) {
-    issues.push(fetched.issue);
-    return buildResult("discount", mode, issues, void 0, {
-      label: `discount ${options.discountId}`,
-      id: String(options.discountId)
-    });
-  }
-  const attrs = fetched.resource.attributes;
-  const mismatch = checkStoreOwnership({
-    expectedStoreId: options.storeId,
-    actualStoreId: attrs.store_id,
-    code: ISSUE_CODES.DISCOUNT_STORE_MISMATCH,
-    label: "Discount",
-    suggestedFix: "Use the correct store ID or discount ID \u2014 discounts should not cross stores."
-  });
-  if (mismatch) issues.push(mismatch);
-  if (attrs.status === "draft") {
-    issues.push(
-      issue(
-        ISSUE_CODES.DISCOUNT_DRAFT,
-        "warning",
-        `Discount "${attrs.name}" is in draft status \u2014 customers cannot redeem it.`,
-        {
-          suggestedFix: "Publish the discount in the Lemon Squeezy dashboard before sharing the code.",
-          context: { name: attrs.name, code: attrs.code }
-        }
-      )
-    );
-  }
-  const now = /* @__PURE__ */ new Date();
-  if (attrs.expires_at && new Date(attrs.expires_at) < now) {
-    issues.push(
-      issue(
-        ISSUE_CODES.DISCOUNT_EXPIRED,
-        "error",
-        `Discount "${attrs.name}" expired at ${attrs.expires_at}.`,
-        {
-          suggestedFix: "Extend the expiration date or create a new discount.",
-          context: { name: attrs.name, expiresAt: attrs.expires_at }
-        }
-      )
-    );
-  }
-  if (attrs.starts_at && new Date(attrs.starts_at) > now) {
-    issues.push(
-      issue(
-        ISSUE_CODES.DISCOUNT_NOT_STARTED,
-        "warning",
-        `Discount "${attrs.name}" starts at ${attrs.starts_at} \u2014 not yet active.`,
-        {
-          suggestedFix: "Wait for the start date or adjust it in the dashboard.",
-          context: { name: attrs.name, startsAt: attrs.starts_at }
-        }
-      )
-    );
-  }
-  if (attrs.is_limited_redemptions && attrs.max_redemptions <= 0) {
-    issues.push(
-      issue(
-        ISSUE_CODES.DISCOUNT_REDEMPTIONS_EXHAUSTED,
-        "warning",
-        `Discount "${attrs.name}" has limited redemptions with max_redemptions \u2264 0.`,
-        {
-          suggestedFix: "Increase max_redemptions or disable the redemption limit.",
-          context: { name: attrs.name, maxRedemptions: attrs.max_redemptions }
-        }
-      )
-    );
-  }
-  if (attrs.amount <= 0) {
-    issues.push(
-      issue(
-        ISSUE_CODES.DISCOUNT_INVALID_AMOUNT,
-        "error",
-        `Discount "${attrs.name}" has amount ${attrs.amount} \u2014 must be positive.`,
-        {
-          suggestedFix: "Set a positive discount amount in the dashboard.",
-          context: { name: attrs.name, amount: attrs.amount }
-        }
-      )
-    );
-  } else if (attrs.amount_type === "percent" && attrs.amount > 100) {
-    issues.push(
-      issue(
-        ISSUE_CODES.DISCOUNT_INVALID_AMOUNT,
-        "error",
-        `Discount "${attrs.name}" is ${attrs.amount}% \u2014 percent discounts cannot exceed 100%.`,
-        {
-          suggestedFix: "Set the discount to 100% or less.",
-          context: { name: attrs.name, amount: attrs.amount, amountType: attrs.amount_type }
-        }
-      )
-    );
+    summary: "Added Generate subscription invoice endpoint and invoice_immediately / disable_prorations parameters.",
+    handledBy: "SubscriptionItemUpdateAttributes.invoice_immediately / disable_prorations; invoice endpoint reachable via client.request()."
+  },
+  {
+    date: "2024-02-05",
+    summary: "Added tax_inclusive parameter to Order objects and Subscription invoice objects.",
+    handledBy: "OrderAttributes.tax_inclusive, SubscriptionInvoiceAttributes.tax_inclusive."
+  },
+  {
+    date: "2024-01-21",
+    summary: "Added setup_fee_enabled / setup_fee to Price objects; setup_fee* to Subscription invoice.",
+    handledBy: "PriceAttributes.setup_fee*, OrderAttributes.setup_fee*."
+  },
+  {
+    date: "2024-01-15",
+    summary: "Added unit_price_decimal to Price objects.",
+    handledBy: "PriceAttributes.unit_price_decimal."
+  },
+  {
+    date: "2024-01-05",
+    summary: "Added test_mode flag to /v1/users/me meta.",
+    handledBy: "Read in validateConnection to emit MODE_MISMATCH when the key's true mode differs from the caller's declared mode."
+  },
+  {
+    date: "2023-09-19",
+    summary: "Added customer_portal URLs to Subscription and Customer objects.",
+    handledBy: "SubscriptionUrls.customer_portal and CustomerUrls.customer_portal."
+  },
+  {
+    date: "2023-08-23",
+    summary: "Added checkout_data.variant_quantities, subscription items, prices, and usage-based billing.",
+    handledBy: "CheckoutData.variant_quantities, SubscriptionItemAttributes, UsageRecordAttributes, PriceAttributes."
+  },
+  {
+    date: "2023-08-14",
+    summary: "Added customer_id, user_name, user_email to Subscription invoice objects.",
+    handledBy: "SubscriptionInvoiceAttributes customer fields."
+  },
+  {
+    date: "2023-03-30",
+    summary: "Added receipt URL to Order objects.",
+    handledBy: "OrderUrls.receipt."
   }
-  return buildResult("discount", mode, issues, attrs, {
-    label: `${attrs.name} (${attrs.code})`,
-    id: String(options.discountId)
-  });
-}
-
-// src/resources/licenseKeys.ts
-async function getLicenseKey(http, licenseKeyId) {
-  return http.getResource(`/v1/license-keys/${licenseKeyId}`);
-}
+];
 
-// src/validate/licenseKey.ts
-async function validateLicenseKey(http, mode, options) {
+// src/validate/webhook.ts
+async function validateWebhook(http, mode, options) {
   const issues = [];
-  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 probeCollection(() => listWebhooksForStore(http, options.storeId));
   if (!fetched.ok) {
     issues.push(fetched.issue);
-    return buildResult("licenseKey", mode, issues, void 0, {
-      label: `license key ${options.licenseKeyId}`,
-      id: String(options.licenseKeyId)
+    return buildResult("webhook", mode, issues, void 0, {
+      label: options.url,
+      url: options.url
     });
   }
-  const attrs = fetched.resource.attributes;
-  const mismatch = checkStoreOwnership({
-    expectedStoreId: options.storeId,
-    actualStoreId: attrs.store_id,
-    code: ISSUE_CODES.LICENSE_KEY_STORE_MISMATCH,
-    label: "License key",
-    suggestedFix: "Use the correct store ID or license key ID \u2014 keys should not cross stores."
-  });
-  if (mismatch) issues.push(mismatch);
-  if (attrs.disabled) {
-    issues.push(
-      issue(
-        ISSUE_CODES.LICENSE_KEY_DISABLED,
-        "error",
-        `License key ${attrs.key_short} is disabled.`,
-        {
-          suggestedFix: "Re-enable the license key in the Lemon Squeezy dashboard.",
-          context: { keyShort: attrs.key_short }
-        }
-      )
-    );
-  }
-  if (attrs.expires_at && new Date(attrs.expires_at) < /* @__PURE__ */ new Date()) {
+  const webhooks = fetched.resource;
+  const match = webhooks.find((webhook) => sameWebhookUrl(webhook.attributes.url, options.url));
+  if (!match) {
     issues.push(
       issue(
-        ISSUE_CODES.LICENSE_KEY_EXPIRED,
+        ISSUE_CODES.WEBHOOK_NOT_FOUND,
         "error",
-        `License key ${attrs.key_short} expired at ${attrs.expires_at}.`,
-        {
-          suggestedFix: "Extend the expiration date or issue a new license key.",
-          context: { keyShort: attrs.key_short, expiresAt: attrs.expires_at }
-        }
-      )
-    );
-  }
-  if (attrs.activation_limit !== null && attrs.instances_count >= attrs.activation_limit) {
-    issues.push(
-      issue(
-        ISSUE_CODES.LICENSE_KEY_AT_ACTIVATION_LIMIT,
-        "warning",
-        `License key ${attrs.key_short} has reached its activation limit (${attrs.instances_count}/${attrs.activation_limit}).`,
+        `No webhook registered for URL ${options.url} on store ${options.storeId}.`,
         {
-          suggestedFix: "Increase the activation limit or deactivate unused instances.",
-          context: {
-            keyShort: attrs.key_short,
-            instancesCount: attrs.instances_count,
-            activationLimit: attrs.activation_limit
-          }
+          suggestedFix: "Register the webhook in Lemon Squeezy (Settings \u2192 Webhooks) and subscribe to the recommended events.",
+          context: { storeId: String(options.storeId), url: options.url }
         }
       )
     );
-  }
-  return buildResult("licenseKey", mode, issues, attrs, {
-    label: attrs.key_short,
-    id: String(options.licenseKeyId)
-  });
-}
-
-// src/validate/subscriptionPlan.ts
-var VALID_INTERVALS = /* @__PURE__ */ new Set(["day", "week", "month", "year"]);
-async function validateSubscriptionPlan(http, mode, options) {
-  const issues = [];
-  const fetched = await probeFetch(
-    () => getVariant(http, options.variantId),
-    {
-      notFoundCode: ISSUE_CODES.PLAN_VARIANT_NOT_FOUND,
-      notFoundMessage: `Variant ${options.variantId} not found.`,
-      notFoundFix: "Verify the variant ID in the Lemon Squeezy dashboard.",
-      notFoundContext: { variantId: String(options.variantId) }
-    }
-  );
-  if (!fetched.ok) {
-    issues.push(fetched.issue);
-    return buildResult("subscriptionPlan", mode, issues, void 0, {
-      label: `variant ${options.variantId}`,
-      id: String(options.variantId)
+    return buildResult("webhook", mode, issues, void 0, {
+      label: options.url,
+      url: options.url
     });
   }
-  const variant = fetched.resource;
-  const attrs = variant.attributes;
-  if (!attrs.is_subscription) {
-    issues.push(
-      issue(
-        ISSUE_CODES.PLAN_NOT_SUBSCRIPTION,
-        "error",
-        `Variant ${options.variantId} is not a subscription variant (is_subscription is false).`,
-        {
-          suggestedFix: "Use a variant that has subscription billing enabled, or use the regular variant validator.",
-          context: { variantId: String(options.variantId) }
-        }
-      )
-    );
-  }
-  if (!attrs.interval || !VALID_INTERVALS.has(attrs.interval)) {
-    issues.push(
-      issue(
-        ISSUE_CODES.PLAN_INVALID_INTERVAL,
-        "error",
-        `Subscription variant has invalid interval: "${attrs.interval ?? "missing"}". Expected one of: day, week, month, year.`,
-        {
-          suggestedFix: "Set a valid billing interval in the variant configuration.",
-          context: { interval: attrs.interval ?? null }
-        }
-      )
-    );
-  }
-  if (attrs.interval_count === null || attrs.interval_count <= 0) {
+  const subscribed = new Set(match.attributes.events);
+  const missingRecommended = RECOMMENDED_WEBHOOK_EVENTS.filter((event) => !subscribed.has(event));
+  const missingOptional = OPTIONAL_WEBHOOK_EVENTS.filter((event) => !subscribed.has(event));
+  if (missingRecommended.length > 0) {
     issues.push(
       issue(
-        ISSUE_CODES.PLAN_INVALID_INTERVAL,
+        ISSUE_CODES.WEBHOOK_EVENTS_MISSING,
         "error",
-        `Subscription variant has invalid interval_count: ${attrs.interval_count}. Must be a positive integer.`,
-        {
-          suggestedFix: "Set interval_count to a positive value (e.g. 1 for monthly, 2 for biweekly).",
-          context: { intervalCount: attrs.interval_count }
-        }
-      )
-    );
-  }
-  if (attrs.price === 0 && attrs.is_subscription) {
-    issues.push(
-      issue(
-        ISSUE_CODES.PLAN_FREE_PRICE,
-        "warning",
-        `Subscription variant has a price of 0 \u2014 this is almost always a misconfiguration for paid plans.`,
-        {
-          suggestedFix: "Set the variant price to the intended amount in cents, or confirm this is intentionally free.",
-          context: { price: attrs.price }
-        }
-      )
-    );
-  }
-  if (attrs.has_free_trial && (!attrs.trial_interval || (attrs.trial_interval_count ?? 0) <= 0)) {
-    issues.push(
-      issue(
-        ISSUE_CODES.PLAN_TRIAL_INCONSISTENT,
-        "warning",
-        `Subscription variant has free trial enabled but trial interval is misconfigured (interval: "${attrs.trial_interval ?? "missing"}", count: ${attrs.trial_interval_count ?? 0}).`,
+        `Webhook is missing recommended events: ${missingRecommended.join(", ")}.`,
         {
-          suggestedFix: "Set a valid trial interval and count, or disable the free trial.",
-          context: {
-            trialInterval: attrs.trial_interval ?? null,
-            trialIntervalCount: attrs.trial_interval_count ?? null
-          }
+          suggestedFix: "Subscribe to all recommended events so the integration survives plan changes and refunds.",
+          context: { missing: missingRecommended.join(",") }
         }
       )
     );
   }
-  if (attrs.status === "draft") {
+  if (missingOptional.length > 0) {
     issues.push(
       issue(
-        ISSUE_CODES.PLAN_DRAFT,
-        "warning",
-        `Subscription variant is in draft status \u2014 customers cannot subscribe.`,
-        {
-          suggestedFix: "Publish the variant in the Lemon Squeezy dashboard.",
-          context: { status: attrs.status }
-        }
+        ISSUE_CODES.WEBHOOK_OPTIONAL_EVENTS,
+        "info",
+        `Optional events not subscribed: ${missingOptional.join(", ")}.`,
+        { context: { missing: missingOptional.join(",") } }
       )
     );
   }
-  try {
-    const product = await getProduct(http, attrs.product_id);
-    const mismatch = checkStoreOwnership({
-      expectedStoreId: options.storeId,
-      actualStoreId: product.attributes.store_id,
-      code: ISSUE_CODES.PLAN_STORE_MISMATCH,
-      label: `Subscription variant (via product ${attrs.product_id})`,
-      suggestedFix: "Use the correct store ID or variant ID \u2014 plans should not cross stores.",
-      extraContext: { productId: String(attrs.product_id) }
-    });
-    if (mismatch) issues.push(mismatch);
-  } catch {
-  }
-  const summary = {
-    variantId: variant.id,
-    interval: attrs.interval,
-    intervalCount: attrs.interval_count,
-    price: attrs.price,
-    hasFreeTrial: attrs.has_free_trial,
-    status: attrs.status
-  };
-  return buildResult("subscriptionPlan", mode, issues, summary, {
-    label: attrs.name,
-    id: String(options.variantId)
+  return buildResult("webhook", mode, issues, match.attributes, {
+    label: match.attributes.url,
+    id: match.id,
+    url: match.attributes.url
   });
 }
 
@@ -1430,6 +1449,10 @@ async function listUsageRecordsForSubscriptionItem(http, subscriptionItemId) {
   SUPPORTED_RESOURCES,
   buildResult,
   buildSubscriptionItemUpdateBody,
+  checkDiscount,
+  checkLicenseKey,
+  checkProduct,
+  checkSubscriptionPlan,
   createFreshSqueezy,
   doctor,
   fetchActualMode,
@@ -1471,7 +1494,11 @@ async function listUsageRecordsForSubscriptionItem(http, subscriptionItemId) {
   sameWebhookUrl,
   userResource,
   validateConnection,
+  validateDiscount,
+  validateLicenseKey,
   validateProduct,
+  validateStore,
+  validateSubscriptionPlan,
   validateWebhook
 });
 //# sourceMappingURL=index.cjs.map