@amboras-dev/money 0.0.0-stage → 0.2.0

package/dist/wire-Bhuut8cW.cjs

@@ -0,0 +1,2097 @@
+const require_money = require("./money-B3wH_Z4S.cjs");
+const require_allocate = require("./allocate-CZRg4TOP.cjs");
+const require_own = require("./own-oP9DXFWv.cjs");
+const require_iso_minor = require("./iso-minor-wSwJN57T.cjs");
+const require_number_text = require("./number-text-BWu67jUq.cjs");
+//#region src/wire/anet.ts
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+* The first `"<field>": <decimal>` (quoted or not) in a raw JSON body, verbatim: `JSON.parse`
+* would turn the gateway's `43.00` into `43`. The value is the whole JSON token, held to
+* `parseDecimal`'s `'plain'` grammar (`1e3` or `"43.10abc"` is not a decimal literal).
+* Undefined when absent; there is no lossy fallback.
+*/
+function jsonDecimalLiteral(rawBody, field) {
+	if (typeof rawBody !== "string" || typeof field !== "string") return void 0;
+	const tokens = rawBody.matchAll(new RegExp(`"${escapeRegExp(field)}"\\s*:\\s*("?)([^"\\s,}\\]]+)\\1`, "g"));
+	for (const [, , token] of tokens) if (require_money.parseDecimal(token, "plain")) return token;
+}
+const isPositiveLiteral = (text) => {
+	const value = require_money.parseDecimal(text.trim());
+	return value !== null && value.units > 0n;
+};
+function authorizeNetReversibleAmount(details) {
+	const settle = details.settleAmount ?? void 0;
+	if (settle !== void 0 && isPositiveLiteral(settle)) return settle;
+	return details.authAmount ?? settle;
+}
+//#endregion
+//#region src/data/psp.ts
+/** developer.paypal.com/reference/currency-codes ("Last updated: August 17, 2026"). */
+const PAYPAL_CURRENCY_DIGITS = {
+	0: [
+		"HUF",
+		"JPY",
+		"TWD"
+	],
+	2: [
+		"AUD",
+		"BRL",
+		"CAD",
+		"CHF",
+		"CNY",
+		"CZK",
+		"DKK",
+		"EUR",
+		"GBP",
+		"HKD",
+		"ILS",
+		"MXN",
+		"MYR",
+		"NOK",
+		"NZD",
+		"PHP",
+		"PLN",
+		"SEK",
+		"SGD",
+		"THB",
+		"USD"
+	]
+};
+/** docs.mollie.com/docs/multicurrency (2026-07-29). */
+const MOLLIE_CURRENCY_DIGITS = {
+	0: ["ISK", "JPY"],
+	2: [
+		"AED",
+		"AUD",
+		"BRL",
+		"CAD",
+		"CHF",
+		"CZK",
+		"DKK",
+		"EUR",
+		"GBP",
+		"HKD",
+		"HUF",
+		"ILS",
+		"MXN",
+		"MYR",
+		"NOK",
+		"NZD",
+		"PHP",
+		"PLN",
+		"RON",
+		"RUB",
+		"SEK",
+		"SGD",
+		"THB",
+		"TWD",
+		"USD",
+		"ZAR"
+	]
+};
+const AIRWALLEX_CURRENCY_DIGITS = {
+	0: [
+		"BIF",
+		"CLP",
+		"DJF",
+		"GNF",
+		"ISK",
+		"JPY",
+		"KMF",
+		"KRW",
+		"PYG",
+		"RWF",
+		"SLE",
+		"UGX",
+		"VND",
+		"VUV",
+		"XAF",
+		"XOF",
+		"XPF"
+	],
+	2: [
+		"AED",
+		"ALL",
+		"AMD",
+		"ANG",
+		"AOA",
+		"ARS",
+		"AUD",
+		"AWG",
+		"AZN",
+		"BAM",
+		"BBD",
+		"BDT",
+		"BGN",
+		"BMD",
+		"BND",
+		"BOB",
+		"BRL",
+		"BSD",
+		"BTN",
+		"BWP",
+		"BZD",
+		"CAD",
+		"CHF",
+		"CNY",
+		"COP",
+		"CRC",
+		"CVE",
+		"CZK",
+		"DKK",
+		"DOP",
+		"DZD",
+		"EGP",
+		"ERN",
+		"ETB",
+		"EUR",
+		"FJD",
+		"FKP",
+		"GBP",
+		"GEL",
+		"GHS",
+		"GIP",
+		"GMD",
+		"GTQ",
+		"GYD",
+		"HKD",
+		"HNL",
+		"HUF",
+		"IDR",
+		"ILS",
+		"INR",
+		"JMD",
+		"KES",
+		"KGS",
+		"KHR",
+		"KYD",
+		"KZT",
+		"LAK",
+		"LBP",
+		"LKR",
+		"LRD",
+		"LSL",
+		"MAD",
+		"MDL",
+		"MGA",
+		"MKD",
+		"MNT",
+		"MOP",
+		"MUR",
+		"MVR",
+		"MWK",
+		"MXN",
+		"MYR",
+		"NAD",
+		"NGN",
+		"NIO",
+		"NOK",
+		"NPR",
+		"NZD",
+		"PAB",
+		"PEN",
+		"PGK",
+		"PHP",
+		"PKR",
+		"PLN",
+		"QAR",
+		"RON",
+		"RSD",
+		"SAR",
+		"SBD",
+		"SCR",
+		"SEK",
+		"SGD",
+		"SHP",
+		"SRD",
+		"STD",
+		"SVC",
+		"SZL",
+		"THB",
+		"TJS",
+		"TMT",
+		"TOP",
+		"TRY",
+		"TTD",
+		"TWD",
+		"TZS",
+		"UAH",
+		"USD",
+		"UYU",
+		"UZS",
+		"WST",
+		"XCD",
+		"ZAR",
+		"ZMW",
+		"ZWL"
+	],
+	3: [
+		"BHD",
+		"JOD",
+		"KWD",
+		"LYD",
+		"OMR",
+		"TND"
+	]
+};
+/** docs.adyen.com/development-resources/currency-codes. Not read by the codec (overrides below); held to it by a test. */
+const ADYEN_CURRENCY_DIGITS = {
+	0: [
+		"CVE",
+		"DJF",
+		"GNF",
+		"IDR",
+		"JPY",
+		"KMF",
+		"KRW",
+		"PYG",
+		"RWF",
+		"UGX",
+		"VND",
+		"VUV",
+		"XAF",
+		"XOF",
+		"XPF"
+	],
+	2: [
+		"AED",
+		"ALL",
+		"AMD",
+		"AOA",
+		"ARS",
+		"AUD",
+		"AWG",
+		"AZN",
+		"BAM",
+		"BBD",
+		"BDT",
+		"BMD",
+		"BND",
+		"BOB",
+		"BRL",
+		"BSD",
+		"BWP",
+		"BYN",
+		"BZD",
+		"CAD",
+		"CHF",
+		"CLP",
+		"CNH",
+		"CNY",
+		"COP",
+		"CRC",
+		"CUP",
+		"CZK",
+		"DKK",
+		"DOP",
+		"DZD",
+		"EGP",
+		"ETB",
+		"EUR",
+		"FJD",
+		"FKP",
+		"GBP",
+		"GEL",
+		"GHS",
+		"GIP",
+		"GMD",
+		"GTQ",
+		"GYD",
+		"HKD",
+		"HNL",
+		"HTG",
+		"HUF",
+		"ILS",
+		"INR",
+		"ISK",
+		"JMD",
+		"KES",
+		"KGS",
+		"KHR",
+		"KYD",
+		"KZT",
+		"LAK",
+		"LKR",
+		"MAD",
+		"MDL",
+		"MKD",
+		"MMK",
+		"MNT",
+		"MOP",
+		"MRU",
+		"MUR",
+		"MVR",
+		"MWK",
+		"MXN",
+		"MYR",
+		"MZN",
+		"NAD",
+		"NGN",
+		"NIO",
+		"NOK",
+		"NPR",
+		"NZD",
+		"PAB",
+		"PEN",
+		"PGK",
+		"PHP",
+		"PKR",
+		"PLN",
+		"QAR",
+		"RON",
+		"RSD",
+		"RUB",
+		"SAR",
+		"SBD",
+		"SCR",
+		"SEK",
+		"SGD",
+		"SHP",
+		"SLE",
+		"SOS",
+		"SRD",
+		"STN",
+		"SVC",
+		"SZL",
+		"THB",
+		"TOP",
+		"TRY",
+		"TTD",
+		"TWD",
+		"TZS",
+		"UAH",
+		"USD",
+		"UYU",
+		"UZS",
+		"VEF",
+		"WST",
+		"XCD",
+		"XCG",
+		"YER",
+		"ZAR",
+		"ZMW"
+	],
+	3: [
+		"BHD",
+		"IQD",
+		"JOD",
+		"KWD",
+		"LYD",
+		"OMR",
+		"TND"
+	]
+};
+/** razorpay.com/docs international currency exponents. */
+const RAZORPAY_CURRENCY_EXPONENTS = {
+	0: [
+		"BIF",
+		"CLP",
+		"DJF",
+		"GNF",
+		"ISK",
+		"JPY",
+		"KMF",
+		"KRW",
+		"PYG",
+		"RWF",
+		"UGX",
+		"VND",
+		"VUV",
+		"XAF",
+		"XOF",
+		"XPF"
+	],
+	2: [
+		"AED",
+		"ALL",
+		"AMD",
+		"AUD",
+		"AWG",
+		"AZN",
+		"BAM",
+		"BBD",
+		"BDT",
+		"BGN",
+		"BMD",
+		"BND",
+		"BOB",
+		"BRL",
+		"BSD",
+		"BTN",
+		"BWP",
+		"BZD",
+		"CAD",
+		"CHF",
+		"CNY",
+		"COP",
+		"CRC",
+		"CUP",
+		"CVE",
+		"CZK",
+		"DKK",
+		"DOP",
+		"DZD",
+		"EGP",
+		"ETB",
+		"EUR",
+		"FJD",
+		"GBP",
+		"GHS",
+		"GIP",
+		"GMD",
+		"GTQ",
+		"GYD",
+		"HKD",
+		"HNL",
+		"HRK",
+		"HTG",
+		"HUF",
+		"IDR",
+		"ILS",
+		"INR",
+		"JMD",
+		"KES",
+		"KGS",
+		"KHR",
+		"KYD",
+		"KZT",
+		"LAK",
+		"LKR",
+		"LRD",
+		"LSL",
+		"MAD",
+		"MDL",
+		"MGA",
+		"MKD",
+		"MMK",
+		"MNT",
+		"MOP",
+		"MUR",
+		"MVR",
+		"MWK",
+		"MXN",
+		"MYR",
+		"MZN",
+		"NAD",
+		"NGN",
+		"NIO",
+		"NOK",
+		"NPR",
+		"NZD",
+		"PEN",
+		"PGK",
+		"PHP",
+		"PKR",
+		"PLN",
+		"QAR",
+		"RON",
+		"RSD",
+		"RUB",
+		"SAR",
+		"SCR",
+		"SEK",
+		"SGD",
+		"SLL",
+		"SOS",
+		"SVC",
+		"SZL",
+		"THB",
+		"TRY",
+		"TTD",
+		"TWD",
+		"TZS",
+		"UAH",
+		"USD",
+		"UYU",
+		"UZS",
+		"XCD",
+		"YER",
+		"ZAR",
+		"ZMW"
+	],
+	3: [
+		"BHD",
+		"IQD",
+		"JOD",
+		"KWD",
+		"OMR",
+		"TND"
+	]
+};
+/** Paystack: "If we notice a fractional part during processing, we ignore the fractional part." */
+const PAYSTACK_CURRENCY_DIGITS = { 2: [
+	"GHS",
+	"KES",
+	"NGN",
+	"USD",
+	"XOF",
+	"ZAR"
+] };
+/** Factor-1 overrides: ISO zero-decimal codes the PSP wants at two decimals (storage and wire agree). */
+const STRIPE_SENT_AS_TWO_DECIMAL = ["ISK", "UGX"];
+const ADYEN_SENT_AS_TWO_DECIMAL = ["ISK", "CLP"];
+const RAZORPAY_SENT_AS_TWO_DECIMAL = ["MGA"];
+const PAYSTACK_SENT_AS_TWO_DECIMAL = ["XOF"];
+const VNPAY_SENT_AS_TWO_DECIMAL = ["VND"];
+/** Factor-100 override: ISO two-decimal codes Adyen wants in whole units. */
+const ADYEN_SENT_AS_ZERO_DECIMAL = ["IDR", "CVE"];
+/** docs.stripe.com/currencies retrieved 2026-10-07 (union over 45 countries; IQD, LYD absent). */
+const STRIPE_PRESENTMENT_CURRENCIES = [
+	"AED",
+	"AFN",
+	"ALL",
+	"AMD",
+	"ANG",
+	"AOA",
+	"ARS",
+	"AUD",
+	"AWG",
+	"AZN",
+	"BAM",
+	"BBD",
+	"BDT",
+	"BHD",
+	"BIF",
+	"BMD",
+	"BND",
+	"BOB",
+	"BRL",
+	"BSD",
+	"BWP",
+	"BYN",
+	"BZD",
+	"CAD",
+	"CDF",
+	"CHF",
+	"CLP",
+	"CNY",
+	"COP",
+	"CRC",
+	"CVE",
+	"CZK",
+	"DJF",
+	"DKK",
+	"DOP",
+	"DZD",
+	"EGP",
+	"ETB",
+	"EUR",
+	"FJD",
+	"FKP",
+	"GBP",
+	"GEL",
+	"GIP",
+	"GMD",
+	"GNF",
+	"GTQ",
+	"GYD",
+	"HKD",
+	"HNL",
+	"HTG",
+	"HUF",
+	"IDR",
+	"ILS",
+	"INR",
+	"ISK",
+	"JMD",
+	"JOD",
+	"JPY",
+	"KES",
+	"KGS",
+	"KHR",
+	"KMF",
+	"KRW",
+	"KWD",
+	"KYD",
+	"KZT",
+	"LAK",
+	"LBP",
+	"LKR",
+	"LRD",
+	"LSL",
+	"MAD",
+	"MDL",
+	"MGA",
+	"MKD",
+	"MMK",
+	"MNT",
+	"MOP",
+	"MUR",
+	"MVR",
+	"MWK",
+	"MXN",
+	"MYR",
+	"MZN",
+	"NAD",
+	"NGN",
+	"NIO",
+	"NOK",
+	"NPR",
+	"NZD",
+	"OMR",
+	"PAB",
+	"PEN",
+	"PGK",
+	"PHP",
+	"PKR",
+	"PLN",
+	"PYG",
+	"QAR",
+	"RON",
+	"RSD",
+	"RUB",
+	"RWF",
+	"SAR",
+	"SBD",
+	"SCR",
+	"SEK",
+	"SGD",
+	"SHP",
+	"SLE",
+	"SOS",
+	"SRD",
+	"STD",
+	"SZL",
+	"THB",
+	"TJS",
+	"TND",
+	"TOP",
+	"TRY",
+	"TTD",
+	"TWD",
+	"TZS",
+	"UAH",
+	"UGX",
+	"USD",
+	"UYU",
+	"UZS",
+	"VND",
+	"VUV",
+	"WST",
+	"XAF",
+	"XCD",
+	"XCG",
+	"XOF",
+	"XPF",
+	"YER",
+	"ZAR",
+	"ZMW"
+];
+/**
+* Presentment currencies only accounts registered in the named countries can charge.
+* Stripe: support.stripe.com/questions/which-payments-methods-and-products-are-available-in-the-uae
+* (retrieved 2026-10-07): "We also support charges in the following three-decimal currencies:
+* Bahraini dinar (BHD), Jordanian dinar (JOD), Kuwaiti dinar (KWD), Omani rial (OMR), Tunisian
+* dinar (TND)"; no other country's list on docs.stripe.com/currencies carries them.
+* PayPal: developer.paypal.com/reference/currency-codes (retrieved 2026-10-07) footnotes BRL, CNY
+* and MYR as supported "only for in-country PayPal accounts" (Medusa models the conservative
+* reading: an out-of-country account cannot charge them; unverified by a sandbox probe).
+*/
+const PRESENTMENT_REQUIRES_ACCOUNT_COUNTRY = {
+	stripe: {
+		BHD: ["AE"],
+		JOD: ["AE"],
+		KWD: ["AE"],
+		OMR: ["AE"],
+		TND: ["AE"]
+	},
+	paypal: {
+		BRL: ["BR"],
+		CNY: ["CN"],
+		MYR: ["MY"]
+	}
+};
+/**
+* Account countries whose card processing takes only the listed currencies.
+* Airwallex: airwallex.com/docs/payments/payment-methods/global/cards (retrieved 2026-10-26,
+* matching Medusa's 2026-10-07 copy): "Supported processing currencies can differ based on where
+* your business is registered and the card scheme." US and MX are listed below; AU, CA, SG, HK,
+* NZ, JP, MY, the EEA, CH, UK and IL take "Visa, MasterCard: All currencies".
+*/
+const PRESENTMENT_ACCOUNT_COUNTRY_ALLOWS_ONLY = { airwallex: {
+	US: [
+		"USD",
+		"EUR",
+		"GBP",
+		"AUD",
+		"SGD",
+		"JPY",
+		"CHF",
+		"NOK",
+		"DKK",
+		"CAD",
+		"NZD",
+		"HKD",
+		"KRW",
+		"PHP",
+		"MYR",
+		"TWD",
+		"VND",
+		"EGP",
+		"SAR",
+		"THB",
+		"MXN",
+		"TRY",
+		"INR",
+		"BRL",
+		"CNY",
+		"PKR",
+		"PLN",
+		"SEK",
+		"NGN",
+		"AED",
+		"IDR",
+		"BDT",
+		"ILS",
+		"ISK",
+		"MAD",
+		"ZAR",
+		"CZK",
+		"HUF",
+		"RON",
+		"CLP",
+		"QAR",
+		"COP",
+		"RUB",
+		"MWK",
+		"PEN",
+		"BGN",
+		"UAH",
+		"ARS",
+		"MOP",
+		"HRK",
+		"KZT",
+		"ALL",
+		"CRC",
+		"XOF",
+		"KES",
+		"UYU",
+		"LKR",
+		"BOB",
+		"PAB",
+		"GTQ",
+		"DOP",
+		"MMK",
+		"RSD",
+		"BZD",
+		"DZD",
+		"SHP",
+		"HNL",
+		"GEL",
+		"BAM",
+		"MKD",
+		"JMD",
+		"AWG",
+		"BBD",
+		"TTD",
+		"PYG",
+		"XAF"
+	],
+	MX: ["MXN"]
+} };
+/** Stripe's not-two-decimal set (capabilities/stripe-connect.ts:47), incl. the UAE-only five. */
+const STRIPE_NOT_TWO_DECIMAL = [
+	"BIF",
+	"CLP",
+	"DJF",
+	"GNF",
+	"JPY",
+	"KMF",
+	"KRW",
+	"MGA",
+	"PYG",
+	"RWF",
+	"UGX",
+	"VND",
+	"VUV",
+	"XAF",
+	"XOF",
+	"XPF",
+	"ISK",
+	"BHD",
+	"JOD",
+	"KWD",
+	"OMR",
+	"TND"
+];
+/**
+* The ISO 4217 set Stripe's sendable rule is derived over (medusa common/money/iso-currencies.ts,
+* 156 codes). Kept verbatim rather than read from the registry's active list: it still holds BGN,
+* which the registry retired, and Stripe still accepts it.
+*/
+const STRIPE_SENDABLE_ISO_BASE = [
+	"AED",
+	"AFN",
+	"ALL",
+	"AMD",
+	"AOA",
+	"ARS",
+	"AUD",
+	"AWG",
+	"AZN",
+	"BAM",
+	"BBD",
+	"BDT",
+	"BGN",
+	"BHD",
+	"BIF",
+	"BMD",
+	"BND",
+	"BOB",
+	"BRL",
+	"BSD",
+	"BTN",
+	"BWP",
+	"BYN",
+	"BZD",
+	"CAD",
+	"CDF",
+	"CHF",
+	"CLP",
+	"CNY",
+	"COP",
+	"CRC",
+	"CUP",
+	"CVE",
+	"CZK",
+	"DJF",
+	"DKK",
+	"DOP",
+	"DZD",
+	"EGP",
+	"ERN",
+	"ETB",
+	"EUR",
+	"FJD",
+	"FKP",
+	"GBP",
+	"GEL",
+	"GHS",
+	"GIP",
+	"GMD",
+	"GNF",
+	"GTQ",
+	"GYD",
+	"HKD",
+	"HNL",
+	"HTG",
+	"HUF",
+	"IDR",
+	"ILS",
+	"INR",
+	"IQD",
+	"IRR",
+	"ISK",
+	"JMD",
+	"JOD",
+	"JPY",
+	"KES",
+	"KGS",
+	"KHR",
+	"KMF",
+	"KPW",
+	"KRW",
+	"KWD",
+	"KYD",
+	"KZT",
+	"LAK",
+	"LBP",
+	"LKR",
+	"LRD",
+	"LSL",
+	"LYD",
+	"MAD",
+	"MDL",
+	"MGA",
+	"MKD",
+	"MMK",
+	"MNT",
+	"MOP",
+	"MRU",
+	"MUR",
+	"MVR",
+	"MWK",
+	"MXN",
+	"MYR",
+	"MZN",
+	"NAD",
+	"NGN",
+	"NIO",
+	"NOK",
+	"NPR",
+	"NZD",
+	"OMR",
+	"PAB",
+	"PEN",
+	"PGK",
+	"PHP",
+	"PKR",
+	"PLN",
+	"PYG",
+	"QAR",
+	"RON",
+	"RSD",
+	"RUB",
+	"RWF",
+	"SAR",
+	"SBD",
+	"SCR",
+	"SDG",
+	"SEK",
+	"SGD",
+	"SHP",
+	"SLE",
+	"SOS",
+	"SRD",
+	"SSP",
+	"STN",
+	"SVC",
+	"SYP",
+	"SZL",
+	"THB",
+	"TJS",
+	"TMT",
+	"TND",
+	"TOP",
+	"TRY",
+	"TTD",
+	"TWD",
+	"TZS",
+	"UAH",
+	"UGX",
+	"USD",
+	"UYU",
+	"UZS",
+	"VED",
+	"VES",
+	"VND",
+	"VUV",
+	"WST",
+	"XAF",
+	"XCD",
+	"XCG",
+	"XOF",
+	"XPF",
+	"YER",
+	"ZAR",
+	"ZMW",
+	"ZWG"
+];
+const IYZICO_CURRENCIES = [
+	"TRY",
+	"USD",
+	"EUR",
+	"GBP",
+	"NOK",
+	"CHF"
+];
+/** developer.authorize.net createTransactionRequest `currencyCode`, retrieved 2026-10-07. */
+const AUTHORIZE_NET_CURRENCIES = [
+	"USD",
+	"CAD",
+	"GBP",
+	"EUR",
+	"AUD",
+	"NZD",
+	"DKK",
+	"NOK",
+	"SEK",
+	"PLN"
+];
+const VND_ONLY = ["VND"];
+/** orch `MINIMUM_AMOUNT_BY_CURRENCY`, majors. */
+const PSP_MINIMUM_MAJOR = { paystack: { USD: "2.00" } };
+/** RBI e-mandate AFA-free cap: INR 15,000 (razorpay-vault `15_000_00` paise, seam `1_500_000`). */
+const RAZORPAY_AFA_FREE_CAP_MAJOR = "15000";
+/**
+* Provider-only codes: currencies a PSP table lists that are not ISO 4217 registry entries (and
+* not Medusa store currencies), so no Amboras store can sell in them and no Money can carry them.
+* /wire knows them only to refuse them by name: `pspSupportsCurrency` is false, `pspCurrencies`
+* leaves them out, and decoding a provider-reported amount in one throws `wire_unsupported`.
+*/
+const PROVIDER_ONLY_CURRENCIES = { CNH: {
+	name: "Chinese Yuan (offshore)",
+	psps: ["adyen"]
+} };
+//#endregion
+//#region src/wire/currency.ts
+/** The registry entry (any case, historic included) for `input`, else null. Never throws. */
+function wireCurrency(input) {
+	return require_money.findCurrency(input, { allowHistoric: true });
+}
+/** The upper-cased code when `input` is a provider-only currency (Adyen CNH), else null. */
+function providerOnlyCode(input) {
+	if (typeof input !== "string") return null;
+	const code = input.trim().toUpperCase();
+	return require_own.hasOwnKey(PROVIDER_ONLY_CURRENCIES, code) ? code : null;
+}
+/** `[<Tag>] CNH is a provider-only currency code ...`: why a provider-only amount is refused. */
+function providerOnlyRefusal(tag, code) {
+	return `[${tag}] ${code} is a provider-only currency code (${PROVIDER_ONLY_CURRENCIES[code].name}): ${tag} can report it, but it is not an ISO 4217 currency, no Amboras store sells in it, and no Money can hold it.`;
+}
+/** `wireCurrency`, throwing `currency_invalid` for an unknown code. */
+function resolveWireCurrency(input) {
+	const info = wireCurrency(input);
+	if (!info) throw new require_money.MoneyError("currency_invalid", `Unknown currency code: ${require_money.describeValue(input)}`);
+	return info;
+}
+/** A Money's currency entry and its stored units, validated like the core's `storedDecimal`. */
+function wireStored(m) {
+	const info = resolveWireCurrency(m.currency);
+	if (!Number.isSafeInteger(m.amount)) throw new require_money.MoneyError("amount_invalid", `Stored amount must be a safe integer, got ${require_money.describeValue(m.amount)}`);
+	return {
+		info,
+		units: BigInt(m.amount)
+	};
+}
+const SAFE_LIMIT = BigInt(Number.MAX_SAFE_INTEGER);
+/**
+* A Money's or FractionalMoney's currency entry and its exact stored amount, normalized (scale 0
+* when whole, so a whole amount reads exactly as `wireStored` reads it). A number must be finite
+* and safe when whole, text plain decimal; the amount must round within the safe integers.
+*/
+function wireStoredDecimal(m) {
+	const info = resolveWireCurrency(m.currency);
+	const { amount } = m;
+	if (typeof amount === "string") {
+		const parsed = require_money.parseDecimal(amount, "plain");
+		if (parsed === null) throw new require_money.MoneyError("amount_invalid", `Stored amount must be plain decimal text, got ${require_money.describeValue(amount)}`);
+		if (!require_money.unitsWithin(require_money.roundToScale(parsed, 0, "up"), SAFE_LIMIT)) throw new require_money.MoneyError("amount_invalid", `Stored amount is beyond the safe integers: ${amount}`);
+		return {
+			info,
+			stored: require_money.normalizeDecimal(parsed)
+		};
+	}
+	const parsed = typeof amount === "number" ? require_money.strictNumberDecimal(amount) : null;
+	if (parsed === null) throw new require_money.MoneyError("amount_invalid", `Stored amount must be a safe integer, got ${require_money.describeValue(amount)}`);
+	return {
+		info,
+		stored: require_money.normalizeDecimal(parsed)
+	};
+}
+//#endregion
+//#region src/wire/descriptors.ts
+function digitTable(groups) {
+	const table = /* @__PURE__ */ new Map();
+	for (const digits of [
+		0,
+		2,
+		3
+	]) for (const code of groups[digits] ?? []) table.set(code, digits);
+	return table;
+}
+function genericUnsupported(tag) {
+	return (code) => `[${tag}] ${code} is not in ${tag}'s supported currency list.`;
+}
+function vndOnly(tag, subject, negation) {
+	return (code) => {
+		return `[${tag}] ${tag} only supports VND - ${subject} ${code}. Switch the region's currency to VND, or ${negation} offer ${tag} in this region.`;
+	};
+}
+const scalesAnyCurrency = () => true;
+const vndOnlyFacade = (code) => code === "VND";
+const NONE = /* @__PURE__ */ new Set();
+const NO_DIGITS = /* @__PURE__ */ new Map();
+function describe(id, input) {
+	const currencies = new Set(input.currencies);
+	return Object.freeze({
+		id,
+		tag: input.tag,
+		family: input.family,
+		gated: input.gated ?? false,
+		encodeGated: input.encodeGated ?? false,
+		preCutoverNeedsFactorOne: input.preCutoverNeedsFactorOne ?? false,
+		roundsToStoredUnitFirst: input.roundsToStoredUnitFirst ?? false,
+		currencies,
+		presentmentCurrencies: input.presentmentCurrencies ? new Set(input.presentmentCurrencies) : currencies,
+		digits: input.digits ?? NO_DIGITS,
+		sentAsTwoDecimal: input.sentAsTwoDecimal ? new Set(input.sentAsTwoDecimal) : NONE,
+		sentAsZeroDecimal: input.sentAsZeroDecimal ? new Set(input.sentAsZeroDecimal) : NONE,
+		threeDecimalStepOfTen: input.threeDecimalStepOfTen ?? false,
+		wholeUnit: input.wholeUnit ?? null,
+		singleCurrency: input.singleCurrency ?? null,
+		unsupported: input.unsupported ?? genericUnsupported(input.tag),
+		facadeAccepts: input.facadeAccepts ?? scalesAnyCurrency,
+		inboundWholePositive: input.inboundWholePositive ?? false
+	});
+}
+const notTwoDecimalAtStripe = new Set(STRIPE_NOT_TWO_DECIMAL);
+/**
+* Stripe's presentment list plus every ISO code that is two-decimal in both storage and display
+* and not on Stripe's not-two-decimal list (capabilities/stripe-connect.ts:60).
+*/
+const STRIPE_SENDABLE = [...STRIPE_PRESENTMENT_CURRENCIES, ...STRIPE_SENDABLE_ISO_BASE.filter((code) => {
+	const info = require_money.findCurrency(code, { allowHistoric: true });
+	return info !== null && !notTwoDecimalAtStripe.has(code) && info.storageDigits === 2 && info.displayDigits === 2;
+})];
+const whole = (info, digits) => info.storageDigits === digits;
+function paystackZeroDecimal(code) {
+	return `[Paystack] ${code} is zero-decimal and Amboras stores it at a x100 scale, so it cannot be sent to Paystack without a currency-aware amount codec. Charging it would overcharge the buyer 100x. Verify the currency against Paystack docs and add an override set before enabling it.`;
+}
+const RAZORPAY_DIGITS = digitTable(RAZORPAY_CURRENCY_EXPONENTS);
+const PSP_DESCRIPTORS = Object.freeze({
+	stripe: describe("stripe", {
+		tag: "StripeConnect",
+		family: "iso-minor",
+		gated: true,
+		encodeGated: true,
+		roundsToStoredUnitFirst: true,
+		currencies: STRIPE_SENDABLE,
+		presentmentCurrencies: STRIPE_PRESENTMENT_CURRENCIES,
+		sentAsTwoDecimal: STRIPE_SENT_AS_TWO_DECIMAL
+	}),
+	adyen: describe("adyen", {
+		tag: "Adyen",
+		family: "iso-minor",
+		gated: true,
+		encodeGated: true,
+		roundsToStoredUnitFirst: true,
+		currencies: digitTable(ADYEN_CURRENCY_DIGITS).keys(),
+		digits: digitTable(ADYEN_CURRENCY_DIGITS),
+		sentAsTwoDecimal: ADYEN_SENT_AS_TWO_DECIMAL,
+		sentAsZeroDecimal: ADYEN_SENT_AS_ZERO_DECIMAL
+	}),
+	razorpay: describe("razorpay", {
+		tag: "Razorpay",
+		family: "iso-minor",
+		gated: true,
+		encodeGated: true,
+		preCutoverNeedsFactorOne: true,
+		threeDecimalStepOfTen: true,
+		currencies: RAZORPAY_DIGITS.keys(),
+		digits: RAZORPAY_DIGITS,
+		sentAsTwoDecimal: RAZORPAY_SENT_AS_TWO_DECIMAL,
+		facadeAccepts: (code) => RAZORPAY_DIGITS.has(code),
+		unsupported: (code) => {
+			return `[Razorpay] ${code} is not in Razorpay's published currency table, so it has no verified minor-unit exponent and cannot be charged through Razorpay.`;
+		}
+	}),
+	paystack: describe("paystack", {
+		tag: "Paystack",
+		family: "iso-minor",
+		gated: true,
+		currencies: digitTable(PAYSTACK_CURRENCY_DIGITS).keys(),
+		digits: digitTable(PAYSTACK_CURRENCY_DIGITS),
+		sentAsTwoDecimal: PAYSTACK_SENT_AS_TWO_DECIMAL,
+		facadeAccepts: (code, info) => info === null || !whole(info, 0) || PAYSTACK_SENT_AS_TWO_DECIMAL.includes(code),
+		wholeUnit: {
+			applies: (info) => PAYSTACK_SENT_AS_TWO_DECIMAL.includes(info.code),
+			message: (info, _stored, _label, major) => {
+				return `[Paystack] ${info.code} ${major} cannot be charged: Paystack takes a whole number of francs and ignores any fraction.`;
+			}
+		},
+		unsupported: (code, info) => info !== null && whole(info, 0) ? paystackZeroDecimal(code) : genericUnsupported("Paystack")(code)
+	}),
+	momo: describe("momo", {
+		tag: "MoMo",
+		family: "iso-minor",
+		gated: true,
+		currencies: VND_ONLY,
+		singleCurrency: "VND",
+		facadeAccepts: vndOnlyFacade,
+		wholeUnit: {
+			applies: () => true,
+			message: (_info, stored, label) => {
+				return `[MoMo] VND ${label} must resolve to a whole dong value after division by 100 (Medusa stores VND at that scale): ${stored}`;
+			}
+		},
+		unsupported: vndOnly("MoMo", "this amount is", "do not")
+	}),
+	vnpay: describe("vnpay", {
+		tag: "VNPay",
+		family: "iso-minor",
+		currencies: VND_ONLY,
+		singleCurrency: "VND",
+		facadeAccepts: vndOnlyFacade,
+		sentAsTwoDecimal: VNPAY_SENT_AS_TWO_DECIMAL,
+		inboundWholePositive: true,
+		wholeUnit: {
+			applies: () => true,
+			message: (_info, stored, label) => `[VNPay] VND ${label} must resolve to a whole dong value: ${stored}`
+		},
+		unsupported: vndOnly("VNPay", "this store's region currency is", "don't")
+	}),
+	paypal: describe("paypal", {
+		tag: "PayPal",
+		family: "major-string",
+		currencies: digitTable(PAYPAL_CURRENCY_DIGITS).keys(),
+		digits: digitTable(PAYPAL_CURRENCY_DIGITS)
+	}),
+	mollie: describe("mollie", {
+		tag: "Mollie",
+		family: "major-string",
+		currencies: digitTable(MOLLIE_CURRENCY_DIGITS).keys(),
+		digits: digitTable(MOLLIE_CURRENCY_DIGITS)
+	}),
+	airwallex: describe("airwallex", {
+		tag: "Airwallex",
+		family: "major-number",
+		currencies: digitTable(AIRWALLEX_CURRENCY_DIGITS).keys(),
+		digits: digitTable(AIRWALLEX_CURRENCY_DIGITS)
+	}),
+	iyzico: describe("iyzico", {
+		tag: "iyzico",
+		family: "major-string",
+		currencies: IYZICO_CURRENCIES,
+		unsupported: (code) => {
+			return `[iyzico] Unsupported currency ${code}. Supported currencies: ${IYZICO_CURRENCIES.join(", ")}.`;
+		}
+	}),
+	"authorize-net": describe("authorize-net", {
+		tag: "authorize-net",
+		family: "major-string",
+		currencies: AUTHORIZE_NET_CURRENCIES,
+		unsupported: (code) => `Authorize.Net does not settle ${code}.`
+	}),
+	payoo: describe("payoo", {
+		tag: "Payoo",
+		family: "major-number",
+		currencies: VND_ONLY,
+		singleCurrency: "VND",
+		facadeAccepts: vndOnlyFacade,
+		wholeUnit: {
+			applies: () => true,
+			message: (_info, stored) => {
+				return `[Payoo] VND amount must resolve to a whole dong value after /100 (Medusa stores VND x100): ${stored}`;
+			}
+		},
+		unsupported: vndOnly("Payoo", "this store's region currency is", "don't")
+	})
+});
+/** Every PSP id, in a stable order. */
+const PSP_IDS = Object.freeze(Object.keys(PSP_DESCRIPTORS));
+/** The descriptor for `psp`; an unknown id throws `wire_unsupported`. */
+function pspDescriptor(psp) {
+	if (typeof psp === "string" && require_own.hasOwnKey(PSP_DESCRIPTORS, psp)) return PSP_DESCRIPTORS[psp];
+	throw new require_money.MoneyError("wire_unsupported", `Unknown payment provider: ${require_money.describeValue(psp)}`);
+}
+//#endregion
+//#region src/wire/marker.ts
+const WIRE_SCALE_KEY = "amboras_wire_scale";
+const WIRE_SCALE_ISO_MINOR_V2 = "iso-minor-v2";
+const WIRE_SCALE_MARKER = Object.freeze({ [WIRE_SCALE_KEY]: WIRE_SCALE_ISO_MINOR_V2 });
+const ISO_MINOR_V2 = Object.freeze({ kind: "iso-minor-v2" });
+const PRE_CUTOVER = Object.freeze({ kind: "pre-cutover" });
+/**
+* `ISO_MINOR_V2` iff ANY record is a non-null object whose `amboras_wire_scale` is strictly
+* `'iso-minor-v2'` (a Stripe charge OR its PaymentIntent); else `PRE_CUTOVER`. Reads already
+* fetched records only: it never queries (FORCE RLS would hide the row and the marker with it).
+*/
+function conventionOf(...records) {
+	return records.some((r) => typeof r === "object" && r !== null && r["amboras_wire_scale"] === "iso-minor-v2") ? ISO_MINOR_V2 : PRE_CUTOVER;
+}
+/** Internal: the convention's kind, or null when `value` is not a Convention. */
+function conventionKind(value) {
+	const kind = typeof value === "object" && value !== null ? value.kind : void 0;
+	return kind === "iso-minor-v2" || kind === "pre-cutover" ? kind : null;
+}
+//#endregion
+//#region src/wire/codec.ts
+const isBlank = (value) => value === null || value === void 0 || typeof value === "string" && value.trim() === "";
+const shownCode = (currency) => typeof currency === "string" ? currency.trim().toUpperCase() : require_money.describeValue(currency);
+function missingCurrency(d) {
+	const message = `[${d.tag}] Cannot scale an amount without a currency code; session data is missing currency_code.`;
+	return new require_money.MoneyError("currency_missing", message);
+}
+function supported(d, currency) {
+	const info = wireCurrency(currency);
+	return info !== null && d.currencies.has(info.code) ? info : null;
+}
+/** Whether `psp` takes `currency` (any case, historic codes included). Never throws for a bad code. */
+function pspSupportsCurrency(psp, currency) {
+	return supported(pspDescriptor(psp), currency) !== null;
+}
+/**
+* Every currency `psp` takes. Provider-only codes a PSP table lists (Adyen offshore CNH) are left
+* out: they are not ISO 4217 currencies, no store sells in them and no Money can carry them.
+*/
+function pspCurrencies(psp) {
+	const d = pspDescriptor(psp);
+	const codes = [];
+	for (const code of d.currencies) {
+		const info = wireCurrency(code);
+		if (info) codes.push(info.code);
+	}
+	return new Set(codes.sort());
+}
+/**
+* `currency` as a CurrencyCode `psp` takes. Empty throws `currency_missing` (`[<Tag>] Cannot
+* scale an amount without a currency code; ...`); anything the PSP does not take throws
+* `wire_unsupported` with the provider's own message.
+*/
+function assertPspCurrency(psp, currency) {
+	const d = pspDescriptor(psp);
+	if (isBlank(currency)) throw missingCurrency(d);
+	const info = supported(d, currency);
+	if (info) return info.code;
+	const providerOnly = providerOnlyCode(currency);
+	if (providerOnly !== null) throw new require_money.MoneyError("wire_unsupported", providerOnlyRefusal(d.tag, providerOnly));
+	throw new require_money.MoneyError("wire_unsupported", d.unsupported(shownCode(currency), wireCurrency(currency)));
+}
+/**
+* The gate Medusa's amount facade for `psp` applies, on encode and decode alike: most scale any
+* currency (the PSP's list is eligibility's job: `assertPspCurrency`); Razorpay, Paystack, MoMo,
+* Payoo and VNPay refuse with their own message (provider-only CNH included, as in Medusa).
+* Returns the registry entry, else throws (`wire_unsupported` for a facade refusal or a
+* provider-only code, `currency_invalid` for an unknown code).
+*/
+function facadeCurrency(d, currency) {
+	const info = wireCurrency(currency);
+	const code = info?.code ?? shownCode(currency);
+	if (!d.facadeAccepts(code, info)) throw new require_money.MoneyError("wire_unsupported", d.unsupported(code, info));
+	const providerOnly = providerOnlyCode(currency);
+	if (providerOnly !== null) throw new require_money.MoneyError("wire_unsupported", providerOnlyRefusal(d.tag, providerOnly));
+	return info ?? resolveWireCurrency(currency);
+}
+/** `'VND'` for the single-currency providers (MoMo, Payoo, VNPay), else null. */
+function pspDefaultCurrency(psp) {
+	const single = pspDescriptor(psp).singleCurrency;
+	return single === null ? null : single;
+}
+function factorOf(d, info) {
+	if (d.sentAsTwoDecimal.has(info.code)) return 1n;
+	if (d.sentAsZeroDecimal.has(info.code)) return 100n;
+	return require_iso_minor.isoMinorFactor(info, info.storageDigits);
+}
+function requireIsoMinor(d) {
+	if (d.family !== "iso-minor") throw new require_money.MoneyError("wire_unsupported", `[${d.tag}] ${d.tag} does not take ISO minor units`);
+}
+/**
+* Stored units per wire unit for an ISO-minor PSP: the PSP's override (Stripe ISK/UGX, Adyen
+* ISK/CLP, Razorpay MGA, Paystack XOF, VNPay VND give 1; Adyen IDR/CVE give 100), else
+* `storageScale / 10^storageDigits` (100 for a zero-decimal currency, else 1).
+*/
+function wireFactor(psp, currency) {
+	const d = pspDescriptor(psp);
+	requireIsoMinor(d);
+	return Number(factorOf(d, resolveWireCurrency(currency)));
+}
+function wireDigitsOf(d, info) {
+	const table = d.digits.get(info.code);
+	if (table !== void 0) return table;
+	if (d.family === "iso-minor") return factorOf(d, info) === 1n ? require_money.storageExponent(info) : 0;
+	return info.displayDigits;
+}
+/**
+* Fraction digits of `psp`'s wire amount: its digit table, else (ISO-minor PSPs) the digits
+* its factor implies, else (iyzico, Authorize.Net, Payoo) the display digits. Null when the
+* PSP does not take the currency.
+*/
+function pspWireDigits(psp, currency) {
+	const d = pspDescriptor(psp);
+	const info = supported(d, currency);
+	return info === null ? null : wireDigitsOf(d, info);
+}
+/** The PSP's minimum charge in `currency` (Paystack USD 2.00), or null when it has none. */
+function pspMinimumAmount(psp, currency) {
+	const d = pspDescriptor(psp);
+	const info = wireCurrency(currency);
+	if (info === null) return null;
+	const major = PSP_MINIMUM_MAJOR[d.id]?.[info.code];
+	return major === void 0 ? null : require_money.fromMajor(major, info.code);
+}
+function requireConvention(d, convention) {
+	const kind = conventionKind(convention);
+	if (kind === null) {
+		const message = `[${d.tag}] A wire convention is required: pass conventionOf(record) for this payment.`;
+		throw new require_money.MoneyError("wire_refused", message);
+	}
+	return kind;
+}
+function encodeWire(psp, m, options = {}) {
+	const d = pspDescriptor(psp);
+	const { info, stored: held } = wireStoredDecimal(m);
+	facadeCurrency(d, info.code);
+	const label = options.label ?? "amount";
+	const shown = require_money.formatDecimal(held);
+	const exponent = require_money.storageExponent(info);
+	const majorText = require_money.formatDecimal({
+		units: held.units,
+		scale: exponent + held.scale
+	});
+	if (held.units < 0n || held.units === 0n && !options.allowZero) throw new require_money.MoneyError("wire_refused", `[${d.tag}] Invalid ${label}: ${shown}`);
+	const stored = d.roundsToStoredUnitFirst ? require_money.roundToScale(held, 0, "half-up") : held;
+	const positive = held.units > 0n;
+	const factor = d.family === "iso-minor" ? factorOf(d, info) : 1n;
+	if (d.encodeGated && requireConvention(d, options.convention) === "pre-cutover") {
+		if (!(stored.scale === 0 && (!d.preCutoverNeedsFactorOne || require_money.divRound(stored.units, factor, "half-up") === stored.units))) throw new require_money.MoneyError("wire_refused", preCutoverRefusal(d.tag, info.code));
+		if (stored.units === 0n && positive) throw subUnitRefusal(d, info, majorText, exponent, label);
+		return Number(stored.units);
+	}
+	if (d.wholeUnit?.applies(info) && stored.units % (BigInt(info.storageScale) * require_money.pow10(stored.scale)) !== 0n) throw new require_money.MoneyError("wire_refused", d.wholeUnit.message(info, shown, label, majorText));
+	const digits = wireDigitsOf(d, info);
+	if (d.family === "iso-minor") {
+		const exact = require_money.divRound(stored.units, factor * require_money.pow10(stored.scale), "half-up");
+		if (exact === 0n && positive) throw subUnitRefusal(d, info, majorText, digits, label);
+		if (!d.threeDecimalStepOfTen || d.digits.get(info.code) !== 3) return Number(exact);
+		const stepped = exact - exact % 10n;
+		if (stepped === 0n && exact > 0n) throw new require_money.MoneyError("wire_refused", roundsToNothing(d.tag, info.code, majorText));
+		return Number(stepped);
+	}
+	const rounded = require_money.roundToScale({
+		units: stored.units,
+		scale: exponent + stored.scale
+	}, digits, "half-up");
+	if (rounded.units === 0n && positive) throw subUnitRefusal(d, info, majorText, digits, label);
+	const text = require_money.formatDecimal(rounded);
+	return d.family === "major-number" ? Number(text) : text;
+}
+function subUnitRefusal(d, info, major, digits, label) {
+	const unit = require_money.formatDecimal({
+		units: 1n,
+		scale: digits
+	});
+	const message = `[${d.tag}] Invalid ${label}: ${info.code} ${major} rounds to 0 at ${d.tag}, whose smallest ${info.code} unit is ${unit}; refusing to send a zero amount.`;
+	return new require_money.MoneyError("wire_refused", message);
+}
+function preCutoverRefusal(tag, code) {
+	return `[${tag}] This ${code} session predates the wire-scale marker, so ${tag} may hold storage units for it; converting would move 1/100th of the amount. Refusing rather than guessing.`;
+}
+function roundsToNothing(tag, code, major) {
+	return `[${tag}] ${code} ${major} rounds to nothing at ${tag}, which takes three-decimal amounts in steps of 0.010.`;
+}
+/** A wire value as an exact Decimal: a finite number (a whole one must be safe) or strict decimal text. Else null. */
+function wireDecimal(wire) {
+	return typeof wire === "number" ? require_money.strictNumberDecimal(wire) : require_money.parseDecimal(wire, "plain");
+}
+/** `w` at storage scale, half-up; with `exact`, a wire naming a fraction of a storage unit throws `amount_invalid`. */
+function decodeWith(d, w, info, kind, exact = false) {
+	const scale = require_money.pow10(w.scale);
+	let multiplier;
+	if (d.family !== "iso-minor") multiplier = BigInt(info.storageScale);
+	else multiplier = kind === "pre-cutover" ? 1n : factorOf(d, info);
+	if (exact && w.units * multiplier % scale !== 0n) throw new require_money.MoneyError("amount_invalid", `[${d.tag}] ${require_money.formatDecimal(w)} is not a whole ${info.code} storage amount`);
+	return require_money.boundedMoney(require_money.mulDiv(w.units, multiplier, scale, "half-up"), info);
+}
+/** VNPay: a positive whole safe integer, as Medusa's `vnpayWireAmountToStorage` reads one. */
+function isWholePositive(w) {
+	const scale = require_money.pow10(w.scale);
+	return w.units > 0n && w.units % scale === 0n && w.units / scale <= BigInt(Number.MAX_SAFE_INTEGER);
+}
+/** Every inbound check: facade currency gate, convention, strict wire text, VNPay's "no amount", the sign. */
+function decodeChecked(d, wire, currency, convention, allowNegative, exact = false) {
+	if (isBlank(currency)) throw missingCurrency(d);
+	const info = facadeCurrency(d, currency);
+	const kind = d.gated ? requireConvention(d, convention) : null;
+	const w = wireDecimal(wire);
+	if (!w) throw new require_money.MoneyError("amount_invalid", `[${d.tag}] Not a wire amount: ${require_money.describeValue(wire)}`);
+	if (d.inboundWholePositive && !isWholePositive(w)) throw new require_money.MoneyError("amount_invalid", `[${d.tag}] No amount: ${d.tag} amounts are positive whole numbers, got ${require_money.describeValue(wire)}`);
+	if (w.units < 0n && !allowNegative) throw new require_money.MoneyError("amount_invalid", `[${d.tag}] Negative wire amount: ${require_money.describeValue(wire)}`);
+	return decodeWith(d, w, info, kind, exact);
+}
+function decodeWire(psp, wire, currency, convention) {
+	return decodeChecked(pspDescriptor(psp), wire, currency, convention, true);
+}
+/**
+* `decodeWire` that never throws: undefined wherever it would throw (null, undefined, `''`,
+* whitespace, unparseable or unsafe input, a missing, unknown or provider-only currency, one the
+* PSP's inbound gate refuses, VNPay's "no amount", an unknown PSP, a gated PSP without
+* `convention`: no hidden default) and for a negative amount unless `allowNegative`.
+*/
+function tryDecodeWire(psp, wire, currency, options = {}) {
+	try {
+		return decodeChecked(pspDescriptor(psp), wire, currency, options.convention, options.allowNegative === true);
+	} catch {
+		return;
+	}
+}
+/**
+* Internal: `tryDecodeWire` (no negatives) that is also undefined for a wire naming a fraction of a
+* storage unit (Airwallex 43.004 is not USD 43.00): the comparators' reading of a reported amount.
+*/
+function tryDecodeWireExactly(psp, wire, currency, convention) {
+	try {
+		return decodeChecked(pspDescriptor(psp), wire, currency, convention, false, true);
+	} catch {
+		return;
+	}
+}
+/** Internal: the major-unit text of `m` at its display digits, half-up (the pre-PSP-table ISO spelling). */
+function legacyIsoMajor(m) {
+	const { info, stored } = wireStoredDecimal(m);
+	const major = {
+		units: stored.units,
+		scale: require_money.storageExponent(info) + stored.scale
+	};
+	return require_money.formatDecimal(require_money.roundToScale(major, info.displayDigits, "half-up"));
+}
+/** Internal: one unit of the PSP's last wire digit as Money. */
+function wireUnit(psp, currency, convention) {
+	const d = pspDescriptor(psp);
+	const info = resolveWireCurrency(currency);
+	if (d.family === "iso-minor") return decodeWith(d, {
+		units: 1n,
+		scale: 0
+	}, info, d.gated ? requireConvention(d, convention) : null);
+	return require_money.boundedMoney(require_iso_minor.isoMinorFactor(info, wireDigitsOf(d, info)), info);
+}
+//#endregion
+//#region src/wire/breakdown.ts
+/**
+* `total` and its `parts` (same currency, non-negative, adding up to `total`) as integer wire
+* amounts whose sum is exactly `encodeWire(psp, total)`: the wire total split by largest
+* remainder over the stored parts. Throws `currency_mismatch`, `amount_invalid` (parts that do not
+* add up, or a negative part) or whatever `encodeWire` refuses.
+*/
+function wireBreakdown(psp, total, parts, convention) {
+	const { info } = wireStored(total);
+	const names = Object.keys(parts);
+	const weights = names.map((name) => {
+		const part = wireStored(parts[name]);
+		if (part.info.code !== info.code) throw new require_money.MoneyError("currency_mismatch", `Part ${name} is ${part.info.code}, total is ${info.code}`);
+		return part.units;
+	});
+	const partsTotal = weights.reduce((a, b) => a + b, 0n);
+	if (partsTotal !== BigInt(total.amount)) throw new require_money.MoneyError("amount_invalid", `Parts add up to ${partsTotal}, not the total ${total.amount}`);
+	const wireTotal = encodeWire(psp, total, {
+		convention,
+		allowZero: true
+	});
+	const shares = require_allocate.allocateUnits(BigInt(wireTotal), weights);
+	const out = {};
+	names.forEach((name, i) => {
+		out[name] = Number(shares[i]);
+	});
+	return {
+		total: wireTotal,
+		parts: out
+	};
+}
+//#endregion
+//#region src/wire/compare.ts
+/**
+* Whether a PSP-reported amount is `expected`, a Money or a FractionalMoney (Medusa's unrounded
+* session total). The expected wire is `encodeWire(psp, expected, { convention, allowZero: true })`
+* (a refusal means false); the reported one must decode exactly (strict like `tryDecodeWire`:
+* never `''` or an exponent, no negatives, and never a fraction of a storage unit) to the same
+* stored amount, so `'44.00'` matches a sent `'44'` and Airwallex `43.004` does not match `43`.
+* Never throws.
+*/
+function sameWireAmount(psp, reported, expected, options = {}) {
+	const { convention } = options;
+	if (options.reportedCurrency !== void 0) {
+		const reportedInfo = wireCurrency(options.reportedCurrency);
+		if (reportedInfo === null || reportedInfo !== wireCurrency(expected.currency)) return false;
+	}
+	const targets = expectedTargets(psp, expected, convention, options.acceptLegacyIsoDigits === true);
+	if (targets === null) return false;
+	const { target, legacy } = targets;
+	const decode = (value) => options.textOnly && typeof value !== "string" ? void 0 : tryDecodeWireExactly(psp, value, expected.currency, convention);
+	if (options.policy === "requested-exact-collected-covers" && options.requested !== void 0 && options.requested !== null) {
+		const requested = decode(options.requested);
+		const collected = decode(reported);
+		if (requested === void 0 || collected === void 0) return false;
+		return requested.amount === target.amount && collected.amount >= target.amount;
+	}
+	const got = decode(reported);
+	if (got === void 0) return false;
+	return got.amount === target.amount || got.amount === legacy?.amount;
+}
+/** What `expected` decodes to once sent (and in its legacy ISO-digit spelling), or null when it cannot be sent. */
+function expectedTargets(psp, expected, convention, acceptLegacy) {
+	try {
+		const d = pspDescriptor(psp);
+		const wire = encodeWire(psp, expected, {
+			convention,
+			allowZero: true
+		});
+		const target = decodeAt(psp, wire, expected, convention);
+		if (!acceptLegacy || d.family === "iso-minor") return {
+			target,
+			legacy: void 0
+		};
+		const spelling = legacyIsoMajor(expected);
+		return {
+			target,
+			legacy: spelling === String(wire) ? void 0 : decodeAt(psp, spelling, expected, convention)
+		};
+	} catch {
+		return null;
+	}
+}
+function decodeAt(psp, wire, expected, convention) {
+	return decodeWire(psp, wire, expected.currency, convention);
+}
+/**
+* One unit of the PSP's last wire digit, as Money: for ISO-minor PSPs `decodeWire(psp, 1)` (the
+* factor on an iso-minor-v2 payment, 1 storage unit on a pre-cutover one; gated PSPs need the
+* convention), for major PSPs `10^-wireDigits` major. The tolerance for `excessOver`.
+*/
+function oneWireUnit(psp, currency, convention) {
+	return wireUnit(psp, currency, convention);
+}
+/** The wire amount as it goes into Redis skip keys and idempotency keys: `String(wire)`, byte for byte. */
+function wireKeyPart(wire) {
+	return String(wire);
+}
+//#endregion
+//#region src/data/destinations.ts
+const pixel = (currencyCase, unit = "major-number") => ({
+	unit,
+	currencyCase,
+	accepts: "non-negative",
+	verified: true
+});
+const marketing = (currencyCase) => ({
+	unit: "major-number",
+	currencyCase,
+	accepts: "non-negative",
+	verified: true
+});
+const ledger = (unit = "major-number") => ({
+	unit,
+	currencyCase: "upper",
+	accepts: "any",
+	verified: true
+});
+const DESTINATIONS = {
+	meta: {
+		unit: "major-number",
+		currencyCase: "lower",
+		accepts: "positive",
+		verified: true
+	},
+	ga4: pixel("upper"),
+	"google-ads": pixel("upper"),
+	tiktok: pixel("upper"),
+	snapchat: pixel("upper"),
+	pinterest: pixel("upper", "major-string"),
+	klaviyo: marketing("lower"),
+	omnisend: marketing("lower"),
+	"omnisend-viewed-product": {
+		unit: "cents",
+		cents: "two-decimal",
+		currencyCase: "lower",
+		accepts: "non-negative",
+		verified: true
+	},
+	mailchimp: marketing("upper"),
+	goaffpro: marketing("lower"),
+	profitmetrics: marketing("upper"),
+	pixi: marketing("lower"),
+	flow: ledger(),
+	sendcloud: ledger(),
+	shipstation: ledger(),
+	shiprocket: ledger(),
+	shipbob: ledger(),
+	printful: ledger("major-string"),
+	ahamove: ledger(),
+	"amazon-mcf": ledger(),
+	skydropx: ledger(),
+	"royal-mail": ledger(),
+	sevdesk: ledger(),
+	"shopify-ajax": {
+		unit: "cents",
+		cents: "x100-storage",
+		currencyCase: "upper",
+		accepts: "any",
+		verified: true
+	}
+};
+//#endregion
+//#region src/wire/destinations.ts
+function descriptorOf(dest) {
+	if (typeof dest === "string" && require_own.hasOwnKey(DESTINATIONS, dest)) return DESTINATIONS[dest];
+	throw new require_money.MoneyError("wire_unsupported", `Unknown destination: ${require_money.describeValue(dest)}`);
+}
+/**
+* `m` as `dest` wants it: major units at the display digits (half-up) as a number or text per
+* destination (`as` overrides), or integer "cents" for Shopify AJAX and Omnisend `viewed product`;
+* the currency upper- or lower-case per destination. Undefined when the destination must not get
+* this amount (Meta: not positive; GA4, Google Ads, TikTok, Snapchat, Pinterest and marketing:
+* negative). Throws `wire_unsupported` for a currency the destination's unit is not defined for.
+*/
+function destinationAmount(dest, m, options = {}) {
+	const d = descriptorOf(dest);
+	const { info, value } = require_money.storedDecimal(m);
+	if (d.accepts === "positive" ? value.units <= 0n : d.accepts === "non-negative" && value.units < 0n) return void 0;
+	let amount;
+	if (d.unit === "cents") {
+		if (!(d.cents === "two-decimal" ? info.displayDigits === 2 : info.storageScale === 100)) throw new require_money.MoneyError("wire_unsupported", `${dest} has no documented integer unit for ${info.code}`);
+		const cents = require_money.mulDiv(value.units, 100n, BigInt(info.storageScale), "half-up");
+		amount = options.as === "string" ? cents.toString() : Number(cents);
+	} else {
+		const text = require_money.toMajorDecimal(m, { digits: "display" });
+		amount = (options.as ? options.as === "string" : d.unit === "major-string") ? text : Number(text);
+	}
+	return {
+		value: amount,
+		currency: d.currencyCase === "lower" ? require_money.medusaCurrencyCode(info.code) : info.code
+	};
+}
+/** A shopping-feed price: `'12.345 KWD'`, `'1200 JPY'`, `'19.99 USD'` (display digits, half-up). */
+function feedPrice(m) {
+	return `${require_money.toMajorDecimal(m, { digits: "display" })} ${require_money.storedDecimal(m).info.code}`;
+}
+/** Google micros (major x 10^6) as integer text, exactly: USD 1999 gives `'19990000'`. */
+function googleMicros(m) {
+	const { info, value } = require_money.storedDecimal(m);
+	return require_money.mulDiv(value.units, 1000000n, BigInt(info.storageScale), "half-up").toString();
+}
+/** First-party analytics money: the stored integer and the lower-case code (the ClickHouse `Int64` contract). */
+function eventMoney(m) {
+	const { info } = require_money.storedDecimal(m);
+	return {
+		value: m.amount,
+		currency: require_money.medusaCurrencyCode(info.code)
+	};
+}
+//#endregion
+//#region src/wire/presentment.ts
+/** Registry codes only, sorted: a provider-only code (Adyen CNH) or one the registry does not know is left out. */
+function knownCodes(codes) {
+	const known = [];
+	for (const code of codes) {
+		const info = wireCurrency(code);
+		if (info) known.push(info.code);
+	}
+	return known.sort();
+}
+/**
+* The PSP's presentment rules, as data: the union of currencies some account can charge, the
+* currencies that need an account in particular countries, and the account countries limited to
+* a list. For capability declarations that hold the rules themselves; `pspPresentmentCurrencies`
+* applies them to one account. Fresh collections on every call. An unknown PSP throws
+* `wire_unsupported`.
+*/
+function pspPresentment(psp) {
+	const d = pspDescriptor(psp);
+	const requires = PRESENTMENT_REQUIRES_ACCOUNT_COUNTRY[d.id] ?? {};
+	const allowsOnly = PRESENTMENT_ACCOUNT_COUNTRY_ALLOWS_ONLY[d.id] ?? {};
+	return Object.freeze({
+		currencies: new Set(knownCodes(d.presentmentCurrencies)),
+		currencyRequiresAccountCountry: new Map(knownCodes(Object.keys(requires)).map((code) => [code, new Set(requires[code])])),
+		accountCountryAllowsOnly: new Map(Object.keys(allowsOnly).map((country) => [country, new Set(knownCodes(allowsOnly[country]))]))
+	});
+}
+/**
+* The currencies `psp` lets an account present (charge buyers in). Without `accountCountry`, the
+* union over every account country; with it (ISO 3166 alpha-2, any case), only what an account
+* registered there can charge: Stripe's three-decimal five need a UAE account, PayPal's BRL, CNY
+* and MYR an in-country one, Airwallex cards on a US account take its documented 76 and on an MX
+* account MXN only. Not `pspCurrencies`, which is what the codec scales and the facade lets
+* through (Stripe's adds every two-decimal ISO code it accepts on the wire).
+*/
+function pspPresentmentCurrencies(psp, options = {}) {
+	const rules = pspPresentment(psp);
+	if (options.accountCountry === void 0) return rules.currencies;
+	const country = options.accountCountry.trim().toUpperCase();
+	const only = rules.accountCountryAllowsOnly.get(country);
+	const codes = [...rules.currencies].filter((code) => {
+		const required = rules.currencyRequiresAccountCountry.get(code);
+		return (required === void 0 || required.has(country)) && (only === void 0 || only.has(code));
+	});
+	return new Set(codes);
+}
+//#endregion
+//#region src/wire/provider-amount.ts
+/**
+* A provider's major-unit amount (finite number, or text read by the separator engine, which
+* strips the currency's symbol and code) as Money, rounded once to the storage digits. Null on
+* anything invalid (empty, unparseable, non-finite, negative without `allowNegative`, too large,
+* unknown currency), never 0.
+*/
+function parseProviderAmount(value, currency, options = {}) {
+	let major;
+	try {
+		if (typeof value === "number") {
+			if (!Number.isFinite(value)) return null;
+			major = value;
+		} else {
+			const read = require_number_text.readNumberText(value, {
+				decimalSeparator: options.decimalSeparator ?? ".",
+				allowTrailingText: options.allowTrailingText,
+				currency,
+				rounding: options.rounding ?? "half-up"
+			});
+			if ("reason" in read) return null;
+			major = require_money.formatDecimal({
+				units: BigInt(read.sign) * read.units,
+				scale: read.scale
+			});
+		}
+		if (!options.allowNegative && (typeof major === "number" ? major < 0 : major.startsWith("-"))) return null;
+		return require_money.fromMajor(major, currency, {
+			precision: "round",
+			rounding: options.rounding ?? "half-up"
+		});
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/wire/providers.ts
+/** RBI e-mandate cap Razorpay token registrations carry as `max_amount`: INR 15,000 (1,500,000 paise = stored). */
+const RAZORPAY_AFA_FREE_CAP = Object.freeze(require_money.fromMajor(RAZORPAY_AFA_FREE_CAP_MAJOR, "INR"));
+/**
+* The symbolic charge a saved-card setup makes: Paystack one major unit, Razorpay one INR (any
+* other currency is `wire_unsupported`), Mollie one smallest wire unit (`'0.01'`, `'1'` for ISK
+* and JPY), Adyen zero. Vault charges are always new, so the iso-minor-v2 convention applies.
+*/
+function verificationCharge(psp, currency) {
+	const code = assertPspCurrency(psp, currency);
+	let charge;
+	if (psp === "paystack") charge = require_money.fromMajor("1", code);
+	else if (psp === "razorpay") {
+		if (code !== "INR") throw new require_money.MoneyError("wire_unsupported", `[Razorpay] Verification charges are made in INR only, not ${code}.`);
+		charge = require_money.fromMajor("1", code);
+	} else if (psp === "mollie") charge = wireUnit("mollie", code);
+	else charge = require_money.boundedMoney(0n, resolveWireCurrency(code));
+	return {
+		wire: encodeWire(psp, charge, {
+			convention: ISO_MINOR_V2,
+			allowZero: true
+		}),
+		money: charge
+	};
+}
+/**
+* iyzico's price spelling, on the text (no float): canonical decimal (no trailing fraction zeros),
+* then `'.0'` when there is no `.` (`'10.50'` gives `'10.5'`, `'10.00'` gives `'10.0'`). Text that
+* is not a plain decimal throws `parse`.
+*/
+function iyzicoPrice(wire) {
+	const parsed = require_money.parseDecimal(wire, "plain");
+	if (!parsed) throw new require_money.MoneyError("parse", `Not an iyzico price: ${require_money.describeValue(wire)}`);
+	const text = require_money.toDecimalText(parsed);
+	return text.includes(".") ? text : `${text}.0`;
+}
+//#endregion
+//#region src/wire/slot.ts
+/** `m` for a slot context's `money` key. */
+function slotMoney(m) {
+	const { info } = require_money.storedDecimal(m);
+	return {
+		amount: m.amount,
+		currency_code: require_money.medusaCurrencyCode(info.code)
+	};
+}
+const isRecord = (value) => typeof value === "object" && value !== null;
+function read(amount, ...currencies) {
+	const info = currencies.map((c) => require_money.findCurrency(c, { allowHistoric: true })).find((c) => c !== null);
+	if (!info || amount === void 0 || amount === null) return void 0;
+	const stored = require_money.readStored(amount, info.code, { mode: "lenient" });
+	return stored ? slotMoney(stored) : void 0;
+}
+/**
+* The money a slot context carries: `context.money` when it is valid, else the legacy
+* `total ?? price` with the first known of `currency_code`, `currency`, read leniently (numbers, numeric text,
+* Medusa BigNumber shapes). Undefined when the amount or the currency is missing or unreadable.
+*/
+function readSlotMoney(context) {
+	if (!isRecord(context)) return void 0;
+	const money = context.money;
+	return (isRecord(money) ? read(money.amount, money.currency_code) : void 0) ?? read(context.total ?? context.price, context.currency_code, context.currency);
+}
+//#endregion
+Object.defineProperty(exports, "ISO_MINOR_V2", {
+	enumerable: true,
+	get: function() {
+		return ISO_MINOR_V2;
+	}
+});
+Object.defineProperty(exports, "PRE_CUTOVER", {
+	enumerable: true,
+	get: function() {
+		return PRE_CUTOVER;
+	}
+});
+Object.defineProperty(exports, "PSP_IDS", {
+	enumerable: true,
+	get: function() {
+		return PSP_IDS;
+	}
+});
+Object.defineProperty(exports, "RAZORPAY_AFA_FREE_CAP", {
+	enumerable: true,
+	get: function() {
+		return RAZORPAY_AFA_FREE_CAP;
+	}
+});
+Object.defineProperty(exports, "WIRE_SCALE_ISO_MINOR_V2", {
+	enumerable: true,
+	get: function() {
+		return WIRE_SCALE_ISO_MINOR_V2;
+	}
+});
+Object.defineProperty(exports, "WIRE_SCALE_KEY", {
+	enumerable: true,
+	get: function() {
+		return WIRE_SCALE_KEY;
+	}
+});
+Object.defineProperty(exports, "WIRE_SCALE_MARKER", {
+	enumerable: true,
+	get: function() {
+		return WIRE_SCALE_MARKER;
+	}
+});
+Object.defineProperty(exports, "assertPspCurrency", {
+	enumerable: true,
+	get: function() {
+		return assertPspCurrency;
+	}
+});
+Object.defineProperty(exports, "authorizeNetReversibleAmount", {
+	enumerable: true,
+	get: function() {
+		return authorizeNetReversibleAmount;
+	}
+});
+Object.defineProperty(exports, "conventionOf", {
+	enumerable: true,
+	get: function() {
+		return conventionOf;
+	}
+});
+Object.defineProperty(exports, "decodeWire", {
+	enumerable: true,
+	get: function() {
+		return decodeWire;
+	}
+});
+Object.defineProperty(exports, "destinationAmount", {
+	enumerable: true,
+	get: function() {
+		return destinationAmount;
+	}
+});
+Object.defineProperty(exports, "encodeWire", {
+	enumerable: true,
+	get: function() {
+		return encodeWire;
+	}
+});
+Object.defineProperty(exports, "eventMoney", {
+	enumerable: true,
+	get: function() {
+		return eventMoney;
+	}
+});
+Object.defineProperty(exports, "feedPrice", {
+	enumerable: true,
+	get: function() {
+		return feedPrice;
+	}
+});
+Object.defineProperty(exports, "googleMicros", {
+	enumerable: true,
+	get: function() {
+		return googleMicros;
+	}
+});
+Object.defineProperty(exports, "iyzicoPrice", {
+	enumerable: true,
+	get: function() {
+		return iyzicoPrice;
+	}
+});
+Object.defineProperty(exports, "jsonDecimalLiteral", {
+	enumerable: true,
+	get: function() {
+		return jsonDecimalLiteral;
+	}
+});
+Object.defineProperty(exports, "oneWireUnit", {
+	enumerable: true,
+	get: function() {
+		return oneWireUnit;
+	}
+});
+Object.defineProperty(exports, "parseProviderAmount", {
+	enumerable: true,
+	get: function() {
+		return parseProviderAmount;
+	}
+});
+Object.defineProperty(exports, "pspCurrencies", {
+	enumerable: true,
+	get: function() {
+		return pspCurrencies;
+	}
+});
+Object.defineProperty(exports, "pspDefaultCurrency", {
+	enumerable: true,
+	get: function() {
+		return pspDefaultCurrency;
+	}
+});
+Object.defineProperty(exports, "pspMinimumAmount", {
+	enumerable: true,
+	get: function() {
+		return pspMinimumAmount;
+	}
+});
+Object.defineProperty(exports, "pspPresentment", {
+	enumerable: true,
+	get: function() {
+		return pspPresentment;
+	}
+});
+Object.defineProperty(exports, "pspPresentmentCurrencies", {
+	enumerable: true,
+	get: function() {
+		return pspPresentmentCurrencies;
+	}
+});
+Object.defineProperty(exports, "pspSupportsCurrency", {
+	enumerable: true,
+	get: function() {
+		return pspSupportsCurrency;
+	}
+});
+Object.defineProperty(exports, "pspWireDigits", {
+	enumerable: true,
+	get: function() {
+		return pspWireDigits;
+	}
+});
+Object.defineProperty(exports, "readSlotMoney", {
+	enumerable: true,
+	get: function() {
+		return readSlotMoney;
+	}
+});
+Object.defineProperty(exports, "sameWireAmount", {
+	enumerable: true,
+	get: function() {
+		return sameWireAmount;
+	}
+});
+Object.defineProperty(exports, "slotMoney", {
+	enumerable: true,
+	get: function() {
+		return slotMoney;
+	}
+});
+Object.defineProperty(exports, "tryDecodeWire", {
+	enumerable: true,
+	get: function() {
+		return tryDecodeWire;
+	}
+});
+Object.defineProperty(exports, "verificationCharge", {
+	enumerable: true,
+	get: function() {
+		return verificationCharge;
+	}
+});
+Object.defineProperty(exports, "wireBreakdown", {
+	enumerable: true,
+	get: function() {
+		return wireBreakdown;
+	}
+});
+Object.defineProperty(exports, "wireFactor", {
+	enumerable: true,
+	get: function() {
+		return wireFactor;
+	}
+});
+Object.defineProperty(exports, "wireKeyPart", {
+	enumerable: true,
+	get: function() {
+		return wireKeyPart;
+	}
+});