/** * Server-owned, versioned credit price book. * * Prices are a business decision, not a code default: this module never * invents a price. It parses an explicit `OPT_CREDIT_PRICE_BOOK` JSON document * and fails closed when it is missing or invalid, so the checkout route can * answer "price book not configured" instead of charging an arbitrary amount. * * Expected shape (all money in minor units, all quantities safe integers): * * { * "version": "2026-11-01", * "currency": "SEK", * "packs": [{ "id": "starter", "credits": 100, "amountMinor": 9900 }], * "metering": { * "pagesPerCredit": 5, * "inputTokensPerCredit": 20000, * "outputTokensPerCredit": 4000 * } * } */ export interface CreditPack { id: string; credits: number; amountMinor: number; } export interface CreditMetering { pagesPerCredit: number; inputTokensPerCredit: number; outputTokensPerCredit: number; } export interface CreditPriceBook { version: string; currency: string; packs: readonly CreditPack[]; metering: CreditMetering; } const MAX_SAFE = Number.MAX_SAFE_INTEGER; function safePositive(value: unknown): value is number { return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 && value <= MAX_SAFE; } function safePositiveOrZero(value: unknown): value is number { return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 && value <= MAX_SAFE; } function parsePack(raw: unknown, currency: string): CreditPack { if (!raw || typeof raw !== 'object' || Array.isArray(raw)) { throw new Error('Each credit pack must be an object'); } const pack = raw as Record; if ( typeof pack.id !== 'string' || !/^[a-z0-9][a-z0-9_-]{0,63}$/.test(pack.id) || !safePositive(pack.credits) || !safePositive(pack.amountMinor) || (pack.currency !== undefined && pack.currency !== currency) ) { throw new Error('Invalid credit pack'); } return { id: pack.id, credits: pack.credits, amountMinor: pack.amountMinor }; } export function parseCreditPriceBook(raw: unknown): CreditPriceBook { if (!raw || typeof raw !== 'object' || Array.isArray(raw)) { throw new Error('Price book must be an object'); } const doc = raw as Record; const version = doc.version; const currency = doc.currency; if ( typeof version !== 'string' || !/^\d{4}-\d{2}-\d{2}(?:\.\d+)?$/.test(version) || typeof currency !== 'string' || !/^[A-Z]{3}$/.test(currency) || !Array.isArray(doc.packs) || doc.packs.length === 0 || doc.packs.length > 100 ) { throw new Error('Invalid price book header or packs'); } const packs = doc.packs.map((pack) => parsePack(pack, currency)); const ids = new Set(packs.map((pack) => pack.id)); if (ids.size !== packs.length) throw new Error('Duplicate credit pack id'); if (!doc.metering || typeof doc.metering !== 'object' || Array.isArray(doc.metering)) { throw new Error('Price book metering is required'); } const metering = doc.metering as Record; if ( !safePositive(metering.pagesPerCredit) || !safePositive(metering.inputTokensPerCredit) || !safePositive(metering.outputTokensPerCredit) ) { throw new Error('Invalid metering rates'); } return { version, currency, packs, metering: { pagesPerCredit: metering.pagesPerCredit, inputTokensPerCredit: metering.inputTokensPerCredit, outputTokensPerCredit: metering.outputTokensPerCredit, }, }; } /** Returns `undefined` (fail closed) when the price book is absent or invalid. */ export function readCreditPriceBook(env: NodeJS.ProcessEnv = process.env): CreditPriceBook | undefined { const raw = env.OPT_CREDIT_PRICE_BOOK; if (!raw || !raw.trim()) return undefined; try { return parseCreditPriceBook(JSON.parse(raw)); } catch { return undefined; } } export function findPack(book: CreditPriceBook, packId: string): CreditPack | undefined { return book.packs.find((pack) => pack.id === packId); } /** Round each metered unit up to its billing block, exactly like credit-quote. */ export function creditsForUsage( book: CreditPriceBook, units: { pages: number; inputTokens: number; outputTokens: number }, ): number { if ( !safePositiveOrZero(units.pages) || !safePositiveOrZero(units.inputTokens) || !safePositiveOrZero(units.outputTokens) ) { throw new Error('Usage units must be nonnegative safe integers'); } const blocks = Math.ceil(units.pages / book.metering.pagesPerCredit) + Math.ceil(units.inputTokens / book.metering.inputTokensPerCredit) + Math.ceil(units.outputTokens / book.metering.outputTokensPerCredit); if (!Number.isSafeInteger(blocks) || blocks < 0) { throw new Error('Credit estimate outside supported range'); } return blocks; }