@go-avro/avro-js 0.0.50 → 0.0.51

package/dist/billing/fees.d.ts

@@ -2,7 +2,7 @@ import { PaymentType } from '../types/api/PaymentType';
 export interface PassOnFeeBreakdown {
     /** Stripe processing fee on the grossed-up amount, in cents. */
     stripeFee: number;
-    /** Avro application fee on the net (gross - stripeFee), in cents. */
+    /** Avro application fee on the grossed-up amount, in cents. */
     avroFee: number;
     /** Total fee added on top of the subtotal: stripeFee + avroFee. */
     totalFee: number;
@@ -15,9 +15,13 @@ export interface PassOnFeeBreakdown {
  */
 export declare function computeStripeFee(grossCents: number, method: PaymentType): number;
 /**
- * Compute Avro's application fee on a net amount (gross - stripeFee), in cents.
+ * Compute Avro's application fee on a gross amount, in cents.
+ *
+ * Avro's fee is now computed against the gross (matching Stripe's basis)
+ * rather than the post-Stripe net. This keeps the pass-on gross-up
+ * exactly solvable in closed form.
  */
-export declare function computeAvroFee(netCents: number): number;
+export declare function computeAvroFee(grossCents: number): number;
 /**
  * Compute the pass-on fee (in cents) such that, after Stripe and Avro deduct
  * their fees from the gross amount the customer is charged, the merchant
@@ -28,8 +32,7 @@ export declare function computeAvroFee(netCents: number): number;
  * Closed form: a finite set of candidate grosses is derived from each fee
  * regime (avro at the 5¢ floor vs. percentage; ACH stripe at the $5 cap vs.
  * percentage). The smallest candidate that satisfies the invariant
- * `gross - stripeFee(gross) - avroFee(gross - stripeFee(gross)) >= subtotal`
- * is selected. No iteration.
+ * `gross - stripeFee(gross) - avroFee(gross) >= subtotal` is selected.
  */
 export declare function computePassOnFee(subtotalCents: number, method: PaymentType): PassOnFeeBreakdown;
 /**

package/dist/billing/fees.js

@@ -4,20 +4,22 @@ import { PaymentType } from '../types/api/PaymentType';
  *
  * When `pass_on_fees` is enabled on a bill, the customer is charged a gross
  * amount that, after Stripe's processing fees and Avro's application fee, leaves
- * the merchant with the bill's subtotal. The fee added on top of the subtotal
- * is exposed as a single read-only line item on the bill.
+ * the merchant with at least the bill's subtotal. The fee added on top of the
+ * subtotal is exposed as a single read-only line item on the bill.
  *
  * Stripe US standard pricing (online):
  *   - Card:          2.9% of gross + 30¢
  *   - ACH (us_bank): 0.8% of gross, capped at $5.00
  * Avro application fee:
- *   - 0.4% of net (gross - stripe), minimum 5¢
+ *   - 0.4% of gross, minimum 5¢
  *
  * All amounts are integer cents. All math is closed-form (no iteration).
  *
- * The integer-ceiling on the gross-up guarantees the merchant nets at
- * least the requested subtotal. In rare regime-boundary cases the merchant
- * may net a sub-cent more than requested — never less.
+ * Because both Stripe and Avro fees are charged against the same base (gross),
+ * the gross-up reduces to the standard form `G = (B + fixed) / (1 - rate)`
+ * within each regime. The integer-ceiling on each candidate guarantees the
+ * merchant nets at least the requested subtotal. In rare regime-boundary cases
+ * the merchant may net up to 2¢ more than requested — never less.
  */
 // --- Rate constants (per 1000 for integer math where applicable) ---
 const CARD_PCT_PER_1000 = 29; // 2.9%
@@ -46,12 +48,16 @@ export function computeStripeFee(grossCents, method) {
     return Math.min(Math.ceil((ACH_PCT_PER_1000 * grossCents) / 1000), ACH_CAP_CENTS);
 }
 /**
- * Compute Avro's application fee on a net amount (gross - stripeFee), in cents.
+ * Compute Avro's application fee on a gross amount, in cents.
+ *
+ * Avro's fee is now computed against the gross (matching Stripe's basis)
+ * rather than the post-Stripe net. This keeps the pass-on gross-up
+ * exactly solvable in closed form.
  */
-export function computeAvroFee(netCents) {
-    if (netCents <= 0)
+export function computeAvroFee(grossCents) {
+    if (grossCents <= 0)
         return AVRO_MIN_CENTS;
-    return Math.max(Math.ceil((AVRO_PCT_PER_1000 * netCents) / 1000), AVRO_MIN_CENTS);
+    return Math.max(Math.ceil((AVRO_PCT_PER_1000 * grossCents) / 1000), AVRO_MIN_CENTS);
 }
 /**
  * Compute the pass-on fee (in cents) such that, after Stripe and Avro deduct
@@ -63,8 +69,7 @@ export function computeAvroFee(netCents) {
  * Closed form: a finite set of candidate grosses is derived from each fee
  * regime (avro at the 5¢ floor vs. percentage; ACH stripe at the $5 cap vs.
  * percentage). The smallest candidate that satisfies the invariant
- * `gross - stripeFee(gross) - avroFee(gross - stripeFee(gross)) >= subtotal`
- * is selected. No iteration.
+ * `gross - stripeFee(gross) - avroFee(gross) >= subtotal` is selected.
  */
 export function computePassOnFee(subtotalCents, method) {
     if (subtotalCents <= 0)
@@ -74,7 +79,7 @@ export function computePassOnFee(subtotalCents, method) {
     let best = Number.POSITIVE_INFINITY;
     for (const g of candidates) {
         const stripe = computeStripeFee(g, method);
-        const avro = computeAvroFee(g - stripe);
+        const avro = computeAvroFee(g);
         if (g - stripe - avro >= B && g < best) {
             best = g;
         }
@@ -85,7 +90,7 @@ export function computePassOnFee(subtotalCents, method) {
         best = B + Math.ceil(B * 0.05) + CARD_FIXED_CENTS + AVRO_MIN_CENTS;
     }
     const stripeFee = computeStripeFee(best, method);
-    const avroFee = computeAvroFee(best - stripeFee);
+    const avroFee = computeAvroFee(best);
     return {
         stripeFee,
         avroFee,
@@ -96,45 +101,42 @@ export function computePassOnFee(subtotalCents, method) {
 /**
  * Card regime candidates.
  *
- * Stripe = ceil(0.029 * G) + 30; avro = max(ceil(0.004 * (G - stripe)), 5).
+ * stripe = ceil(0.029 * G) + 30; avro = max(ceil(0.004 * G), 5).
  *
- * The two `ceil`s can each add up to 1¢ relative to the exact rational form,
- * so each candidate carries a baked-in 2¢ (percentage regime) or 1¢ (floor
+ * Both ceil()s can each add up to 1¢ relative to the exact rational form, so
+ * each candidate carries a baked-in 2¢ (percentage regime) or 1¢ (floor
  * regime) safety margin to guarantee the invariant holds for every B in
  * integer cents — no post-hoc iteration required.
  *
- * 1) Percentage avro:  G * 0.967116 ≥ B + 29.88 + 2
- *      => G = ceil((1_000_000 * B + 31_880_000) / 967_116)
- * 2) Floor avro (5¢):  G * 0.971    ≥ B + 35 + 1
+ * 1) Percentage avro:  G * 0.967 ≥ B + 30 + 2
+ *      => G = ceil((1000 * B + 32_000) / 967)
+ * 2) Floor avro (5¢):  G * 0.971 ≥ B + 30 + 5 + 1
  *      => G = ceil((1000 * B + 36_000) / 971)
  */
 function cardCandidates(B) {
-    return [
-        Math.ceil((1000000 * B + 31880000) / 967116),
-        Math.ceil((1000 * B + 36000) / 971),
-    ];
+    return [Math.ceil((1000 * B + 32000) / 967), Math.ceil((1000 * B + 36000) / 971)];
 }
 /**
  * ACH regime candidates.
  *
- * Stripe = min(ceil(0.008 * G), 500); avro = max(ceil(0.004 * (G - stripe)), 5).
+ * stripe = min(ceil(0.008 * G), 500); avro = max(ceil(0.004 * G), 5).
  *
  * Same ceiling-safety logic as card. Stripe at the $5 cap is a fixed integer
  * so its ceiling-slack disappears in the capped regimes.
  *
- * 1) No-cap percentage avro: G * 0.988032 ≥ B + 2
- *      => G = ceil((1_000_000 * (B + 2)) / 988_032)
- * 2) No-cap floor avro:      G * 0.992    ≥ B + 5 + 1
+ * 1) No-cap percentage avro: G * 0.988 ≥ B + 2
+ *      => G = ceil((1000 * (B + 2)) / 988)
+ * 2) No-cap floor avro:      G * 0.992 ≥ B + 5 + 1
  *      => G = ceil((1000 * (B + 6)) / 992)
- * 3) Capped percentage avro: G * 0.996    ≥ B + 498 + 1
- *      => G = ceil((1000 * (B + 499)) / 996)
+ * 3) Capped percentage avro: G * 0.996 ≥ B + 500 + 1
+ *      => G = ceil((1000 * (B + 501)) / 996)
  * 4) Capped floor avro:      G = B + 505
  */
 function achCandidates(B) {
     return [
-        Math.ceil((1000000 * (B + 2)) / 988032),
+        Math.ceil((1000 * (B + 2)) / 988),
         Math.ceil((1000 * (B + 6)) / 992),
-        Math.ceil((1000 * (B + 499)) / 996),
+        Math.ceil((1000 * (B + 501)) / 996),
         B + 505,
     ];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@go-avro/avro-js",
-  "version": "0.0.50",
+  "version": "0.0.51",
   "description": "JS client for Avro backend integration.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",