@stll/money 0.0.1-placeholder.0 → 0.2.0

package/README.md

@@ -0,0 +1,15 @@
+# @stll/money
+
+Branded minor-unit monetary values and exact billing arithmetic for Stella.
+
+The package keeps money in integer minor units, rejects fractional cents, and
+separates totals by currency so incompatible amounts cannot be combined.
+
+```ts
+import { MoneyTotals, cents } from "@stll/money";
+
+const totals = new MoneyTotals();
+totals.add("EUR", cents(1250));
+```
+
+Public API changes require a changeset.

package/dist/index.d.ts

@@ -0,0 +1,202 @@
+//#region src/cents.d.ts
+/**
+ * The minor-unit brand and its constructors.
+ *
+ * Separate from `index.ts` because `format.ts` mints amounts too: the
+ * conversion helpers there return a `CentsAmount`, and a module the package
+ * entry re-exports cannot import back from that entry without a cycle.
+ */
+declare const __cents: unique symbol;
+type CentsAmount = number & {
+  readonly [__cents]: "CentsAmount";
+};
+/**
+ * Construct a CentsAmount from a value already known to be in minor
+ * units. Use at boundaries where the input is validated as an integer
+ * minor-unit value (e.g. after Elysia `tMinorUnitAmount(...)` or after
+ * scaling a typed major-unit amount by the currency's exponent).
+ *
+ * SAFE integer, not merely integer: `Number.isInteger` is true for 2^53 and
+ * everything above it, where the spacing between representable doubles is
+ * larger than one minor unit, so `x + 1 === x` and a total silently stops
+ * moving. An amount that far out is a caller defect rather than a runtime
+ * condition, like a fractional one, so it panics the same way.
+ */
+declare const cents: (value: number) => CentsAmount;
+/**
+ * Escape hatch for code paths that genuinely need to attach the brand
+ * without a runtime check (test fixtures, generated code). Prefer
+ * `cents()` everywhere else; reach for this only with a `// SAFETY:`
+ * comment naming why the value is already a valid minor-unit integer.
+ */
+declare const unsafeCents: (value: number) => CentsAmount;
+//#endregion
+//#region src/format.d.ts
+/**
+ * How many minor units make a major one, for this currency: 100 for CZK, 1 for
+ * JPY, 1000 for KWD. It is a property of the currency and not of the reader, so
+ * the lookup is deliberately locale-independent.
+ *
+ * A malformed code makes the `Intl.NumberFormat` constructor throw, before any
+ * `?? 2` on its result could help, so the fallback has to wrap the call.
+ */
+declare const currencyMinorUnitDigits: (currency: string) => number;
+type ToMinorUnitsParams = {
+  /**
+   * The amount in major units: the decimal text a form holds, or a number.
+   * Text is preferred where the caller has it, because it is what the person
+   * typed rather than the nearest double to it.
+   */
+  amount: number | string;
+  currency: string;
+};
+/**
+ * A typed major-unit amount as the minor units the currency actually counts:
+ * 12.5 USD is 1250, 1500 JPY is 1500, 12.5 KWD is 12500.
+ *
+ * The scaling is decimal, not a float multiply. `1.005 * 100` is
+ * 100.49999999999999 in binary floating point, so `Math.round` of it is 100
+ * and a $1.005 line item silently loses a cent; the same shortfall appears at
+ * a different decimal for every currency. Splitting the text on the point and
+ * moving the digits instead keeps the amount the person typed: the kept
+ * fraction digits are appended to the whole part, and the first digit dropped
+ * decides a half-up carry on the magnitude.
+ *
+ * Rounding is still the point -- a typed amount carries more places than the
+ * currency has -- and it happens on digits, exactly. Text this cannot parse,
+ * and a result outside the safe integer range, are caller defects: gate the
+ * text with `isDecimalAmount` first.
+ */
+declare const toMinorUnits: (params: ToMinorUnitsParams) => CentsAmount;
+/**
+ * The same conversion for text nobody has vouched for yet: null when the text
+ * is not a decimal amount, and null when the scaled value would leave the safe
+ * integer range, where a total silently stops adding up.
+ *
+ * A form holds whatever was typed and has to be able to decline it. Everything
+ * past that gate calls `toMinorUnits`, which panics, because by then the
+ * decision has been made.
+ */
+declare const tryToMinorUnits: ({ amount, currency }: ToMinorUnitsParams) => CentsAmount | null;
+type ToMajorUnitsParams = {
+  amountCents: number;
+  currency: string;
+};
+/** The inverse: a stored amount as the major-unit number a person reads. */
+declare const toMajorUnits: ({ amountCents, currency }: ToMajorUnitsParams) => number;
+type FormatMoneyCentsParams = {
+  amountCents: number;
+  currency: string;
+  locale: string;
+  /**
+   * Digits to show, minimum and maximum alike. Defaults to the currency's own
+   * exponent; pass 0 for a rounded summary that has no room for decimals.
+   */
+  fractionDigits?: number;
+};
+/**
+ * Money is stored in minor units, and how many of them make a major one is a
+ * property of the currency. Ask the currency rather than assuming a hundred.
+ *
+ * A code `Intl` rejects falls back to the amount beside the raw code: a column
+ * showing "15.00 A1C" is wrong-looking data, which is the truth, where a thrown
+ * RangeError would take the whole board down with it.
+ */
+declare const formatMoneyCents: ({ amountCents, currency, locale, fractionDigits }: FormatMoneyCentsParams) => string;
+//#endregion
+//#region src/index.d.ts
+type ProrateHourlyCentsInput = {
+  billedMinutes: number;
+  hourlyRateCents: CentsAmount;
+};
+declare const prorateHourlyCents: ({ billedMinutes, hourlyRateCents }: ProrateHourlyCentsInput) => CentsAmount;
+type ApplyMarkupCentsInput = {
+  amountCents: CentsAmount;
+  markupPercent: number;
+};
+declare const applyMarkupCents: ({ amountCents, markupPercent }: ApplyMarkupCentsInput) => CentsAmount;
+declare const __currency: unique symbol;
+/**
+ * A `CentsAmount` additionally branded with its ISO 4217-ish currency code
+ * `C`. This makes cross-currency addition a compile error instead of a
+ * runtime bug: `addCents` only accepts two `CurrencyCents` sharing the same
+ * `C`, so `addCents(usdAmount, eurAmount)` fails to typecheck rather than
+ * silently producing a meaningless sum.
+ *
+ * Mint one with `currencyCents()`; there is no unsafe escape hatch because
+ * the underlying `CentsAmount` validation (`cents()`) is cheap and the
+ * currency code is a plain string carried alongside it, so there is no
+ * boundary that needs to skip it.
+ */
+type CurrencyCents<C extends string = string> = CentsAmount & {
+  readonly [__currency]: C;
+};
+/**
+ * Construct a `CurrencyCents<C>` from a currency code and a minor-unit
+ * amount. The only producer of `CurrencyCents`; downstream code narrows `C`
+ * from the literal `currency` argument (e.g. `currencyCents("USD", 100)`
+ * infers `CurrencyCents<"USD">`).
+ */
+declare const currencyCents: <C extends string>(currency: C, amount: number) => CurrencyCents<C>;
+type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
+type IsSingletonCurrency<C extends string> = string extends C ? never : [C] extends [UnionToIntersection<C>] ? C : never;
+/**
+ * Add two `CurrencyCents` amounts of the SAME currency. The second
+ * parameter's currency `B` is constrained to `extends A`, so passing a
+ * different currency literal (e.g. `addCents(usdAmount, eurAmount)`) is a
+ * compile error, not a runtime bug — see `packages/money/src/index.test.ts`
+ * for the `@ts-expect-error` proof.
+ *
+ * Both operands are further constrained by `IsSingletonCurrency` to reject
+ * any non-singleton currency type: the WIDE `CurrencyCents<string>`, and
+ * also a finite union such as `CurrencyCents<"USD" | "EUR">` (e.g. from a
+ * validator's `t.UnionEnum`). A currency read back from a DB row or
+ * narrowed only to a finite set of allowed codes types as `string` or a
+ * union, not a single literal, so without this, `addCents(currencyCents(a,
+ * x), currencyCents(b, y))` would still typecheck even when `a`/`b` are
+ * both known only up to a union of currencies that could differ at
+ * runtime — the compile-time guarantee above only bites for a genuine
+ * single-literal currency type on both operands. Code that aggregates rows
+ * with a dynamic or union (non-singleton) currency must use `MoneyTotals`
+ * instead, which buckets by currency at runtime and is the runtime-correct
+ * tool for that case.
+ */
+declare const addCents: <A extends string, B extends A = A>(a: IsSingletonCurrency<A> extends never ? never : CurrencyCents<A>, b: IsSingletonCurrency<B> extends never ? never : CurrencyCents<B>) => CurrencyCents<A>;
+/**
+ * Per-currency accumulator for aggregating money across rows that may carry
+ * different currencies (e.g. time entries across matters, expenses across
+ * clients). There is deliberately no method that returns a single combined
+ * number: the only way to read totals out is `entries()`, which groups by
+ * currency and sorts deterministically by currency code. This keeps
+ * cross-currency summation structurally unreachable through this package's
+ * API — callers must handle each currency's total explicitly.
+ *
+ * Division of responsibility with `addCents`: `addCents` gives a
+ * compile-time guarantee, but only when both operands carry a single
+ * string-literal currency type (`CurrencyCents<"USD">`); it rejects both
+ * the wide `CurrencyCents<string>` and a finite union such as
+ * `CurrencyCents<"USD" | "EUR">` outright. Any flow whose currency is
+ * dynamic or only known up to a union of allowed codes (read from a DB row,
+ * request body, etc.) cannot satisfy that singleton-literal constraint and
+ * must bucket through `MoneyTotals` instead, which enforces
+ * the same "never sum across currencies" invariant at runtime via the
+ * per-currency `Map`.
+ */
+type MoneyTotalsEntry = {
+  currency: string;
+  amountCents: CentsAmount;
+};
+declare class MoneyTotals {
+  #private;
+  /** Add `amountCents` to the running total for `currency`. */
+  add(currency: string, amountCents: CentsAmount): void;
+  /**
+   * Per-currency totals, sorted deterministically by currency code so
+   * output (PDF lines, API responses) does not depend on insertion order.
+   * Sorts by UTF-16 code unit (default `Array.sort`) rather than
+   * `localeCompare`, so ordering does not vary with the runtime's locale.
+   */
+  entries(): MoneyTotalsEntry[];
+}
+//#endregion
+export { ApplyMarkupCentsInput, type CentsAmount, CurrencyCents, type FormatMoneyCentsParams, MoneyTotals, MoneyTotalsEntry, ProrateHourlyCentsInput, type ToMajorUnitsParams, type ToMinorUnitsParams, addCents, applyMarkupCents, cents, currencyCents, currencyMinorUnitDigits, formatMoneyCents, prorateHourlyCents, toMajorUnits, toMinorUnits, tryToMinorUnits, unsafeCents };

package/dist/index.js

@@ -0,0 +1,274 @@
+import { Result, panic } from "better-result";
+//#region src/cents.ts
+/**
+* The minor-unit brand and its constructors.
+*
+* Separate from `index.ts` because `format.ts` mints amounts too: the
+* conversion helpers there return a `CentsAmount`, and a module the package
+* entry re-exports cannot import back from that entry without a cycle.
+*/
+/**
+* Construct a CentsAmount from a value already known to be in minor
+* units. Use at boundaries where the input is validated as an integer
+* minor-unit value (e.g. after Elysia `tMinorUnitAmount(...)` or after
+* scaling a typed major-unit amount by the currency's exponent).
+*
+* SAFE integer, not merely integer: `Number.isInteger` is true for 2^53 and
+* everything above it, where the spacing between representable doubles is
+* larger than one minor unit, so `x + 1 === x` and a total silently stops
+* moving. An amount that far out is a caller defect rather than a runtime
+* condition, like a fractional one, so it panics the same way.
+*/
+const cents = (value) => {
+	if (!Number.isSafeInteger(value)) return panic(`cents(${value}): money values must be safe integer minor units`);
+	return value;
+};
+/**
+* Escape hatch for code paths that genuinely need to attach the brand
+* without a runtime check (test fixtures, generated code). Prefer
+* `cents()` everywhere else; reach for this only with a `// SAFETY:`
+* comment naming why the value is already a valid minor-unit integer.
+*/
+const unsafeCents = (value) => value;
+//#endregion
+//#region src/format.ts
+/**
+* Moving between a stored minor-unit amount and the major-unit number a
+* person types, and rendering either as text.
+*
+* The brand keeps the arithmetic honest; this keeps the scale honest. Both
+* live here because "how many minor units make a major one" is a property of
+* the currency, and every surface that touches money has to answer it the
+* same way — a workspace column header, a billing form, an invoice line, an
+* export row.
+*
+* The locale is always a parameter. A package cannot read the reader's
+* formatting locale, and one that guessed would render a number differently
+* from the app around it.
+*/
+/**
+* Two, the ISO 4217 default, used when a stored code is one `Intl` will not
+* accept. Validation at the API boundary keeps those out, but a row written
+* before that constraint existed must still render rather than throw.
+*/
+const DEFAULT_MINOR_UNIT_DIGITS = 2;
+/**
+* How many minor units make a major one, for this currency: 100 for CZK, 1 for
+* JPY, 1000 for KWD. It is a property of the currency and not of the reader, so
+* the lookup is deliberately locale-independent.
+*
+* A malformed code makes the `Intl.NumberFormat` constructor throw, before any
+* `?? 2` on its result could help, so the fallback has to wrap the call.
+*/
+const currencyMinorUnitDigits = (currency) => {
+	const resolved = Result.try(() => new Intl.NumberFormat("en", {
+		style: "currency",
+		currency
+	}).resolvedOptions().maximumFractionDigits);
+	if (resolved.isErr()) return DEFAULT_MINOR_UNIT_DIGITS;
+	return resolved.value ?? DEFAULT_MINOR_UNIT_DIGITS;
+};
+/** A decimal amount in major units: an optional sign, digits, an optional point. */
+const DECIMAL_AMOUNT = /^(?<sign>[+-]?)(?<whole>\d*)(?:\.(?<fraction>\d*))?$/u;
+/** Scientific notation, which `String(1e21)` and `String(1e-7)` both produce. */
+const EXPONENT_AMOUNT = /^(?<sign>[+-]?)(?<whole>\d+)(?:\.(?<fraction>\d+))?[eE](?<exponent>[+-]?\d+)$/u;
+/**
+* The widest exponent a finite double prints with (`5e-324`, `1.8e308`).
+* Text past it names no amount any currency stores, and expanding it would
+* mean materialising that many zeros.
+*/
+const MAX_EXPONENT_MAGNITUDE = 324;
+const expandExponent = (text) => {
+	const groups = EXPONENT_AMOUNT.exec(text)?.groups;
+	if (!groups) return null;
+	const exponent = Number(groups["exponent"]);
+	if (Math.abs(exponent) > MAX_EXPONENT_MAGNITUDE) return null;
+	const sign = groups["sign"] ?? "";
+	const digits = `${groups["whole"] ?? ""}${groups["fraction"] ?? ""}`;
+	const point = (groups["whole"] ?? "").length + exponent;
+	if (point <= 0) return `${sign}0.${"0".repeat(-point)}${digits}`;
+	if (point >= digits.length) return `${sign}${digits}${"0".repeat(point - digits.length)}`;
+	return `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;
+};
+/**
+* The amount as decimal text, or null when it is not a decimal amount.
+*
+* A number is rendered by `String`, which produces the SHORTEST text that
+* round-trips back to the same double. That is what makes the number path
+* exact: the double nearest 1.005 prints as "1.005", which is the amount the
+* person typed, where multiplying that double by 100 yields 100.49999999999999.
+*/
+const decimalText = (amount) => {
+	if (typeof amount === "number") {
+		if (!Number.isFinite(amount)) return null;
+		const rendered = String(amount);
+		return rendered.includes("e") ? expandExponent(rendered) : rendered;
+	}
+	const trimmed = amount.trim();
+	return /[eE]/u.test(trimmed) ? expandExponent(trimmed) : trimmed;
+};
+/** The digits of a decimal amount, or null when the text is not one. */
+const amountDigits = (amount) => {
+	const text = decimalText(amount);
+	const groups = text === null ? void 0 : DECIMAL_AMOUNT.exec(text)?.groups;
+	if (groups === void 0) return null;
+	const whole = groups["whole"] ?? "";
+	const fraction = groups["fraction"] ?? "";
+	if (`${whole}${fraction}`.length === 0) return null;
+	return {
+		sign: groups["sign"] ?? "",
+		whole,
+		fraction
+	};
+};
+/**
+* A typed major-unit amount as the minor units the currency actually counts:
+* 12.5 USD is 1250, 1500 JPY is 1500, 12.5 KWD is 12500.
+*
+* The scaling is decimal, not a float multiply. `1.005 * 100` is
+* 100.49999999999999 in binary floating point, so `Math.round` of it is 100
+* and a $1.005 line item silently loses a cent; the same shortfall appears at
+* a different decimal for every currency. Splitting the text on the point and
+* moving the digits instead keeps the amount the person typed: the kept
+* fraction digits are appended to the whole part, and the first digit dropped
+* decides a half-up carry on the magnitude.
+*
+* Rounding is still the point -- a typed amount carries more places than the
+* currency has -- and it happens on digits, exactly. Text this cannot parse,
+* and a result outside the safe integer range, are caller defects: gate the
+* text with `isDecimalAmount` first.
+*/
+const toMinorUnits = (params) => tryToMinorUnits(params) ?? panic(`toMinorUnits(${JSON.stringify(params.amount)}): not an amount ${params.currency} can store`);
+/**
+* The same conversion for text nobody has vouched for yet: null when the text
+* is not a decimal amount, and null when the scaled value would leave the safe
+* integer range, where a total silently stops adding up.
+*
+* A form holds whatever was typed and has to be able to decline it. Everything
+* past that gate calls `toMinorUnits`, which panics, because by then the
+* decision has been made.
+*/
+const tryToMinorUnits = ({ amount, currency }) => {
+	const parsed = amountDigits(amount);
+	if (parsed === null) return null;
+	const digits = currencyMinorUnitDigits(currency);
+	const kept = parsed.fraction.slice(0, digits).padEnd(digits, "0");
+	const dropped = parsed.fraction.charAt(digits);
+	const magnitude = BigInt(`${parsed.whole || "0"}${kept}`) + (dropped >= "5" ? 1n : 0n);
+	const value = Number(parsed.sign === "-" ? -magnitude : magnitude);
+	return Number.isSafeInteger(value) ? cents(value) : null;
+};
+/** The inverse: a stored amount as the major-unit number a person reads. */
+const toMajorUnits = ({ amountCents, currency }) => amountCents / 10 ** currencyMinorUnitDigits(currency);
+/**
+* Money is stored in minor units, and how many of them make a major one is a
+* property of the currency. Ask the currency rather than assuming a hundred.
+*
+* A code `Intl` rejects falls back to the amount beside the raw code: a column
+* showing "15.00 A1C" is wrong-looking data, which is the truth, where a thrown
+* RangeError would take the whole board down with it.
+*/
+const formatMoneyCents = ({ amountCents, currency, locale, fractionDigits }) => {
+	const major = toMajorUnits({
+		amountCents,
+		currency
+	});
+	const digits = fractionDigits ?? currencyMinorUnitDigits(currency);
+	const formatted = Result.try(() => new Intl.NumberFormat(locale, {
+		style: "currency",
+		currency,
+		minimumFractionDigits: digits,
+		maximumFractionDigits: digits
+	}).format(major));
+	return formatted.isErr() ? `${major.toFixed(digits)} ${currency}` : formatted.value;
+};
+//#endregion
+//#region src/index.ts
+/**
+* Branded monetary amounts and minor-unit billing arithmetic.
+*
+* Money in this codebase is stored and computed in minor units
+* ("cents" for USD/EUR, halere for CZK, etc.). The `CentsAmount`
+* brand prevents the canonical 100x bug where a major-unit value
+* (12.50 dollars) is silently mixed with minor-unit math (1250 cents).
+*
+* The brand lives in this package, so it threads end to end:
+* the same `CentsAmount` flows from a Drizzle column declared with
+* `.$type<CentsAmount>()`, across the API boundary (Eden infers the
+* brand from the handler's return type), into browser previews and back.
+* A plain `number` is not assignable to `CentsAmount`; mint one with
+* `cents()` after validating minor-unit input, or `unsafeCents()` at a
+* documented boundary.
+*
+* Currency-agnostic: the currency code lives alongside the amount in the
+* schema (e.g. invoices.currency); pairing them is the call site's
+* responsibility.
+*/
+const prorateHourlyCents = ({ billedMinutes, hourlyRateCents }) => {
+	assertNonNegativeInteger("billedMinutes", billedMinutes);
+	assertNonNegativeInteger("hourlyRateCents", hourlyRateCents);
+	return cents(Math.floor((billedMinutes * hourlyRateCents + 30) / 60));
+};
+const applyMarkupCents = ({ amountCents, markupPercent }) => {
+	assertNonNegativeInteger("amountCents", amountCents);
+	assertNonNegativeInteger("markupPercent", markupPercent);
+	return cents(Math.floor((amountCents * (100 + markupPercent) + 50) / 100));
+};
+function assertNonNegativeInteger(name, value) {
+	if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) panic(`${name} must be a finite non-negative integer`);
+}
+/**
+* Construct a `CurrencyCents<C>` from a currency code and a minor-unit
+* amount. The only producer of `CurrencyCents`; downstream code narrows `C`
+* from the literal `currency` argument (e.g. `currencyCents("USD", 100)`
+* infers `CurrencyCents<"USD">`).
+*/
+const currencyCents = (currency, amount) => {
+	if (!currency) return panic("currencyCents(): currency must be a non-empty code");
+	return cents(amount);
+};
+/**
+* Add two `CurrencyCents` amounts of the SAME currency. The second
+* parameter's currency `B` is constrained to `extends A`, so passing a
+* different currency literal (e.g. `addCents(usdAmount, eurAmount)`) is a
+* compile error, not a runtime bug — see `packages/money/src/index.test.ts`
+* for the `@ts-expect-error` proof.
+*
+* Both operands are further constrained by `IsSingletonCurrency` to reject
+* any non-singleton currency type: the WIDE `CurrencyCents<string>`, and
+* also a finite union such as `CurrencyCents<"USD" | "EUR">` (e.g. from a
+* validator's `t.UnionEnum`). A currency read back from a DB row or
+* narrowed only to a finite set of allowed codes types as `string` or a
+* union, not a single literal, so without this, `addCents(currencyCents(a,
+* x), currencyCents(b, y))` would still typecheck even when `a`/`b` are
+* both known only up to a union of currencies that could differ at
+* runtime — the compile-time guarantee above only bites for a genuine
+* single-literal currency type on both operands. Code that aggregates rows
+* with a dynamic or union (non-singleton) currency must use `MoneyTotals`
+* instead, which buckets by currency at runtime and is the runtime-correct
+* tool for that case.
+*/
+const addCents = (a, b) => cents(a + b);
+var MoneyTotals = class {
+	#totals = /* @__PURE__ */ new Map();
+	/** Add `amountCents` to the running total for `currency`. */
+	add(currency, amountCents) {
+		if (!currency) panic("MoneyTotals.add(): currency must be a non-empty code");
+		const running = this.#totals.get(currency) ?? cents(0);
+		this.#totals.set(currency, cents(running + amountCents));
+	}
+	/**
+	* Per-currency totals, sorted deterministically by currency code so
+	* output (PDF lines, API responses) does not depend on insertion order.
+	* Sorts by UTF-16 code unit (default `Array.sort`) rather than
+	* `localeCompare`, so ordering does not vary with the runtime's locale.
+	*/
+	entries() {
+		return [...this.#totals.keys()].sort().map((currency) => ({
+			currency,
+			amountCents: this.#totals.get(currency) ?? cents(0)
+		}));
+	}
+};
+//#endregion
+export { MoneyTotals, addCents, applyMarkupCents, cents, currencyCents, currencyMinorUnitDigits, formatMoneyCents, prorateHourlyCents, toMajorUnits, toMinorUnits, tryToMinorUnits, unsafeCents };

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@stll/money",
-  "version": "0.0.1-placeholder.0",
-  "description": "Placeholder to bootstrap npm trusted publishing. Real releases are published from stella/stella via GitHub Actions.",
-  "license": "Apache-2.0"
+  "version": "0.2.0",
+  "description": "Branded minor-unit monetary amounts and currency-safe billing arithmetic.",
+  "keywords": [
+    "billing",
+    "currency",
+    "minor-units",
+    "money",
+    "typescript"
+  ],
+  "homepage": "https://github.com/stella/stella/tree/main/packages/money",
+  "bugs": {
+    "url": "https://github.com/stella/stella/issues"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stella/stella.git",
+    "directory": "packages/money"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "git clean -xdf dist .cache .turbo node_modules",
+    "build": "tsdown",
+    "pack:dry-run": "bun pm pack --dry-run",
+    "test": "bun test src",
+    "typecheck": "bun ../../packages/scripts/src/tsc-native.ts --noEmit",
+    "lint": "cd ../.. && bun --bun oxlint -c oxlint.config.ts --report-unused-disable-directives-severity=error --deny-warnings --type-aware packages/money",
+    "lint:fix": "cd ../.. && bun --bun oxlint -c oxlint.config.ts --type-aware --fix packages/money",
+    "format": "bun ../../scripts/run-oxfmt.ts .",
+    "prepack": "bun run build"
+  },
+  "dependencies": {
+    "better-result": "3.0.0"
+  },
+  "devDependencies": {
+    "@stll/typescript-config": "0.0.0",
+    "bun-types": "1.4.2",
+    "tsdown": "0.22.14"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
 }