@jskit-ai/payments-core 0.1.61 → 0.1.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/payments-core",
-  "version": "0.1.61",
+  "version": "0.1.62",
   "type": "module",
   "description": "Application-owned payment configuration, subscription access and transactional usage credits.",
   "exports": {

package/src/server/catalogue.js

@@ -1,7 +1,6 @@
-import { createHash, randomUUID } from "node:crypto";
-import { PaymentError } from "./service.js";
+import { randomUUID } from "node:crypto";
+import { PaymentError, fingerprint } from "./errors.js";
 
-const fingerprint = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
 const priceFields = (plan) => ({ amount: plan.amount, currency: plan.currency, interval: plan.interval });
 const samePrice = (a, b) => fingerprint(priceFields(a)) === fingerprint(priceFields(b));
 

package/src/server/checkout.js

@@ -1,5 +1,5 @@
-import { createHash, randomUUID } from "node:crypto";
-import { PaymentError } from "./service.js";
+import { randomUUID } from "node:crypto";
+import { PaymentError, fingerprint } from "./errors.js";
 
 // Application composition boundary: authorization is mandatory and supplied by
 // the app's framework. Actor and subject must come from its authenticated route.
@@ -43,7 +43,7 @@ function createPaymentCheckoutService({ adapter, store, payments, merchantScope,
     adapter.validatePlan(planId);
     if (typeof requestId !== "string" || !/^[A-Za-z0-9_-]{1,100}$/.test(requestId)) throw new PaymentError("payment_request_invalid", "Supply a stable checkout request identifier.");
     if (typeof email !== "string" || email.length > 320 || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) throw new PaymentError("payment_input_invalid", "Supply the authenticated billing contact's email.");
-    const identity = createHash("sha256").update(JSON.stringify(scope)).digest("hex");
+    const identity = fingerprint(scope);
     const customerId = await perform(scope, async (tx) => tx.state.customerId
       ? { cached: true, result: tx.state.customerId }
       : { action: "customer", email },
@@ -62,7 +62,7 @@ function createPaymentCheckoutService({ adapter, store, payments, merchantScope,
       }
       return { action: "checkout", customerId, planId, requestId };
     }, () => adapter.createCheckout({ customerId, planId, returnUrl: target.href,
-      requestId: `checkout-${createHash("sha256").update(JSON.stringify([scope, requestId])).digest("hex")}` }),
+      requestId: `checkout-${fingerprint([scope, requestId])}` }),
     async (tx, result) => { await tx.record(`checkout:${requestId}`, { planId, result }); return result; });
   }
   async function account({ actor, subjectId }) {

package/src/server/errors.js

@@ -0,0 +1,15 @@
+import { createHash } from "node:crypto";
+
+class PaymentError extends Error {
+  constructor(code, message, statusCode = 422) {
+    super(message);
+    this.name = "PaymentError";
+    this.code = code;
+    this.statusCode = statusCode;
+  }
+}
+
+// Stable sha256 hex of a JSON value: idempotency digests, review IDs and store keys.
+const fingerprint = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+
+export { PaymentError, fingerprint };

package/src/server/knexStore.js

@@ -1,6 +1,5 @@
-import { createHash } from "node:crypto";
+import { PaymentError, fingerprint } from "./errors.js";
 
-const hash = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
 const empty = () => ({ lots: [], subscriptions: {} });
 
 function merchant(scope) {
@@ -15,7 +14,7 @@ function identifier(value) {
   if (typeof value !== "string" || !value || value.length > 200) throw new TypeError("Payment identity is required (maximum 200 characters).");
   return value;
 }
-const accountKey = (scope) => hash([...merchant(scope), identifier(scope.subjectId)]);
+const accountKey = (scope) => fingerprint([...merchant(scope), identifier(scope.subjectId)]);
 
 function createKnexPaymentStore({ knex }) {
   if (typeof knex !== "function" || typeof knex.transaction !== "function") throw new TypeError("Supply the application's transactional Knex client.");
@@ -35,11 +34,11 @@ function createKnexPaymentStore({ knex }) {
       const result = await work({
         state,
         async find(reference) {
-          const entry = await trx("payment_entries").where({ entry_key: hash([key, identifier(reference)]) }).first();
+          const entry = await trx("payment_entries").where({ entry_key: fingerprint([key, identifier(reference)]) }).first();
           return entry ? JSON.parse(entry.payload) : null;
         },
         async record(reference, payload) {
-          await trx("payment_entries").insert({ entry_key: hash([key, identifier(reference)]), account_key: key, payload: JSON.stringify(payload) });
+          await trx("payment_entries").insert({ entry_key: fingerprint([key, identifier(reference)]), account_key: key, payload: JSON.stringify(payload) });
         }
       });
       await trx("payment_accounts").where({ account_key: key }).update({ payload: JSON.stringify(state) });
@@ -47,25 +46,25 @@ function createKnexPaymentStore({ knex }) {
     });
   }
   async function bindCustomer(scope, customerId, subjectId) {
-    const key = hash([...merchant(scope), identifier(customerId)]);
+    const key = fingerprint([...merchant(scope), identifier(customerId)]);
     identifier(subjectId);
     await knex.transaction(async (trx) => {
       await trx("payment_customers").insert({ customer_key: key, subject_id: subjectId })
         .onConflict("customer_key").merge({ customer_key: key });
       const row = await trx("payment_customers").where({ customer_key: key }).first();
-      if (row.subject_id !== subjectId) throw new Error("This provider customer is already bound to a different billable subject.");
+      if (row.subject_id !== subjectId) throw new PaymentError("payment_customer_conflict", "This provider customer is already bound to a different billable subject.", 409);
     });
   }
   async function resolveCustomer(scope, customerId) {
-    const row = await knex("payment_customers").where({ customer_key: hash([...merchant(scope), identifier(customerId)]) }).first();
+    const row = await knex("payment_customers").where({ customer_key: fingerprint([...merchant(scope), identifier(customerId)]) }).first();
     return row?.subject_id ?? null;
   }
   async function inspectCatalogue(scope) {
-    const row = await knex("payment_catalogues").where({ catalogue_key: hash(merchant(scope)) }).first();
+    const row = await knex("payment_catalogues").where({ catalogue_key: fingerprint(merchant(scope)) }).first();
     return row ? JSON.parse(row.payload) : { plans: {}, history: [] };
   }
   async function withCatalogue(scope, work) {
-    const key = hash(merchant(scope));
+    const key = fingerprint(merchant(scope));
     return knex.transaction(async (trx) => {
       await trx("payment_catalogues").insert({ catalogue_key: key, payload: JSON.stringify({ plans: {}, history: [] }) })
         .onConflict("catalogue_key").merge({ catalogue_key: key });

package/src/server/paddle.js

@@ -1,20 +1,12 @@
 import { Paddle, Environment } from "@paddle/paddle-node-sdk";
-import { PaymentError } from "./service.js";
+import { PaymentError } from "./errors.js";
+import { createPriceBindings } from "./priceBindings.js";
 
 const invalid = () => { throw new PaymentError("payment_provider_result_invalid", "Check the Paddle account, price mapping and subscription shape.", 502); };
 
 function createPaddlePaymentAdapter({ apiKey, webhookSecret, environment, priceBindings, taxCategory, historicalPriceBindings = {}, client = new Paddle(apiKey, { environment: environment === "live" ? Environment.production : Environment.sandbox }) }) {
   if (!["sandbox", "live"].includes(environment) || typeof webhookSecret !== "string" || !webhookSecret) throw new TypeError("Supply Paddle credentials and environment.");
-  const prices = structuredClone(priceBindings);
-  const planFor = (priceId) => {
-    const matches = Object.entries(prices).filter(([, value]) => value === priceId);
-    if (!matches.length && Object.hasOwn(historicalPriceBindings, priceId)) return historicalPriceBindings[priceId];
-    if (matches.length !== 1) invalid();
-    return matches[0][0];
-  };
-  function validatePlan(planId) {
-    if (!Object.hasOwn(prices, planId)) throw new PaymentError("payment_plan_unknown", "Select a published payment plan.");
-  }
+  const { validatePlan, priceFor, planFor } = createPriceBindings({ priceBindings, historicalPriceBindings, invalid });
   async function verifyAccount() {
     await client.products.list({ perPage: 1 }).next();
     // A successful catalogue read cannot prove merchant verification or identify
@@ -61,10 +53,10 @@ function createPaddlePaymentAdapter({ apiKey, webhookSecret, environment, priceB
     return customer.id;
   }
   async function createCheckout({ customerId, planId, returnUrl }) {
-    if (!Object.hasOwn(prices, planId)) throw new PaymentError("payment_plan_unknown", "Select a published payment plan.");
+    const priceId = priceFor(planId);
     // This URL is an app-owned Paddle.js checkout page, approved in Paddle.
     const result = await client.transactions.create({ customerId, collectionMode: "automatic",
-      items: [{ priceId: prices[planId], quantity: 1 }], checkout: { url: returnUrl } });
+      items: [{ priceId, quantity: 1 }], checkout: { url: returnUrl } });
     if (typeof result.checkout?.url !== "string") invalid();
     return { id: result.id, url: result.checkout.url };
   }

package/src/server/priceBindings.js

@@ -0,0 +1,23 @@
+import { PaymentError } from "./errors.js";
+
+// Plan-to-price bindings shared by the provider adapters. `invalid` throws the
+// adapter's own provider-result error for an unknown or ambiguous price.
+function createPriceBindings({ priceBindings, historicalPriceBindings = {}, invalid }) {
+  const prices = structuredClone(priceBindings);
+  function validatePlan(planId) {
+    if (!Object.hasOwn(prices, planId)) throw new PaymentError("payment_plan_unknown", "Select a published payment plan.");
+  }
+  function priceFor(planId) {
+    validatePlan(planId);
+    return prices[planId];
+  }
+  function planFor(priceId) {
+    const matches = Object.entries(prices).filter(([, value]) => value === priceId);
+    if (!matches.length && Object.hasOwn(historicalPriceBindings, priceId)) return historicalPriceBindings[priceId];
+    if (matches.length !== 1) invalid();
+    return matches[0][0];
+  }
+  return { validatePlan, priceFor, planFor };
+}
+
+export { createPriceBindings };

package/src/server/readiness.js

@@ -1,4 +1,18 @@
-import { PaymentError } from "./service.js";
+import { PaymentError } from "./errors.js";
+
+const DEFAULT_CHECKS = Object.freeze([
+  { id: "credentials", status: "unknown", detail: "Check the provider credentials for this environment." },
+  { id: "account", status: "unknown", detail: "Confirm the configured merchant owns these credentials." },
+  { id: "charges", status: "manual", detail: "Confirm payment acceptance is enabled in the provider dashboard." },
+  { id: "payouts", status: "manual", detail: "Confirm payout eligibility in the provider dashboard." },
+  { id: "catalogue", status: "unknown", detail: "Inspect the saved products and prices." },
+  { id: "webhook", status: "unknown", detail: "Verify the deployed webhook route, signing secret and subscribed events." },
+  { id: "checkout", status: "unknown", detail: "Verify app checkout and portal routes, authorization and return handling." },
+  { id: "site", status: "manual", detail: "Review required site content and provider domain or website approval." },
+  { id: "deployment", status: "unknown", detail: "Verify the intended release uses this configuration and environment." }
+]);
+// Only these checks take their result from the application's own evidence.
+const APPLICATION_CHECKS = ["webhook", "checkout", "site", "deployment"];
 
 // App-server inspection, invoked only after the host authorizes management.
 // Missing app evidence stays unknown; provider errors never become display text.
@@ -6,56 +20,48 @@ function createPaymentReadiness({ adapter, catalogue, scope, inspectApplication
   const merchant = structuredClone(scope);
   if (!["sandbox", "live"].includes(merchant?.environment) || !merchant.providerAccountId) throw new TypeError("Supply the configured payment merchant scope.");
   async function inspect() {
-    const checks = [
-      { id: "credentials", status: "unknown", detail: "Check the provider credentials for this environment." },
-      { id: "account", status: "unknown", detail: "Confirm the configured merchant owns these credentials." },
-      { id: "charges", status: "manual", detail: "Confirm payment acceptance is enabled in the provider dashboard." },
-      { id: "payouts", status: "manual", detail: "Confirm payout eligibility in the provider dashboard." },
-      { id: "catalogue", status: "unknown", detail: "Inspect the saved products and prices." },
-      { id: "webhook", status: "unknown", detail: "Verify the deployed webhook route, signing secret and subscribed events." },
-      { id: "checkout", status: "unknown", detail: "Verify app checkout and portal routes, authorization and return handling." },
-      { id: "site", status: "manual", detail: "Review required site content and provider domain or website approval." },
-      { id: "deployment", status: "unknown", detail: "Verify the intended release uses this configuration and environment." }
-    ];
+    const checks = new Map(DEFAULT_CHECKS.map((check) => [check.id, { ...check }]));
+    const set = (id, status, detail) => Object.assign(checks.get(id), { status, detail });
     let provider;
     try { provider = await adapter.verifyAccount(); }
-    catch { checks[0] = { id: "credentials", status: "failed", detail: "Provider verification failed. Check the account, credentials and environment." }; }
+    catch { set("credentials", "failed", "Provider verification failed. Check the account, credentials and environment."); }
     if (provider) {
       if (provider.environment !== merchant.environment || (provider.accountId && provider.accountId !== merchant.providerAccountId)) {
         throw new PaymentError("payment_scope_invalid", "Readiness returned a different payment account or environment.", 403);
       }
       const verified = provider.credentialsVerified === true || provider.accountId === merchant.providerAccountId;
-      checks[0] = { id: "credentials", status: verified ? "passed" : "unknown", detail: verified
-        ? "The provider accepted credential verification for this environment." : "The provider returned no affirmative credential verification." };
-      checks[1] = { id: "account", status: provider.accountId === merchant.providerAccountId ? "passed" : "manual",
-        detail: provider.accountId === merchant.providerAccountId ? "The provider account matches the saved merchant identity." : "This provider check does not establish merchant identity. Confirm it in the provider dashboard." };
-      for (const [index, property] of [[2, "chargesEnabled"], [3, "payoutsEnabled"]]) {
-        if (typeof provider[property] === "boolean") checks[index] = { id: checks[index].id, status: provider[property] ? "passed" : "failed",
-          detail: `The provider reports ${checks[index].id} ${provider[property] ? "enabled" : "not enabled"}.` };
+      set("credentials", verified ? "passed" : "unknown", verified
+        ? "The provider accepted credential verification for this environment." : "The provider returned no affirmative credential verification.");
+      const accountMatches = provider.accountId === merchant.providerAccountId;
+      set("account", accountMatches ? "passed" : "manual", accountMatches
+        ? "The provider account matches the saved merchant identity." : "This provider check does not establish merchant identity. Confirm it in the provider dashboard.");
+      for (const [id, property] of [["charges", "chargesEnabled"], ["payouts", "payoutsEnabled"]]) {
+        if (typeof provider[property] === "boolean") {
+          set(id, provider[property] ? "passed" : "failed", `The provider reports ${id} ${provider[property] ? "enabled" : "not enabled"}.`);
+        }
       }
       try {
         const review = await catalogue.preview();
         if (review.environment !== merchant.environment || review.providerAccountId !== merchant.providerAccountId) throw new Error("scope");
         const unresolved = Boolean(review.pending || review.changes.length || review.drift.length || review.removed.length);
-        checks[4] = { id: "catalogue", status: unresolved ? "failed" : "passed",
-          detail: unresolved ? "Catalogue changes, drift, removed plans or an unresolved write need review." : "Saved plans match their published provider products and prices." };
-      } catch { checks[4] = { id: "catalogue", status: "failed", detail: "Catalogue inspection failed. Review the application's catalogue command and provider access." }; }
+        set("catalogue", unresolved ? "failed" : "passed",
+          unresolved ? "Catalogue changes, drift, removed plans or an unresolved write need review." : "Saved plans match their published provider products and prices.");
+      } catch { set("catalogue", "failed", "Catalogue inspection failed. Review the application's catalogue command and provider access."); }
     }
     if (inspectApplication) {
       let evidence;
       try { evidence = await inspectApplication(); } catch { evidence = {}; }
-      for (const check of checks.slice(5)) {
-        const value = evidence?.[check.id];
+      for (const id of APPLICATION_CHECKS) {
+        const value = evidence?.[id];
         if (value === undefined) continue;
         if (!value || !["passed", "failed", "unknown", "manual"].includes(value.status) || typeof value.detail !== "string" ||
           !value.detail.trim() || value.detail.length > 500 || /[\p{Cc}\p{Cf}]/u.test(value.detail)) {
           throw new PaymentError("payment_readiness_invalid", "App readiness checks must return bounded status and safe explanatory text.");
         }
-        check.status = value.status;
-        check.detail = value.detail;
+        set(id, value.status, value.detail);
       }
     }
-    return { paymentEnvironment: merchant.environment, providerAccountId: merchant.providerAccountId, checks };
+    return { paymentEnvironment: merchant.environment, providerAccountId: merchant.providerAccountId, checks: [...checks.values()] };
   }
   return Object.freeze({ inspect });
 }

package/src/server/service.js

@@ -1,12 +1,5 @@
-import { createHash } from "node:crypto";
+import { PaymentError, fingerprint } from "./errors.js";
 
-class PaymentError extends Error {
-  constructor(code, message, statusCode = 422) {
-    super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-  }
-}
 const fail = (code, message, status) => { throw new PaymentError(code, message, status); };
 function reference(value) {
   if (typeof value !== "string" || !value || value.length > 150 || ["__proto__", "constructor", "prototype"].includes(value)) fail("payment_input_invalid", "Use a nonempty business reference of at most 150 characters.");
@@ -20,7 +13,6 @@ function timestamp(value) {
   if (!Number.isSafeInteger(value) || value < 0) fail("payment_input_invalid", "Use an integer UTC timestamp in milliseconds.");
   return value;
 }
-const fingerprint = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
 const unexpired = (lot, now) => lot.expiresAt === null || lot.expiresAt > now;
 const available = (lots, now) => lots.reduce((sum, lot) => sum + (unexpired(lot, now) ? lot.remaining : 0), 0);
 

package/src/server/stripe.js

@@ -1,5 +1,6 @@
 import Stripe from "stripe";
-import { PaymentError } from "./service.js";
+import { PaymentError } from "./errors.js";
+import { createPriceBindings } from "./priceBindings.js";
 
 const id = (value) => typeof value === "string" ? value : value?.id;
 const invalid = () => { throw new PaymentError("payment_provider_result_invalid", "Check the Stripe account, price mapping and subscription shape.", 502); };
@@ -7,16 +8,7 @@ const invalid = () => { throw new PaymentError("payment_provider_result_invalid"
 function createStripePaymentAdapter({ apiKey, webhookSecret, environment, providerAccountId, priceBindings, historicalPriceBindings = {}, client = new Stripe(apiKey, { maxNetworkRetries: 0 }) }) {
   if (!["sandbox", "live"].includes(environment) || typeof webhookSecret !== "string" || !webhookSecret || !providerAccountId) throw new TypeError("Supply Stripe credentials, environment and account identity.");
   const live = environment === "live";
-  const prices = structuredClone(priceBindings);
-  const planFor = (priceId) => {
-    const matches = Object.entries(prices).filter(([, value]) => value === priceId);
-    if (!matches.length && Object.hasOwn(historicalPriceBindings, priceId)) return historicalPriceBindings[priceId];
-    if (matches.length !== 1) invalid();
-    return matches[0][0];
-  };
-  function validatePlan(planId) {
-    if (!Object.hasOwn(prices, planId)) throw new PaymentError("payment_plan_unknown", "Select a published payment plan.");
-  }
+  const { validatePlan, priceFor, planFor } = createPriceBindings({ priceBindings, historicalPriceBindings, invalid });
   async function verifyAccount() {
     const account = await client.accounts.retrieve();
     const balance = await client.balance.retrieve();
@@ -76,10 +68,10 @@ function createStripePaymentAdapter({ apiKey, webhookSecret, environment, provid
     return customer.id;
   }
   async function createCheckout({ customerId, planId, returnUrl, requestId }) {
-    if (!Object.hasOwn(prices, planId)) throw new PaymentError("payment_plan_unknown", "Select a published payment plan.");
+    const price = priceFor(planId);
     await verifyAccount();
     const result = await client.checkout.sessions.create({ mode: "subscription", customer: customerId,
-      line_items: [{ price: prices[planId], quantity: 1 }], success_url: returnUrl, cancel_url: returnUrl
+      line_items: [{ price, quantity: 1 }], success_url: returnUrl, cancel_url: returnUrl
     }, { idempotencyKey: requestId });
     if (typeof result.url !== "string") invalid();
     return { id: result.id, url: result.url };

package/src/shared/configuration.js

@@ -3,19 +3,21 @@ import schema from "../../contracts/configuration.schema.json" with { type: "jso
 
 const validate = new Ajv({ allErrors: true, strict: true }).compile(schema);
 
+function configurationError(message, fieldErrors) {
+  return Object.assign(new Error(message), { code: "payment_configuration_invalid", statusCode: 422, fieldErrors });
+}
+
 function validatePaymentConfiguration(document) {
   const value = document?.extensions?.payments;
   if (!validate(value)) {
-    const error = new Error("Check the application's payment configuration.");
-    error.code = "payment_configuration_invalid";
-    error.statusCode = 422;
-    error.fieldErrors = validate.errors.map(({ instancePath, message }) => ({ path: `extensions.payments${instancePath}`, message }));
-    throw error;
+    throw configurationError("Check the application's payment configuration.",
+      validate.errors.map(({ instancePath, message }) => ({ path: `extensions.payments${instancePath}`, message })));
   }
+  // Report every environment's binding problems at once, like the schema stage.
+  const fieldErrors = [];
   for (const [environment, binding] of Object.entries(value.environments)) {
     const slot = document.integrations?.[binding.integrationId];
     const path = `extensions.payments/environments/${environment}`;
-    const fieldErrors = [];
     if (!slot || !["stripe", "paddle"].includes(slot.provider) || slot.accountMode !== "shared" ||
         slot.authentication?.method !== "api-key" || !/^env:[A-Z_][A-Z0-9_]*$/.test(slot.authentication.secretRef || "")) {
       fieldErrors.push({ path: `${path}/integrationId`, message: `Select a shared Stripe or Paddle connection with a backend API-key Env reference for ${environment}.` });
@@ -25,14 +27,8 @@ function validatePaymentConfiguration(document) {
       if (!binding.taxCategory) fieldErrors.push({ path: `${path}/taxCategory`, message: "Choose the Paddle tax category for the products this app sells." });
       if (!binding.publicClientTokenRef) fieldErrors.push({ path: `${path}/publicClientTokenRef`, message: "Set the Env reference for this environment's Paddle public client token." });
     }
-    if (fieldErrors.length) {
-      const error = new Error(fieldErrors[0].message);
-      error.code = "payment_configuration_invalid";
-      error.statusCode = 422;
-      error.fieldErrors = fieldErrors;
-      throw error;
-    }
   }
+  if (fieldErrors.length) throw configurationError(fieldErrors[0].message, fieldErrors);
   // The validated declaration is JSON data; callers may supply reactive proxies.
   return JSON.parse(JSON.stringify(value));
 }

package/test/service.test.js

@@ -36,6 +36,21 @@ test("portable configuration rejects secret literals, invalid prices and mismatc
   }
 });
 
+test("configuration reports binding problems in every environment at once", () => {
+  const value = structuredClone(document);
+  value.integrations.billing.accountMode = "per-user";
+  value.integrations.production.authentication.secretRef = "sk_live_pasted";
+  assert.throws(() => validatePaymentConfiguration(value), (error) => {
+    assert.equal(error.code, "payment_configuration_invalid");
+    assert.equal(error.statusCode, 422);
+    assert.deepEqual(error.fieldErrors.map(({ path }) => path), [
+      "extensions.payments/environments/sandbox/integrationId", "extensions.payments/environments/live/integrationId"
+    ]);
+    assert.equal(error.message, error.fieldErrors[0].message);
+    return true;
+  });
+});
+
 test("configuration accepts reactive objects and returns an independent plain snapshot", () => {
   const input = structuredClone(document);
   input.extensions.payments = new Proxy(input.extensions.payments, {});
@@ -84,7 +99,7 @@ test("transactional payment state isolates subjects, grants once, prevents overs
     });
     await t.test("customer bindings cannot be stolen or resolved across environments", async () => {
       await store.bindCustomer(scope, "cus_a", "tenant-a");
-      await assert.rejects(store.bindCustomer(scope, "cus_a", "tenant-b"), /already bound/);
+      await assert.rejects(store.bindCustomer(scope, "cus_a", "tenant-b"), { name: "PaymentError", code: "payment_customer_conflict", statusCode: 409, message: /already bound/ });
       await assert.rejects(service.reconcileEvent(scope, { eventId: "evt_unbound", customerId: "cus_b", load: async () => {} }), { code: "payment_customer_unbound" });
     });
     await t.test("event failure rolls back; retries grant once per renewal rather than event", async () => {