@classytic/primitives 0.18.0 → 0.19.0

package/CHANGELOG.md

@@ -3,6 +3,42 @@
 Format based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 adhering to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.19.0] - 2026-08-01
+
+### Added — `./monetization`: canonical pricing classification contract
+
+- **`@classytic/primitives/monetization`** — the single home for how a product
+  is sold and priced, so the classification survives end-to-end across catalog,
+  revenue, order, and entitlement kernels without each maintaining its own enum.
+- **`Monetization`** discriminated union — `FreeMonetization | OneTimeMonetization |
+  SubscriptionMonetization | BundleMonetization | UsageMonetization`, each
+  carrying its own nested pricing shape.
+- **`MONETIZATION_KINDS`** + **`MonetizationKind`** + **`isMonetizationKind`** —
+  exhaustive kind list with runtime guard.
+- Type-guard predicates: **`isFreeMonetization`**, **`isOneTimeMonetization`**,
+  **`isSubscriptionMonetization`**, **`isBundleMonetization`**,
+  **`isUsageMonetization`**.
+- Supporting types: `PriceTier`, `OneTimePricing`, `SubscriptionPlan`,
+  `UsageTier`, `UsageRating`, `DurationUnit`, `MoneyByCurrency`.
+
+### Added — `./proration`: pure proration arithmetic
+
+- **`@classytic/primitives/proration`** — timezone-agnostic, policy-free
+  proration math. Holds no commercial policy (no upgrade/downgrade semantics,
+  no discount or tax logic) — those live in the contract kernel.
+- **`periodProgress(input)`** — fraction of a billing period consumed given
+  start, end, and current instants as `Date`. Returns `PeriodFraction`.
+- **`splitByPeriodFraction(amount, fraction, granularity?)`** — split a `Money`
+  amount into consumed/remaining parts; `granularity: 'whole_day'` (default) or
+  `'exact'`.
+- **`allocateMoneyByFraction(amount, fraction)`** — proportional allocation
+  using the largest-remainder allocator so `consumed + remaining === amount`
+  exactly (no penny drift).
+- **`ProrationError`** + **`ProrationErrorCode`** (`INVALID_PERIOD` |
+  `INVALID_FRACTION`) — typed errors for out-of-range inputs.
+- Supporting types: `PeriodFraction`, `PeriodProgressInput`,
+  `ProrationGranularity`.
+
 ## [0.18.0] - 2026-07-29
 
 ### Added — `./subject`: `SubjectRef` polymorphic identity pointer

package/dist/monetization.d.mts

@@ -0,0 +1,195 @@
+import { Money } from "./money.mjs";
+
+//#region src/money/monetization.d.ts
+/**
+ * A map of currency code → {@link Money} for explicit per-currency pricing.
+ * Explicit entries always win over a currency-conversion fallback.
+ *
+ * Canonical home (was hand-declared in `@classytic/catalog`; re-exported there
+ * for back-compat). Belongs with money because it is a money-shaped value.
+ */
+type MoneyByCurrency = Record<string, Money>;
+/**
+ * The canonical monetization kinds. Order is stable; append only.
+ *
+ *   - `free`         — no charge.
+ *   - `one_time`     — charged once (catalog `one_time`; revenue `purchase`).
+ *   - `subscription` — recurring plan / membership.
+ *   - `bundle`       — a composite priced from its members.
+ *   - `usage`        — metered / per-seat / consumption (billed per unit or in
+ *                      arrears). The extension point for rating models.
+ */
+declare const MONETIZATION_KINDS: readonly ["free", "one_time", "subscription", "bundle", "usage"];
+type MonetizationKind = (typeof MONETIZATION_KINDS)[number];
+/** True when `value` is one of the canonical kinds. */
+declare function isMonetizationKind(value: unknown): value is MonetizationKind;
+/** A quantity-based price break. `price` (fixed override) XOR `discountPercent`. */
+interface PriceTier {
+  /** Minimum quantity to qualify. */
+  readonly minQuantity: number;
+  /** Fixed override price for this tier. */
+  readonly price?: Money;
+  /** OR a percentage discount (0–100). Mutually exclusive with `price`. */
+  readonly discountPercent?: number;
+}
+interface OneTimePricing {
+  /** Required base (list) price. */
+  readonly basePrice: Money;
+  /** Default currency (redundant with `basePrice.currency`, indexed for queries). */
+  readonly currency: string;
+  /** Optional strikethrough / MSRP price. */
+  readonly compareAtPrice?: Money;
+  /** Explicit per-currency price overrides. */
+  readonly priceByCurrency?: MoneyByCurrency;
+  /** Optional cost (role-gated — filtered for non-finance readers). */
+  readonly costPrice?: Money;
+  /** Optional volume tiers (quantity-based discounts). */
+  readonly tiers?: readonly PriceTier[];
+}
+type DurationUnit = 'day' | 'week' | 'month' | 'year';
+interface SubscriptionPlan {
+  /** Internal key ('monthly', 'quarterly', 'annual'). */
+  readonly key: string;
+  /** Display label ("Monthly", "Annual (save 20%)"). */
+  readonly label: string;
+  /** Base price for this plan in the default currency. */
+  readonly price: Money;
+  /** Explicit per-currency overrides. */
+  readonly priceByCurrency?: MoneyByCurrency;
+  /** Billing cycle length. */
+  readonly duration: number;
+  /** Unit of the billing cycle. */
+  readonly durationUnit: DurationUnit;
+  /** Optional free trial length in days. */
+  readonly trialDays?: number;
+  /** Optional auto-calculated discount vs the highest-frequency plan. */
+  readonly discount?: number;
+}
+/**
+ * One band of a metered rate table.
+ *
+ * `upTo` is the inclusive upper bound of the band; omit it for the final,
+ * open-ended band. Within a band either a `perUnit` rate applies (per metered
+ * unit) or a `flatPrice` (a stairstep charge for landing in the band).
+ */
+interface UsageTier {
+  readonly upTo?: number;
+  readonly perUnit?: Money;
+  readonly flatPrice?: Money;
+}
+/**
+ * How a metered unit is priced. One `scheme`, composed with the fields it needs
+ * — this single shape covers per-seat, metered, graduated, volume, package and
+ * base-plus-overage without a separate kind for each.
+ *
+ *   - `per_unit` — price × quantity (per-seat licensing, flat metering).
+ *   - `tiered`   — graduated: each unit priced at the rate of the band it falls in.
+ *   - `volume`   — the WHOLE quantity priced at the band the total lands in.
+ *   - `package`  — priced per package of `packageSize` units.
+ *
+ * `includedUnits` are free before metering starts (base-plus-overage when paired
+ * with {@link UsageMonetization.baseFee}).
+ */
+interface UsageRating {
+  readonly scheme: 'per_unit' | 'tiered' | 'volume' | 'package';
+  /** Flat per-unit rate (`per_unit` scheme). */
+  readonly perUnit?: Money;
+  /** Rate table (`tiered` / `volume` schemes). */
+  readonly tiers?: readonly UsageTier[];
+  /** Units per package and the package price (`package` scheme). */
+  readonly packageSize?: number;
+  readonly packagePrice?: Money;
+  /** Free units before metering starts (base-plus-overage). */
+  readonly includedUnits?: number;
+  /** Display label for one unit ("seat", "GB", "call", "visit"). */
+  readonly unitLabel?: string;
+}
+interface FreeMonetization {
+  readonly type: 'free';
+}
+interface OneTimeMonetization {
+  readonly type: 'one_time';
+  readonly pricing: OneTimePricing;
+}
+interface SubscriptionMonetization {
+  readonly type: 'subscription';
+  /** At least one plan is required. */
+  readonly plans: readonly SubscriptionPlan[];
+}
+interface BundleMonetization {
+  readonly type: 'bundle';
+  /** Optional fixed bundle price (overrides the dynamic sum). */
+  readonly basePrice?: Money;
+  /** How bundle pricing is computed. */
+  readonly pricingMode: 'fixed' | 'dynamic';
+  /** For `dynamic` mode, an optional 0–100 discount on the members' sum. */
+  readonly dynamicDiscountPercent?: number;
+}
+/**
+ * Metered / consumption pricing. The extension point for per-seat, metered,
+ * graduated, volume, package and base-plus-overage — all via {@link UsageRating}
+ * so the classification does not grow one kind per rating model.
+ */
+interface UsageMonetization {
+  readonly type: 'usage';
+  /** Optional recurring base fee charged regardless of usage (base + overage). */
+  readonly baseFee?: Money;
+  /** How each metered unit is priced. */
+  readonly rating: UsageRating;
+  /** Settlement cadence when usage is billed in arrears. */
+  readonly billingPeriod?: {
+    readonly duration: number;
+    readonly durationUnit: DurationUnit;
+  };
+}
+/**
+ * The canonical monetization value object. The `type` discriminant selects the
+ * pricing detail. Matches `@classytic/catalog`'s existing discriminants (so no
+ * data migration) plus `usage`.
+ */
+type Monetization = FreeMonetization | OneTimeMonetization | SubscriptionMonetization | BundleMonetization | UsageMonetization;
+declare const isFreeMonetization: (m: Monetization) => m is FreeMonetization;
+declare const isOneTimeMonetization: (m: Monetization) => m is OneTimeMonetization;
+declare const isSubscriptionMonetization: (m: Monetization) => m is SubscriptionMonetization;
+declare const isBundleMonetization: (m: Monetization) => m is BundleMonetization;
+declare const isUsageMonetization: (m: Monetization) => m is UsageMonetization;
+/** The kind of a monetization value (its discriminant, narrowed to the union). */
+declare const monetizationKindOf: (m: Monetization) => MonetizationKind;
+/**
+ * The single headline unit price for a monetization, or `null` when there isn't
+ * one. This is the ONE place that decides "which number is the price" per kind,
+ * so a cart line, an order snapshot and a storefront card never re-`switch` on
+ * `type` and drift (a host that read `plans[0].price` while another read
+ * `plans[1]` is exactly the divergence this prevents).
+ *
+ *   - `one_time`     → the base (list) price
+ *   - `subscription` → the first plan's price (the default / most-frequent plan)
+ *   - `bundle`       → the FIXED bundle price; `null` in `dynamic` mode (that
+ *                      price is computed from the members, not stored here)
+ *   - `free`         → `null`
+ *   - `usage`        → `null` — a metered item has no single unit price; it is
+ *                      rated per consumption via {@link UsageRating}
+ *
+ * Exhaustive on purpose: a new kind fails to compile here until it declares how
+ * it prices, instead of silently returning `null`.
+ */
+declare function unitPriceOf(m: Monetization): Money | null;
+/** The strikethrough / MSRP price, if the kind carries one (only `one_time`). */
+declare function compareAtPriceOf(m: Monetization): Money | null;
+/**
+ * `@classytic/revenue`'s coarse wire enum. `purchase` is the paid-once case that
+ * the rest of the ecosystem calls `one_time`. Kept as its own type so revenue's
+ * PERSISTED values never have to change — only the mapping to the canonical kind
+ * lives here, in one place, instead of an implicit hand-conversion per call site.
+ */
+type RevenueMonetizationType = 'free' | 'purchase' | 'subscription';
+/**
+ * Canonical kind → revenue wire type. Everything that is not `free` or
+ * `subscription` settles as a `purchase` in revenue's ledger vocabulary
+ * (one_time, bundle, and a usage charge are all "a purchase happened").
+ */
+declare function toRevenueMonetizationType(kind: MonetizationKind): RevenueMonetizationType;
+/** Revenue wire type → canonical kind (`purchase` → `one_time`). */
+declare function fromRevenueMonetizationType(type: RevenueMonetizationType): MonetizationKind;
+//#endregion
+export { BundleMonetization, DurationUnit, FreeMonetization, MONETIZATION_KINDS, Monetization, MonetizationKind, MoneyByCurrency, OneTimeMonetization, OneTimePricing, PriceTier, RevenueMonetizationType, SubscriptionMonetization, SubscriptionPlan, UsageMonetization, UsageRating, UsageTier, compareAtPriceOf, fromRevenueMonetizationType, isBundleMonetization, isFreeMonetization, isMonetizationKind, isOneTimeMonetization, isSubscriptionMonetization, isUsageMonetization, monetizationKindOf, toRevenueMonetizationType, unitPriceOf };

package/dist/monetization.mjs

@@ -0,0 +1,79 @@
+//#region src/money/monetization.ts
+/**
+* The canonical monetization kinds. Order is stable; append only.
+*
+*   - `free`         — no charge.
+*   - `one_time`     — charged once (catalog `one_time`; revenue `purchase`).
+*   - `subscription` — recurring plan / membership.
+*   - `bundle`       — a composite priced from its members.
+*   - `usage`        — metered / per-seat / consumption (billed per unit or in
+*                      arrears). The extension point for rating models.
+*/
+const MONETIZATION_KINDS = [
+	"free",
+	"one_time",
+	"subscription",
+	"bundle",
+	"usage"
+];
+const MONETIZATION_KIND_SET = new Set(MONETIZATION_KINDS);
+/** True when `value` is one of the canonical kinds. */
+function isMonetizationKind(value) {
+	return typeof value === "string" && MONETIZATION_KIND_SET.has(value);
+}
+const isFreeMonetization = (m) => m.type === "free";
+const isOneTimeMonetization = (m) => m.type === "one_time";
+const isSubscriptionMonetization = (m) => m.type === "subscription";
+const isBundleMonetization = (m) => m.type === "bundle";
+const isUsageMonetization = (m) => m.type === "usage";
+/** The kind of a monetization value (its discriminant, narrowed to the union). */
+const monetizationKindOf = (m) => m.type;
+/**
+* The single headline unit price for a monetization, or `null` when there isn't
+* one. This is the ONE place that decides "which number is the price" per kind,
+* so a cart line, an order snapshot and a storefront card never re-`switch` on
+* `type` and drift (a host that read `plans[0].price` while another read
+* `plans[1]` is exactly the divergence this prevents).
+*
+*   - `one_time`     → the base (list) price
+*   - `subscription` → the first plan's price (the default / most-frequent plan)
+*   - `bundle`       → the FIXED bundle price; `null` in `dynamic` mode (that
+*                      price is computed from the members, not stored here)
+*   - `free`         → `null`
+*   - `usage`        → `null` — a metered item has no single unit price; it is
+*                      rated per consumption via {@link UsageRating}
+*
+* Exhaustive on purpose: a new kind fails to compile here until it declares how
+* it prices, instead of silently returning `null`.
+*/
+function unitPriceOf(m) {
+	switch (m.type) {
+		case "one_time": return m.pricing.basePrice;
+		case "subscription": return m.plans[0]?.price ?? null;
+		case "bundle": return m.basePrice ?? null;
+		case "free":
+		case "usage": return null;
+	}
+}
+/** The strikethrough / MSRP price, if the kind carries one (only `one_time`). */
+function compareAtPriceOf(m) {
+	return m.type === "one_time" ? m.pricing.compareAtPrice ?? null : null;
+}
+/**
+* Canonical kind → revenue wire type. Everything that is not `free` or
+* `subscription` settles as a `purchase` in revenue's ledger vocabulary
+* (one_time, bundle, and a usage charge are all "a purchase happened").
+*/
+function toRevenueMonetizationType(kind) {
+	if (kind === "free") return "free";
+	if (kind === "subscription") return "subscription";
+	return "purchase";
+}
+/** Revenue wire type → canonical kind (`purchase` → `one_time`). */
+function fromRevenueMonetizationType(type) {
+	if (type === "free") return "free";
+	if (type === "subscription") return "subscription";
+	return "one_time";
+}
+//#endregion
+export { MONETIZATION_KINDS, compareAtPriceOf, fromRevenueMonetizationType, isBundleMonetization, isFreeMonetization, isMonetizationKind, isOneTimeMonetization, isSubscriptionMonetization, isUsageMonetization, monetizationKindOf, toRevenueMonetizationType, unitPriceOf };

package/dist/proration.d.mts

@@ -0,0 +1,76 @@
+import { Money } from "./money.mjs";
+
+//#region src/money/proration.d.ts
+/**
+ * How to count days within a period.
+ *
+ * - `'whole_day'` (default) — integer calendar-day counts. Callers normalize
+ *   `periodStart`/`periodEnd`/`asOf` to business-local midnight first, so this
+ *   matches "day-of-month" proration (the Stripe default, how ~99% of SaaS
+ *   bill). `periodDays` is clamped to `>= 1`.
+ * - `'exact'` — fractional wall-clock day counts (`ms / 86_400_000`). Use when
+ *   cycles are short and a partial day must be billed precisely.
+ */
+type ProrationGranularity = 'whole_day' | 'exact';
+/** The elapsed/remaining split of a billing period at a change instant. */
+interface PeriodFraction {
+  /** Total days in the period. `>= 1` for `whole_day`; `> 0` for `exact`. */
+  readonly periodDays: number;
+  /** Days consumed as of the change instant, clamped to `[0, periodDays]`. */
+  readonly elapsedDays: number;
+  /** `periodDays - elapsedDays`. */
+  readonly remainingDays: number;
+  /** `remainingDays / periodDays`, in `[0, 1]`. */
+  readonly remainingFraction: number;
+}
+interface PeriodProgressInput {
+  /** Period start instant (business-tz-normalized by the caller). */
+  readonly periodStart: Date;
+  /** Period end instant — must be strictly after `periodStart`. */
+  readonly periodEnd: Date;
+  /** The change/quote instant. Clamped into `[periodStart, periodEnd]`. */
+  readonly asOf: Date;
+  /** Day-counting granularity. Default `'whole_day'`. */
+  readonly granularity?: ProrationGranularity;
+}
+type ProrationErrorCode = 'INVALID_PERIOD' | 'INVALID_FRACTION';
+declare class ProrationError extends Error {
+  readonly name = "ProrationError";
+  readonly code: ProrationErrorCode;
+  constructor(code: ProrationErrorCode, message: string);
+}
+/**
+ * Compute how much of a period is elapsed vs remaining at `asOf`.
+ *
+ * `asOf` before the period start ⇒ nothing elapsed (full remaining);
+ * `asOf` after the period end ⇒ fully elapsed (nothing remaining).
+ *
+ * @throws ProrationError('INVALID_PERIOD') if a date is invalid or
+ *   `periodEnd <= periodStart`.
+ */
+declare function periodProgress(input: PeriodProgressInput): PeriodFraction;
+/**
+ * Split a `Money` amount into its consumed and remaining parts across a
+ * {@link PeriodFraction}, drift-free: `consumed.amount + remaining.amount ===
+ * amount.amount` exactly (largest-remainder allocation). Sign is preserved, so
+ * a negative amount (a reversal) splits symmetrically.
+ *
+ * This is the load-bearing primitive for proration: the "unused value" a
+ * plan-change credits is `remaining`; the "already-consumed value" is
+ * `consumed`.
+ */
+declare function splitByPeriodFraction(amount: Money, fraction: PeriodFraction): {
+  readonly consumed: Money;
+  readonly remaining: Money;
+};
+/**
+ * Allocate the `fraction`-weighted part of a `Money` amount, drift-free — the
+ * complement (`1 - fraction`) is discarded but computed so rounding is exact
+ * against the whole. `fraction` must be in `[0, 1]`.
+ *
+ * @throws ProrationError('INVALID_FRACTION') if `fraction` is outside `[0, 1]`
+ *   or not finite.
+ */
+declare function allocateMoneyByFraction(amount: Money, fraction: number): Money;
+//#endregion
+export { PeriodFraction, PeriodProgressInput, ProrationError, ProrationErrorCode, ProrationGranularity, allocateMoneyByFraction, periodProgress, splitByPeriodFraction };

package/dist/proration.mjs

@@ -0,0 +1,120 @@
+import { allocate } from "./split-allocation.mjs";
+//#region src/money/proration.ts
+/**
+* Pure proration ARITHMETIC — fraction / period / allocation / rounding only.
+*
+* This module deliberately holds **no commercial policy**. It does not know
+* what "an upgrade" is, whether a discount is creditable, how tax is treated,
+* or whether a downgrade yields cash vs store credit. Those decisions live in
+* the subscription/contract kernel (`@classytic/contract`
+* `calculatePlanChangeProration(...)`), which composes these primitives.
+*
+* It is also **timezone-agnostic**: callers pass already-resolved `Date`
+* instants (normalized to the deployment's business timezone via
+* `@classytic/primitives/timezone` upstream). This module never reads a clock
+* and never applies an offset — pass instants, get numbers.
+*
+* Money is integer minor units throughout; splits use the largest-remainder
+* allocator so `consumed + remaining === amount` exactly, with no penny drift.
+*/
+const MS_PER_DAY = 864e5;
+var ProrationError = class extends Error {
+	name = "ProrationError";
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+function isValidDate(d) {
+	return d instanceof Date && !Number.isNaN(d.getTime());
+}
+/**
+* Compute how much of a period is elapsed vs remaining at `asOf`.
+*
+* `asOf` before the period start ⇒ nothing elapsed (full remaining);
+* `asOf` after the period end ⇒ fully elapsed (nothing remaining).
+*
+* @throws ProrationError('INVALID_PERIOD') if a date is invalid or
+*   `periodEnd <= periodStart`.
+*/
+function periodProgress(input) {
+	const { periodStart, periodEnd, asOf, granularity = "whole_day" } = input;
+	if (!isValidDate(periodStart) || !isValidDate(periodEnd) || !isValidDate(asOf)) throw new ProrationError("INVALID_PERIOD", "periodStart, periodEnd and asOf must be valid Dates");
+	const startMs = periodStart.getTime();
+	const endMs = periodEnd.getTime();
+	if (endMs <= startMs) throw new ProrationError("INVALID_PERIOD", `periodEnd (${periodEnd.toISOString()}) must be after periodStart (${periodStart.toISOString()})`);
+	const clampedAsOfMs = Math.min(Math.max(asOf.getTime(), startMs), endMs);
+	const rawPeriodDays = (endMs - startMs) / MS_PER_DAY;
+	const rawElapsedDays = (clampedAsOfMs - startMs) / MS_PER_DAY;
+	let periodDays;
+	let elapsedDays;
+	if (granularity === "whole_day") {
+		periodDays = Math.max(1, Math.round(rawPeriodDays));
+		elapsedDays = Math.min(periodDays, Math.max(0, Math.round(rawElapsedDays)));
+	} else {
+		periodDays = rawPeriodDays;
+		elapsedDays = Math.min(periodDays, Math.max(0, rawElapsedDays));
+	}
+	const remainingDays = periodDays - elapsedDays;
+	return {
+		periodDays,
+		elapsedDays,
+		remainingDays,
+		remainingFraction: remainingDays / periodDays
+	};
+}
+/**
+* Split a `Money` amount into its consumed and remaining parts across a
+* {@link PeriodFraction}, drift-free: `consumed.amount + remaining.amount ===
+* amount.amount` exactly (largest-remainder allocation). Sign is preserved, so
+* a negative amount (a reversal) splits symmetrically.
+*
+* This is the load-bearing primitive for proration: the "unused value" a
+* plan-change credits is `remaining`; the "already-consumed value" is
+* `consumed`.
+*/
+function splitByPeriodFraction(amount, fraction) {
+	const result = allocate(amount.amount, [{
+		id: "consumed",
+		weight: fraction.elapsedDays
+	}, {
+		id: "remaining",
+		weight: fraction.remainingDays
+	}], "by-weight");
+	const consumed = result.parts.find((p) => p.id === "consumed")?.amount ?? 0;
+	const remaining = result.parts.find((p) => p.id === "remaining")?.amount ?? 0;
+	return {
+		consumed: {
+			amount: consumed,
+			currency: amount.currency
+		},
+		remaining: {
+			amount: remaining,
+			currency: amount.currency
+		}
+	};
+}
+/**
+* Allocate the `fraction`-weighted part of a `Money` amount, drift-free — the
+* complement (`1 - fraction`) is discarded but computed so rounding is exact
+* against the whole. `fraction` must be in `[0, 1]`.
+*
+* @throws ProrationError('INVALID_FRACTION') if `fraction` is outside `[0, 1]`
+*   or not finite.
+*/
+function allocateMoneyByFraction(amount, fraction) {
+	if (!Number.isFinite(fraction) || fraction < 0 || fraction > 1) throw new ProrationError("INVALID_FRACTION", `fraction must be in [0, 1], got ${fraction}`);
+	return {
+		amount: allocate(amount.amount, [{
+			id: "part",
+			weight: fraction
+		}, {
+			id: "rest",
+			weight: 1 - fraction
+		}], "by-weight").parts.find((p) => p.id === "part")?.amount ?? 0,
+		currency: amount.currency
+	};
+}
+//#endregion
+export { ProrationError, allocateMoneyByFraction, periodProgress, splitByPeriodFraction };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classytic/primitives",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "Framework-agnostic TypeScript primitives shared across Classytic packages — Money, events, pagination, tenant config, and other building blocks.",
   "author": "Classytic",
   "license": "MIT",
@@ -133,6 +133,14 @@
       "types": "./dist/payment-allocation-status.d.mts",
       "default": "./dist/payment-allocation-status.mjs"
     },
+    "./monetization": {
+      "types": "./dist/monetization.d.mts",
+      "default": "./dist/monetization.mjs"
+    },
+    "./proration": {
+      "types": "./dist/proration.d.mts",
+      "default": "./dist/proration.mjs"
+    },
     "./payment-events": {
       "types": "./dist/payment-events.d.mts",
       "default": "./dist/payment-events.mjs"