@amboras-dev/money 0.0.0-stage → 0.1.0

package/dist/arithmetic-Bq-8mSal.cjs

@@ -0,0 +1,233 @@
+const require_money = require("./money-D5-vlv0h.cjs");
+const require_rounding = require("./rounding-oZ832yTD.cjs");
+const require_percent = require("./percent-Dt8vNIAW.cjs");
+//#region src/arithmetic.ts
+/** Internal: the shared currency of `a` and `b` and their stored integers. Throws `currency_mismatch`. */
+function pair(a, b, verb) {
+	const left = require_money.storedDecimal(a).info;
+	const right = require_money.storedDecimal(b).info;
+	if (left.code !== right.code) throw new require_money.MoneyError("currency_mismatch", `Cannot ${verb} ${left.code} and ${right.code}`);
+	return {
+		info: left,
+		x: BigInt(a.amount),
+		y: BigInt(b.amount)
+	};
+}
+const sign = (n) => n < 0n ? -1 : n > 0n ? 1 : 0;
+/** The validated stored integer of `m`. */
+const unitsOf = (m) => require_money.storedDecimal(m).value.units;
+function add(a, b) {
+	const { info, x, y } = pair(a, b, "add");
+	return require_money.boundedMoney(x + y, info);
+}
+function subtract(a, b) {
+	const { info, x, y } = pair(a, b, "subtract");
+	return require_money.boundedMoney(x - y, info);
+}
+/** The exact total of `items`, every one in `currency` (required, so an empty list has one). */
+function sum(items, currency) {
+	const info = require_money.resolveCurrency(currency, { allowHistoric: true });
+	let total = 0n;
+	for (const item of items) {
+		const own = require_money.storedDecimal(item).info;
+		if (own.code !== info.code) throw new require_money.MoneyError("currency_mismatch", `Cannot sum ${own.code} into ${info.code}`);
+		total += BigInt(item.amount);
+	}
+	return require_money.boundedMoney(total, info);
+}
+function integerOf(value, name) {
+	if (typeof value === "bigint") return value;
+	if (Number.isSafeInteger(value)) return BigInt(value);
+	throw new require_money.MoneyError("amount_invalid", `Ratio ${name} must be a safe integer or bigint, got ${require_money.describeValue(value)}`);
+}
+/** `m x numerator / denominator`, rounded once to a whole `unit`. */
+function scaled(m, numerator, denominator, options) {
+	const { info } = require_money.storedDecimal(m);
+	if (denominator === 0n) throw new require_money.MoneyError("amount_invalid", "Division by zero");
+	const units = require_rounding.mulDivToUnit(BigInt(m.amount), numerator, denominator, info, options.unit ?? "storage", options.rounding);
+	return require_money.boundedMoney(units, info);
+}
+/**
+* `m x factor`, rounded once to a whole `unit` (default `'storage'`) with `rounding`
+* (default half-up). A number is taken by its shortest decimal text (as JSON carries it);
+* text is exact decimal; a Ratio is exact. Integer factors are exact. A non-finite factor or
+* a zero denominator throws `amount_invalid`.
+*/
+function multiply(m, factor, options = {}) {
+	if (typeof factor === "object" && factor !== null) return scaled(m, integerOf(factor.numerator, "numerator"), integerOf(factor.denominator, "denominator"), options);
+	const value = require_money.decimalOf(factor);
+	return scaled(m, value.units, require_money.pow10(value.scale), options);
+}
+/** `m / divisor`, rounded once like `multiply`. Divisor 0 throws `amount_invalid`. */
+function divide(m, divisor, options = {}) {
+	const value = require_money.decimalOf(divisor);
+	return scaled(m, require_money.pow10(value.scale), value.units, options);
+}
+/** `percent` percent of `m` (12.5 is an eighth), rounded once like `multiply` (default unit `'storage'`). */
+function percentOf(m, percent, options = {}) {
+	const value = require_money.decimalOf(percent);
+	return scaled(m, value.units, require_percent.hundredPercent(value.scale), options);
+}
+/** `-1`, `0` or `1`. Different currencies throw `currency_mismatch`. */
+function compare(a, b) {
+	const { x, y } = pair(a, b, "compare");
+	return sign(x - y);
+}
+/** Same currency and same amount. Different currencies are `false`, never a throw. */
+function equals(a, b) {
+	return require_money.storedDecimal(a).info.code === require_money.storedDecimal(b).info.code && a.amount === b.amount;
+}
+function isZero(m) {
+	return unitsOf(m) === 0n;
+}
+function isPositive(m) {
+	return require_money.isPositiveDecimal(require_money.storedDecimal(m).value);
+}
+function isNegative(m) {
+	return unitsOf(m) < 0n;
+}
+/** The smallest of the amounts, all in one currency (the first of equals). */
+function min(first, ...rest) {
+	require_money.storedDecimal(first);
+	return rest.reduce((low, m) => compare(m, low) < 0 ? m : low, first);
+}
+/** The largest of the amounts, all in one currency (the first of equals). */
+function max(first, ...rest) {
+	require_money.storedDecimal(first);
+	return rest.reduce((high, m) => compare(m, high) > 0 ? m : high, first);
+}
+/** `m` limited to `[min, max]` (either optional, same currency). `min` above `max` throws `amount_invalid`. */
+function clamp(m, bounds) {
+	if (bounds.min && bounds.max && compare(bounds.min, bounds.max) > 0) throw new require_money.MoneyError("amount_invalid", `Clamp bounds are reversed: ${bounds.min.amount} > ${bounds.max.amount}`);
+	if (bounds.min && compare(m, bounds.min) < 0) return bounds.min;
+	if (bounds.max && compare(m, bounds.max) > 0) return bounds.max;
+	return m;
+}
+/** What is left: `max(0, total - used)`. */
+function remaining(total, used) {
+	const { info, x, y } = pair(total, used, "subtract");
+	return require_money.boundedMoney(x > y ? x - y : 0n, info);
+}
+function checkTolerance(tolerance, info) {
+	const own = require_money.storedDecimal(tolerance).info;
+	if (own.code !== info.code) throw new require_money.MoneyError("currency_mismatch", `Tolerance in ${own.code}, amounts in ${info.code}`);
+	if (tolerance.amount < 0) throw new require_money.MoneyError("amount_invalid", `Tolerance must not be negative, got ${tolerance.amount}`);
+	return BigInt(tolerance.amount);
+}
+/** `|a - b| <= tolerance` (`<` with `inclusive: false`), all one currency. A negative tolerance throws `amount_invalid`. */
+function within(a, b, tolerance, options = {}) {
+	const { info, x, y } = pair(a, b, "compare");
+	const limit = checkTolerance(tolerance, info);
+	const gap = x > y ? x - y : y - x;
+	return options.inclusive === false ? gap < limit : gap <= limit;
+}
+/** `d = a - b`; `d` below `tolerance` counts as rounding and gives 0, else `d` (Stripe `refundSyncDelta`). */
+function excessOver(a, b, tolerance) {
+	const { info, x, y } = pair(a, b, "subtract");
+	const limit = checkTolerance(tolerance, info);
+	const delta = x - y;
+	return require_money.boundedMoney(delta < limit ? 0n : delta, info);
+}
+//#endregion
+Object.defineProperty(exports, "add", {
+	enumerable: true,
+	get: function() {
+		return add;
+	}
+});
+Object.defineProperty(exports, "clamp", {
+	enumerable: true,
+	get: function() {
+		return clamp;
+	}
+});
+Object.defineProperty(exports, "compare", {
+	enumerable: true,
+	get: function() {
+		return compare;
+	}
+});
+Object.defineProperty(exports, "divide", {
+	enumerable: true,
+	get: function() {
+		return divide;
+	}
+});
+Object.defineProperty(exports, "equals", {
+	enumerable: true,
+	get: function() {
+		return equals;
+	}
+});
+Object.defineProperty(exports, "excessOver", {
+	enumerable: true,
+	get: function() {
+		return excessOver;
+	}
+});
+Object.defineProperty(exports, "isNegative", {
+	enumerable: true,
+	get: function() {
+		return isNegative;
+	}
+});
+Object.defineProperty(exports, "isPositive", {
+	enumerable: true,
+	get: function() {
+		return isPositive;
+	}
+});
+Object.defineProperty(exports, "isZero", {
+	enumerable: true,
+	get: function() {
+		return isZero;
+	}
+});
+Object.defineProperty(exports, "max", {
+	enumerable: true,
+	get: function() {
+		return max;
+	}
+});
+Object.defineProperty(exports, "min", {
+	enumerable: true,
+	get: function() {
+		return min;
+	}
+});
+Object.defineProperty(exports, "multiply", {
+	enumerable: true,
+	get: function() {
+		return multiply;
+	}
+});
+Object.defineProperty(exports, "percentOf", {
+	enumerable: true,
+	get: function() {
+		return percentOf;
+	}
+});
+Object.defineProperty(exports, "remaining", {
+	enumerable: true,
+	get: function() {
+		return remaining;
+	}
+});
+Object.defineProperty(exports, "subtract", {
+	enumerable: true,
+	get: function() {
+		return subtract;
+	}
+});
+Object.defineProperty(exports, "sum", {
+	enumerable: true,
+	get: function() {
+		return sum;
+	}
+});
+Object.defineProperty(exports, "within", {
+	enumerable: true,
+	get: function() {
+		return within;
+	}
+});

package/dist/arithmetic-C-Q_aI49.js

@@ -0,0 +1,132 @@
+import { E as resolveCurrency, Q as describeValue, Z as MoneyError, at as isPositiveDecimal, ct as pow10, s as storedDecimal, t as boundedMoney, z as decimalOf } from "./money-CIgELekG.js";
+import { t as mulDivToUnit } from "./rounding-CVAPEfq_.js";
+import { n as hundredPercent } from "./percent-CKVI_c-m.js";
+//#region src/arithmetic.ts
+/** Internal: the shared currency of `a` and `b` and their stored integers. Throws `currency_mismatch`. */
+function pair(a, b, verb) {
+	const left = storedDecimal(a).info;
+	const right = storedDecimal(b).info;
+	if (left.code !== right.code) throw new MoneyError("currency_mismatch", `Cannot ${verb} ${left.code} and ${right.code}`);
+	return {
+		info: left,
+		x: BigInt(a.amount),
+		y: BigInt(b.amount)
+	};
+}
+const sign = (n) => n < 0n ? -1 : n > 0n ? 1 : 0;
+/** The validated stored integer of `m`. */
+const unitsOf = (m) => storedDecimal(m).value.units;
+function add(a, b) {
+	const { info, x, y } = pair(a, b, "add");
+	return boundedMoney(x + y, info);
+}
+function subtract(a, b) {
+	const { info, x, y } = pair(a, b, "subtract");
+	return boundedMoney(x - y, info);
+}
+/** The exact total of `items`, every one in `currency` (required, so an empty list has one). */
+function sum(items, currency) {
+	const info = resolveCurrency(currency, { allowHistoric: true });
+	let total = 0n;
+	for (const item of items) {
+		const own = storedDecimal(item).info;
+		if (own.code !== info.code) throw new MoneyError("currency_mismatch", `Cannot sum ${own.code} into ${info.code}`);
+		total += BigInt(item.amount);
+	}
+	return boundedMoney(total, info);
+}
+function integerOf(value, name) {
+	if (typeof value === "bigint") return value;
+	if (Number.isSafeInteger(value)) return BigInt(value);
+	throw new MoneyError("amount_invalid", `Ratio ${name} must be a safe integer or bigint, got ${describeValue(value)}`);
+}
+/** `m x numerator / denominator`, rounded once to a whole `unit`. */
+function scaled(m, numerator, denominator, options) {
+	const { info } = storedDecimal(m);
+	if (denominator === 0n) throw new MoneyError("amount_invalid", "Division by zero");
+	const units = mulDivToUnit(BigInt(m.amount), numerator, denominator, info, options.unit ?? "storage", options.rounding);
+	return boundedMoney(units, info);
+}
+/**
+* `m x factor`, rounded once to a whole `unit` (default `'storage'`) with `rounding`
+* (default half-up). A number is taken by its shortest decimal text (as JSON carries it);
+* text is exact decimal; a Ratio is exact. Integer factors are exact. A non-finite factor or
+* a zero denominator throws `amount_invalid`.
+*/
+function multiply(m, factor, options = {}) {
+	if (typeof factor === "object" && factor !== null) return scaled(m, integerOf(factor.numerator, "numerator"), integerOf(factor.denominator, "denominator"), options);
+	const value = decimalOf(factor);
+	return scaled(m, value.units, pow10(value.scale), options);
+}
+/** `m / divisor`, rounded once like `multiply`. Divisor 0 throws `amount_invalid`. */
+function divide(m, divisor, options = {}) {
+	const value = decimalOf(divisor);
+	return scaled(m, pow10(value.scale), value.units, options);
+}
+/** `percent` percent of `m` (12.5 is an eighth), rounded once like `multiply` (default unit `'storage'`). */
+function percentOf(m, percent, options = {}) {
+	const value = decimalOf(percent);
+	return scaled(m, value.units, hundredPercent(value.scale), options);
+}
+/** `-1`, `0` or `1`. Different currencies throw `currency_mismatch`. */
+function compare(a, b) {
+	const { x, y } = pair(a, b, "compare");
+	return sign(x - y);
+}
+/** Same currency and same amount. Different currencies are `false`, never a throw. */
+function equals(a, b) {
+	return storedDecimal(a).info.code === storedDecimal(b).info.code && a.amount === b.amount;
+}
+function isZero(m) {
+	return unitsOf(m) === 0n;
+}
+function isPositive(m) {
+	return isPositiveDecimal(storedDecimal(m).value);
+}
+function isNegative(m) {
+	return unitsOf(m) < 0n;
+}
+/** The smallest of the amounts, all in one currency (the first of equals). */
+function min(first, ...rest) {
+	storedDecimal(first);
+	return rest.reduce((low, m) => compare(m, low) < 0 ? m : low, first);
+}
+/** The largest of the amounts, all in one currency (the first of equals). */
+function max(first, ...rest) {
+	storedDecimal(first);
+	return rest.reduce((high, m) => compare(m, high) > 0 ? m : high, first);
+}
+/** `m` limited to `[min, max]` (either optional, same currency). `min` above `max` throws `amount_invalid`. */
+function clamp(m, bounds) {
+	if (bounds.min && bounds.max && compare(bounds.min, bounds.max) > 0) throw new MoneyError("amount_invalid", `Clamp bounds are reversed: ${bounds.min.amount} > ${bounds.max.amount}`);
+	if (bounds.min && compare(m, bounds.min) < 0) return bounds.min;
+	if (bounds.max && compare(m, bounds.max) > 0) return bounds.max;
+	return m;
+}
+/** What is left: `max(0, total - used)`. */
+function remaining(total, used) {
+	const { info, x, y } = pair(total, used, "subtract");
+	return boundedMoney(x > y ? x - y : 0n, info);
+}
+function checkTolerance(tolerance, info) {
+	const own = storedDecimal(tolerance).info;
+	if (own.code !== info.code) throw new MoneyError("currency_mismatch", `Tolerance in ${own.code}, amounts in ${info.code}`);
+	if (tolerance.amount < 0) throw new MoneyError("amount_invalid", `Tolerance must not be negative, got ${tolerance.amount}`);
+	return BigInt(tolerance.amount);
+}
+/** `|a - b| <= tolerance` (`<` with `inclusive: false`), all one currency. A negative tolerance throws `amount_invalid`. */
+function within(a, b, tolerance, options = {}) {
+	const { info, x, y } = pair(a, b, "compare");
+	const limit = checkTolerance(tolerance, info);
+	const gap = x > y ? x - y : y - x;
+	return options.inclusive === false ? gap < limit : gap <= limit;
+}
+/** `d = a - b`; `d` below `tolerance` counts as rounding and gives 0, else `d` (Stripe `refundSyncDelta`). */
+function excessOver(a, b, tolerance) {
+	const { info, x, y } = pair(a, b, "subtract");
+	const limit = checkTolerance(tolerance, info);
+	const delta = x - y;
+	return boundedMoney(delta < limit ? 0n : delta, info);
+}
+//#endregion
+export { within as _, equals as a, isPositive as c, min as d, multiply as f, sum as g, subtract as h, divide as i, isZero as l, remaining as m, clamp as n, excessOver as o, percentOf as p, compare as r, isNegative as s, add as t, max as u };

package/dist/billing.cjs

@@ -0,0 +1,184 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_money = require("./money-D5-vlv0h.cjs");
+const require_percent = require("./percent-Dt8vNIAW.cjs");
+//#region src/billing/credits.ts
+function wholeNumber(value, name, min) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < min) throw new require_money.MoneyError("amount_invalid", `${name} must be an integer >= ${min}, got ${require_money.describeValue(value)}`);
+	return BigInt(value);
+}
+/**
+* Fraction digits a float USD cost is held to before the ceil: 1e-8 USD, the granularity of
+* orch `costUsdToCredits`' 1e-6-credit drift epsilon. Coarse enough to absorb float noise
+* (`0.07 * 3` is 0.21000000000000002), fine enough to keep sub-micro costs (1e-7 gives 1).
+*/
+const FLOAT_USD_DIGITS = 8;
+/**
+* Credits for a USD cost: `ceil(usd x 100)` (0.07 gives 7, 1.1 gives 110, 0.0049 and 1e-7
+* give 1). Text and Money are exact. A number is first rounded half-even to 8 decimals, so
+* float noise never adds a credit (`0.07 * 3` gives 21, `1.1 * 1.1` gives 121). USD Money is
+* cents already. A negative cost throws `amount_invalid`.
+*/
+function usdToCredits(usd) {
+	let cents;
+	if (typeof usd === "object" && usd !== null) {
+		const { info } = require_money.storedDecimal(usd);
+		if (info.code !== "USD") throw new require_money.MoneyError("currency_mismatch", `Credits are USD cents, got ${info.code}`);
+		cents = usd.amount;
+	} else {
+		const parsed = require_money.decimalOf(usd, true, "usd");
+		const exact = require_money.formatDecimal(typeof usd === "number" ? require_money.roundToScale(parsed, FLOAT_USD_DIGITS, "half-even") : parsed);
+		cents = require_money.fromMajor(exact, "USD", {
+			precision: "round",
+			rounding: "ceil",
+			field: "usd"
+		}).amount;
+	}
+	if (cents < 0) throw new require_money.MoneyError("amount_invalid", `A USD cost must not be negative, got ${require_money.describeValue(usd)}`);
+	return cents;
+}
+/** The USD a number of credits is worth: `credits / 100`, exact. */
+function creditsToUsd(credits) {
+	return require_money.toDecimalText({
+		units: wholeNumber(credits, "credits", Number.MIN_SAFE_INTEGER),
+		scale: 2
+	});
+}
+/**
+* The credits charged for a share (0..1) of a quoted run: `min(quoted, ceil(quoted x share))`,
+* with the product held to 6 decimals (half-up) before the ceil, as the quote does, so a float
+* share such as 0.28000000000000003 never adds a credit.
+*/
+function prorateCredits(quoted, share) {
+	const q = wholeNumber(quoted, "quoted", 0);
+	const s = require_money.decimalOf(share, false, "share");
+	const product = require_money.roundToScale({
+		units: q * s.units,
+		scale: s.scale
+	}, 6, "half-up");
+	const charged = require_money.roundToScale(product, 0, "ceil").units;
+	return Number(charged < q ? charged : q);
+}
+/** Credits rounded up to a whole `step` (default 50) for a quote: `ceil(credits / step) x step`. */
+function bucketCredits(credits, step = 50) {
+	const c = wholeNumber(credits, "credits", Number.MIN_SAFE_INTEGER);
+	const s = wholeNumber(step, "step", 1);
+	return Number(require_money.divRound(c, s, "ceil") * s);
+}
+//#endregion
+//#region src/billing/plans.ts
+function checkSame(m, other, verb) {
+	const info = require_money.storedDecimal(m).info;
+	const own = require_money.storedDecimal(other).info;
+	if (own.code !== info.code) throw new require_money.MoneyError("currency_mismatch", `Cannot ${verb} ${own.code} with ${info.code}`);
+	return info;
+}
+/** The yearly price: `yearly` when set, else `monthly x 12`. */
+function annualPrice(input) {
+	const info = require_money.storedDecimal(input.monthly).info;
+	if (input.yearly !== null && input.yearly !== void 0) {
+		checkSame(input.monthly, input.yearly, "price");
+		return input.yearly;
+	}
+	return require_money.boundedMoney(BigInt(input.monthly.amount) * 12n, info);
+}
+/** `yearly / 12` half-up to a storage unit (a cent); whole-dollar headlines use `roundToUnit(..., { unit: 'major' })`. */
+function monthlyEquivalent(yearly) {
+	const { info } = require_money.storedDecimal(yearly);
+	return require_money.boundedMoney(require_money.divRound(BigInt(yearly.amount), 12n, "half-up"), info);
+}
+/** A percent in 0..100, else `amount_invalid`. */
+function couponPercent(value, name) {
+	const pct = require_money.decimalOf(value, false, name);
+	if (pct.units > require_percent.hundredPercent(pct.scale)) throw new require_money.MoneyError("amount_invalid", `${name} must be at most 100, got ${require_money.describeValue(value)}`);
+	return pct;
+}
+/**
+* `m` after `coupons`. `'sequential'` (default, Stripe): in order, each on what the previous
+* left, a percent taking `round(amount x pct / 100)` half-up, clamped at 0 after each.
+* `'additive'`: the percents summed and taken in one rounding, plus the amounts, clamped at 0.
+* An amount-off coupon in another currency throws `currency_mismatch`.
+*/
+function applyCoupons(m, coupons, options = {}) {
+	const { info } = require_money.storedDecimal(m);
+	let amount = BigInt(m.amount);
+	const percentCut = (base, value) => require_percent.percentOfUnits(base, couponPercent(value, "percentOff"), "half-up");
+	if (options.mode === "additive") {
+		let percents = {
+			units: 0n,
+			scale: 0
+		};
+		let off = 0n;
+		for (const c of coupons) if ("amountOff" in c) {
+			checkSame(m, c.amountOff, "apply a coupon in");
+			off += BigInt(c.amountOff.amount);
+		} else percents = require_money.addDecimal(percents, couponPercent(c.percentOff, "percentOff"));
+		const cut = require_percent.percentOfUnits(amount, percents, "half-up") + off;
+		return require_money.boundedMoney(amount > cut ? amount - cut : 0n, info);
+	}
+	for (const c of coupons) {
+		if ("amountOff" in c) {
+			checkSame(m, c.amountOff, "apply a coupon in");
+			amount -= BigInt(c.amountOff.amount);
+		} else amount -= percentCut(amount, c.percentOff);
+		if (amount < 0n) amount = 0n;
+	}
+	return require_money.boundedMoney(amount, info);
+}
+/**
+* The line amount that is still `m` after the subscription's percent coupons take their cut
+* (Stripe discounts a negative invoice line too). A verbatim port of orch `grossUpCredit`,
+* float arithmetic included, because a credit already granted must not change by a cent:
+* `Math.round(m / prod(1 - p / 100))` with the product taken in float64, so a tie is resolved
+* by the float product (9 cents at [10, 20] gives 12, since 0.9 x 0.8 is 0.7200000000000001);
+* when the kept share is not positive (100% off), `m` unchanged.
+* It inverts `applyCoupons` exactly for one percent coupon. For stacked percents it can miss
+* by a cent (about 4% of amounts at [10, 20] or [30, 15]): Stripe rounds each coupon's cut,
+* while this divides by the unrounded product (11 cents at [10, 20] grosses up to 15, which
+* the coupons take to 10).
+*/
+function grossUpForPercentOffs(m, percents) {
+	const { info } = require_money.storedDecimal(m);
+	const kept = percents.reduce((share, value) => {
+		return share * (1 - Number(require_money.formatDecimal(require_money.decimalOf(value, true, "percent"))) / 100);
+	}, 1);
+	if (!(kept > 0)) return m;
+	return require_money.boundedMoney(BigInt(Math.round(m.amount / kept)), info);
+}
+//#endregion
+//#region src/billing/usage.ts
+const USD_DIGITS = 6;
+/**
+* The exact sum of `quantity x rate x multiplier` over `lines`, rounded half-up once to 6
+* decimals. Replaces the token-cost formulas (`computeCost`, the unpriced-model fallback,
+* the cloner's `estimateCost`). Each line needs exactly one of `usdPerMillion` / `usdPerUnit`.
+*/
+function usdCost(lines) {
+	let total = {
+		units: 0n,
+		scale: 0
+	};
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const perMillion = line?.usdPerMillion !== void 0;
+		if (perMillion === (line?.usdPerUnit !== void 0)) throw new require_money.MoneyError("amount_invalid", `lines[${i}] needs exactly one of usdPerMillion and usdPerUnit, got ${require_money.describeValue(line)}`);
+		const quantity = require_money.decimalOf(line.quantity, true, `lines[${i}].quantity`);
+		const rate = require_money.decimalOf(perMillion ? line.usdPerMillion : line.usdPerUnit, true, `lines[${i}].rate`);
+		const multiplier = require_money.decimalOf(line.multiplier ?? 1, true, `lines[${i}].multiplier`);
+		const cost = require_money.multiplyDecimal(require_money.multiplyDecimal(quantity, rate), multiplier);
+		total = require_money.addDecimal(total, perMillion ? {
+			units: cost.units,
+			scale: cost.scale + 6
+		} : cost);
+	}
+	return require_money.toDecimalText(require_money.roundToScale(total, USD_DIGITS, "half-up"));
+}
+//#endregion
+exports.annualPrice = annualPrice;
+exports.applyCoupons = applyCoupons;
+exports.bucketCredits = bucketCredits;
+exports.creditsToUsd = creditsToUsd;
+exports.grossUpForPercentOffs = grossUpForPercentOffs;
+exports.monthlyEquivalent = monthlyEquivalent;
+exports.prorateCredits = prorateCredits;
+exports.usdCost = usdCost;
+exports.usdToCredits = usdToCredits;

package/dist/billing.d.cts

@@ -0,0 +1,81 @@
+import { L as DecimalText, r as Money } from "./money-CbhsT0fB.cjs";
+//#region src/billing/usage.d.ts
+/** USD with sub-cent precision, as canonical decimal text (`'0.001234'`). Never merchant money. */
+type UsdAmount = DecimalText;
+interface UsdCostLine {
+  /** Tokens, seconds, images...; negative for an adjustment. */
+  quantity: number;
+  /** USD per million units (token prices). Give this or `usdPerUnit`. */
+  usdPerMillion?: number | DecimalText;
+  /** USD per unit. */
+  usdPerUnit?: number | DecimalText;
+  /** A surcharge multiplier (long-context 2x, 1.5x). Default 1. */
+  multiplier?: number | DecimalText;
+}
+/**
+ * The exact sum of `quantity x rate x multiplier` over `lines`, rounded half-up once to 6
+ * decimals. Replaces the token-cost formulas (`computeCost`, the unpriced-model fallback,
+ * the cloner's `estimateCost`). Each line needs exactly one of `usdPerMillion` / `usdPerUnit`.
+ */
+export declare function usdCost(lines: readonly UsdCostLine[]): UsdAmount;
+//#endregion
+//#region src/billing/credits.d.ts
+/**
+ * Credits for a USD cost: `ceil(usd x 100)` (0.07 gives 7, 1.1 gives 110, 0.0049 and 1e-7
+ * give 1). Text and Money are exact. A number is first rounded half-even to 8 decimals, so
+ * float noise never adds a credit (`0.07 * 3` gives 21, `1.1 * 1.1` gives 121). USD Money is
+ * cents already. A negative cost throws `amount_invalid`.
+ */
+export declare function usdToCredits(usd: UsdAmount | number | Money): number;
+/** The USD a number of credits is worth: `credits / 100`, exact. */
+export declare function creditsToUsd(credits: number): UsdAmount;
+/**
+ * The credits charged for a share (0..1) of a quoted run: `min(quoted, ceil(quoted x share))`,
+ * with the product held to 6 decimals (half-up) before the ceil, as the quote does, so a float
+ * share such as 0.28000000000000003 never adds a credit.
+ */
+export declare function prorateCredits(quoted: number, share: number | DecimalText): number;
+/** Credits rounded up to a whole `step` (default 50) for a quote: `ceil(credits / step) x step`. */
+export declare function bucketCredits(credits: number, step?: number): number;
+//#endregion
+//#region src/billing/plans.d.ts
+/** The yearly price: `yearly` when set, else `monthly x 12`. */
+export declare function annualPrice(input: {
+  monthly: Money;
+  yearly?: Money | null;
+}): Money;
+/** `yearly / 12` half-up to a storage unit (a cent); whole-dollar headlines use `roundToUnit(..., { unit: 'major' })`. */
+export declare function monthlyEquivalent(yearly: Money): Money;
+type Coupon = {
+  readonly percentOff: number | DecimalText;
+} | {
+  readonly amountOff: Money;
+};
+/**
+ * `m` after `coupons`. `'sequential'` (default, Stripe): in order, each on what the previous
+ * left, a percent taking `round(amount x pct / 100)` half-up, clamped at 0 after each.
+ * `'additive'`: the percents summed and taken in one rounding, plus the amounts, clamped at 0.
+ * An amount-off coupon in another currency throws `currency_mismatch`.
+ */
+export declare function applyCoupons(m: Money, coupons: readonly Coupon[], options?: {
+  mode?: 'sequential' | 'additive';
+}): Money;
+/**
+ * The line amount that is still `m` after the subscription's percent coupons take their cut
+ * (Stripe discounts a negative invoice line too). A verbatim port of orch `grossUpCredit`,
+ * float arithmetic included, because a credit already granted must not change by a cent:
+ * `Math.round(m / prod(1 - p / 100))` with the product taken in float64, so a tie is resolved
+ * by the float product (9 cents at [10, 20] gives 12, since 0.9 x 0.8 is 0.7200000000000001);
+ * when the kept share is not positive (100% off), `m` unchanged.
+ * It inverts `applyCoupons` exactly for one percent coupon. For stacked percents it can miss
+ * by a cent (about 4% of amounts at [10, 20] or [30, 15]): Stripe rounds each coupon's cut,
+ * while this divides by the unrounded product (11 cents at [10, 20] grosses up to 15, which
+ * the coupons take to 10).
+ */
+export declare function grossUpForPercentOffs(m: Money, percents: readonly (number | DecimalText)[]): Money;
+//#endregion
+//#region src/billing.d.ts
+/** USD cents: Money in USD (USD stored amounts are cents). */
+export type UsdCents = Money;
+//#endregion
+export type { Coupon, UsdAmount, UsdCostLine };