@trajectonomics/money 0.0.0-stage → 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 excited.live
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,68 @@
-# Temporary Holding Version
+# @trajectonomics/money
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Pure decimal scaling: major units to integer **Minor Units** and back, for any currency, with the currency precision supplied by the caller.
+
+Zero dependencies, no I/O, no clock, no randomness. It ships no currency table and never touches `Intl`, so the same code serves a statutory tax engine that must stay locale-free and an accounting ledger that resolves ISO 4217 codes from the runtime.
+
+## What this is not
+
+- Not a currency authority: it does not validate or normalise currency codes, and it does not know how many digits a currency has. The caller supplies `digits`.
+- Not money arithmetic: rounding, percentages, gross-ups, statutory caps and currency-tagged types belong to the packages that need them.
+- Not signed-policy: whether a negative amount is acceptable is the caller's decision, expressed through `allowNegative`.
+
+## Install
+
+```bash
+bun add @trajectonomics/money
+```
+
+## API
+
+```ts
+import { fromMinorUnits, MoneyValidationError, toMinorUnits } from "@trajectonomics/money"
+
+toMinorUnits(1.005, 2) // 101 - 101 cents, not 100: float noise never decides
+toMinorUnits(1234, 0) // 1234 - JPY has no fractional digits
+toMinorUnits(1.234, 3) // 1234 - KWD has three
+toMinorUnits(-1.14, 2, "netTaxPayable", { allowNegative: true }) // -114
+
+fromMinorUnits(1055, 2) // 10.55
+fromMinorUnits(500, 0) // 500
+```
+
+`toMinorUnits(amount, digits, field?, options?)` expands the amount's shortest decimal representation and rounds half away from zero, so the result never depends on binary floating-point multiplication. Scientific-notation input is scaled directly rather than mis-parsed.
+
+`fromMinorUnits(minorUnits, digits, field?, options?)` is the inverse and also normalises `-0` to `+0`.
+
+Both throw `MoneyValidationError` - carrying `field`, `value` and `reason` - when the precision is not a safe integer in `0..15`, the amount is `NaN` or infinite, a negative amount arrives without `allowNegative`, an amount is not an integer where one is required, or a result leaves the safe integer range.
+
+## Crossing a package boundary
+
+Convert **once**, at the boundary you own, and carry integer Minor Units from there:
+
+- A value that came out of `fromMinorUnits` is canonical: it converts back to the same integer, so converting it once with any implementation is exact.
+- A refund is negative. Pass `{ allowNegative: true }` when converting a net figure that can be below zero.
+- Do not convert a value with one money implementation and re-convert it with another in the same flow; the diverging input classes are computed floats and amounts near the top of the safe integer range.
+
+## Commands
+
+- `bun run check`: lint, typecheck, tests with 100% line coverage, build, `publint --strict` and `attw`.
+- `bun run test`: tests plus the coverage threshold.
+- `bun run build`: ESM and CJS bundles via `tsdown`.
+
+## Releasing
+
+Versions are computed, never edited by hand (`package.json` says `0.0.0-development` on purpose). The shared publish workflow reads the last `vX.Y.Z` tag and the conventional commit messages since then:
+
+| Commits since last release | Bump |
+| --- | --- |
+| any `feat!:` / `fix!:` / `BREAKING CHANGE:` | major (minor while on 0.x) |
+| any `feat:` | minor |
+| anything else | patch |
+
+- **Alpha, automatic:** every merge to `main` that touches code publishes `<next>-alpha.<n>` under the npm dist-tag `alpha`.
+- **Stable, on demand:** Actions -> Release -> Run workflow (on `main`) publishes `<next>` under `latest`, tags `vX.Y.Z` and creates a GitHub release.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,133 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+// src/errors.ts
+/**
+* Error thrown when a monetary value violates a decimal-scaling invariant.
+*
+* Purpose: One failure type for both conversions, carrying the diagnostic field, the offending
+* value and the reason, so each consumer can map it onto the error class its own API promises.
+* Units: `value` is whatever the caller supplied - major units, integer Minor Units, or a digit count.
+*/
+var MoneyValidationError = class MoneyValidationError extends Error {
+	field;
+	value;
+	reason;
+	constructor(field, value, reason) {
+		super(`Money validation error on field '${field}': ${reason} (received: ${String(value)})`);
+		this.name = "MoneyValidationError";
+		this.field = field;
+		this.value = value;
+		this.reason = reason;
+		Object.setPrototypeOf(this, MoneyValidationError.prototype);
+	}
+};
+/**
+* Validates a currency precision supplied by the caller.
+*
+* Purpose: Rejects an out-of-range precision with a typed error instead of letting a raw
+* `RangeError` escape from `toFixed` or a silent mis-scaling from `10 ** digits`.
+* Math: Requires `Number.isSafeInteger(digits)` and `0 <= digits <= MAX_DIGITS`.
+* Units: count of fractional decimal digits.
+* Throws: MoneyValidationError when the count is fractional, negative, or above MAX_DIGITS.
+*
+* @param digits Fractional decimal digits of the currency, supplied by the caller.
+* @param field Diagnostic field name reported on failure.
+*/
+function validateDigits(digits, field = "digits") {
+	if (!Number.isSafeInteger(digits)) throw new MoneyValidationError(field, digits, "Precision must be a safe integer");
+	if (digits < 0 || digits > 15) throw new MoneyValidationError(field, digits, `Precision must be between 0 and 15 digits`);
+}
+/**
+* Validates a monetary input against numerical boundaries.
+*
+* Math: Rejects `NaN`, non-finite values and negatives unless `allowNegative` is set.
+* Units: major units or integer Minor Units, depending on the caller.
+* Throws: MoneyValidationError on any violation.
+*
+* @param value Amount to validate.
+* @param field Diagnostic field name reported on failure.
+* @param options Validation options.
+*/
+function validateMonetaryAmount(value, field, options) {
+	if (Number.isNaN(value)) throw new MoneyValidationError(field, value, "Value cannot be NaN");
+	if (!Number.isFinite(value)) throw new MoneyValidationError(field, value, "Value must be a finite number");
+	if (!options?.allowNegative && value < 0) throw new MoneyValidationError(field, value, "Value cannot be negative");
+}
+/**
+* Validates that an amount is an exact integer number of Minor Units.
+*
+* Math: Requires a finite, sign-allowed `Number.isSafeInteger`.
+* Units: integer Minor Units.
+* Throws: MoneyValidationError when the amount is not a safe integer.
+*
+* @param minorUnits Integer Minor Units to validate.
+* @param field Diagnostic field name reported on failure.
+* @param options Validation options.
+*/
+function validateIntegerMinorUnits(minorUnits, field, options) {
+	validateMonetaryAmount(minorUnits, field, options);
+	if (!Number.isSafeInteger(minorUnits)) throw new MoneyValidationError(field, minorUnits, "Minor units amount must be a safe integer");
+}
+// src/minor-units.ts
+function scaleDecimalString(abs, precision) {
+	const factor = 10 ** precision;
+	if (String(abs).includes("e")) return abs * factor;
+	const parts = String(abs).split(".");
+	const intPart = parts[0] ?? "0";
+	const decPart = (parts[1] ?? "").padEnd(precision, "0");
+	const whole = intPart + decPart.slice(0, precision);
+	const fraction = decPart.slice(precision);
+	return Number(whole + (fraction.length > 0 ? `.${fraction}` : ""));
+}
+/**
+* Converts a major-unit amount to integer Minor Units.
+*
+* Purpose: Exact major-to-Minor conversion for any currency, with precision supplied by the caller.
+* Math: Expands the shortest decimal representation and rounds half away from zero, so binary
+* float noise (`1.005 * 100`) never decides the result; scientific notation is scaled directly.
+* Units: input in major units, output as integer Minor Units.
+* Throws: MoneyValidationError when `digits` is out of range, the amount is `NaN`, infinite or
+* negative without `allowNegative`, or the result leaves the safe integer range.
+*
+* @param amount Amount in major units.
+* @param digits Fractional decimal digits of the currency (0 for JPY, 2 for USD, 3 for KWD).
+* @param field Diagnostic field name reported on failure.
+* @param options Validation options.
+* @returns Amount as an integer number of Minor Units.
+* @example toMinorUnits(1.005, 2) // 101 (101 cents, not 100)
+*/
+function toMinorUnits(amount, digits, field = "amount", options) {
+	validateDigits(digits);
+	validateMonetaryAmount(amount, field, options);
+	const sign = amount < 0 ? -1 : 1;
+	const scaled = scaleDecimalString(Math.abs(amount), digits);
+	const result = sign * Math.round(scaled) + 0;
+	if (!Number.isSafeInteger(result)) throw new MoneyValidationError(field, amount, "Conversion to minor units failed or exceeded safe integer bounds");
+	return result;
+}
+/**
+* Converts integer Minor Units back to a major-unit amount.
+*
+* Purpose: Inverse of `toMinorUnits`, producing the shortest decimal a double can carry.
+* Math: Divides by `10 ** digits` and fixes the result to `digits` decimals, which also
+* normalises `-0` to `+0`.
+* Units: input as integer Minor Units, output in major units.
+* Throws: MoneyValidationError when `digits` is out of range, or the input is not a safe integer.
+*
+* @param minorUnits Integer Minor Units.
+* @param digits Fractional decimal digits of the currency.
+* @param field Diagnostic field name reported on failure.
+* @param options Validation options.
+* @returns Amount in major units.
+* @example fromMinorUnits(1055, 2) // 10.55
+*/
+function fromMinorUnits(minorUnits, digits, field = "minorUnits", options) {
+	validateDigits(digits);
+	validateIntegerMinorUnits(minorUnits, field, options);
+	const factor = 10 ** digits;
+	return (minorUnits < 0 ? -1 : 1) * Number((Math.abs(minorUnits) / factor).toFixed(digits)) + 0;
+}
+exports.MoneyValidationError = MoneyValidationError;
+exports.fromMinorUnits = fromMinorUnits;
+exports.toMinorUnits = toMinorUnits;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/errors.ts","../src/validate.ts","../src/minor-units.ts"],"sourcesContent":["/**\n * Error thrown when a monetary value violates a decimal-scaling invariant.\n *\n * Purpose: One failure type for both conversions, carrying the diagnostic field, the offending\n * value and the reason, so each consumer can map it onto the error class its own API promises.\n * Units: `value` is whatever the caller supplied - major units, integer Minor Units, or a digit count.\n */\nexport class MoneyValidationError extends Error {\n\treadonly field: string\n\treadonly value: unknown\n\treadonly reason: string\n\n\tconstructor(field: string, value: unknown, reason: string) {\n\t\tsuper(`Money validation error on field '${field}': ${reason} (received: ${String(value)})`)\n\t\tthis.name = \"MoneyValidationError\"\n\t\tthis.field = field\n\t\tthis.value = value\n\t\tthis.reason = reason\n\t\tObject.setPrototypeOf(this, MoneyValidationError.prototype)\n\t}\n}\n","import { MoneyValidationError } from \"./errors\"\n\n/**\n * Options controlling monetary validation.\n */\nexport interface ValidateAmountOptions {\n\t/** If true, negative values are accepted (e.g. a refund balance). */\n\treadonly allowNegative?: boolean\n}\n\n/**\n * Highest decimal precision the conversions accept.\n *\n * Math: `10 ** 15` is the largest power of ten a double holds exactly, so any larger precision\n * could not be scaled without losing digits.\n * Units: count of fractional decimal digits.\n */\nexport const MAX_DIGITS = 15\n\n/**\n * Validates a currency precision supplied by the caller.\n *\n * Purpose: Rejects an out-of-range precision with a typed error instead of letting a raw\n * `RangeError` escape from `toFixed` or a silent mis-scaling from `10 ** digits`.\n * Math: Requires `Number.isSafeInteger(digits)` and `0 <= digits <= MAX_DIGITS`.\n * Units: count of fractional decimal digits.\n * Throws: MoneyValidationError when the count is fractional, negative, or above MAX_DIGITS.\n *\n * @param digits Fractional decimal digits of the currency, supplied by the caller.\n * @param field Diagnostic field name reported on failure.\n */\nexport function validateDigits(digits: number, field = \"digits\"): void {\n\tif (!Number.isSafeInteger(digits)) {\n\t\tthrow new MoneyValidationError(field, digits, \"Precision must be a safe integer\")\n\t}\n\tif (digits < 0 || digits > MAX_DIGITS) {\n\t\tthrow new MoneyValidationError(\n\t\t\tfield,\n\t\t\tdigits,\n\t\t\t`Precision must be between 0 and ${MAX_DIGITS} digits`,\n\t\t)\n\t}\n}\n\n/**\n * Validates a monetary input against numerical boundaries.\n *\n * Math: Rejects `NaN`, non-finite values and negatives unless `allowNegative` is set.\n * Units: major units or integer Minor Units, depending on the caller.\n * Throws: MoneyValidationError on any violation.\n *\n * @param value Amount to validate.\n * @param field Diagnostic field name reported on failure.\n * @param options Validation options.\n */\nexport function validateMonetaryAmount(\n\tvalue: number,\n\tfield: string,\n\toptions?: ValidateAmountOptions,\n): void {\n\tif (Number.isNaN(value)) {\n\t\tthrow new MoneyValidationError(field, value, \"Value cannot be NaN\")\n\t}\n\tif (!Number.isFinite(value)) {\n\t\tthrow new MoneyValidationError(field, value, \"Value must be a finite number\")\n\t}\n\tif (!options?.allowNegative && value < 0) {\n\t\tthrow new MoneyValidationError(field, value, \"Value cannot be negative\")\n\t}\n}\n\n/**\n * Validates that an amount is an exact integer number of Minor Units.\n *\n * Math: Requires a finite, sign-allowed `Number.isSafeInteger`.\n * Units: integer Minor Units.\n * Throws: MoneyValidationError when the amount is not a safe integer.\n *\n * @param minorUnits Integer Minor Units to validate.\n * @param field Diagnostic field name reported on failure.\n * @param options Validation options.\n */\nexport function validateIntegerMinorUnits(\n\tminorUnits: number,\n\tfield: string,\n\toptions?: ValidateAmountOptions,\n): void {\n\tvalidateMonetaryAmount(minorUnits, field, options)\n\tif (!Number.isSafeInteger(minorUnits)) {\n\t\tthrow new MoneyValidationError(field, minorUnits, \"Minor units amount must be a safe integer\")\n\t}\n}\n","import { MoneyValidationError } from \"./errors\"\nimport {\n\ttype ValidateAmountOptions,\n\tvalidateDigits,\n\tvalidateIntegerMinorUnits,\n\tvalidateMonetaryAmount,\n} from \"./validate\"\n\nfunction scaleDecimalString(abs: number, precision: number): number {\n\tconst factor = 10 ** precision\n\tif (String(abs).includes(\"e\")) {\n\t\treturn abs * factor\n\t}\n\tconst parts = String(abs).split(\".\")\n\tconst intPart = parts[0] ?? \"0\"\n\tconst decPart = (parts[1] ?? \"\").padEnd(precision, \"0\")\n\tconst whole = intPart + decPart.slice(0, precision)\n\tconst fraction = decPart.slice(precision)\n\treturn Number(whole + (fraction.length > 0 ? `.${fraction}` : \"\"))\n}\n\n/**\n * Converts a major-unit amount to integer Minor Units.\n *\n * Purpose: Exact major-to-Minor conversion for any currency, with precision supplied by the caller.\n * Math: Expands the shortest decimal representation and rounds half away from zero, so binary\n * float noise (`1.005 * 100`) never decides the result; scientific notation is scaled directly.\n * Units: input in major units, output as integer Minor Units.\n * Throws: MoneyValidationError when `digits` is out of range, the amount is `NaN`, infinite or\n * negative without `allowNegative`, or the result leaves the safe integer range.\n *\n * @param amount Amount in major units.\n * @param digits Fractional decimal digits of the currency (0 for JPY, 2 for USD, 3 for KWD).\n * @param field Diagnostic field name reported on failure.\n * @param options Validation options.\n * @returns Amount as an integer number of Minor Units.\n * @example toMinorUnits(1.005, 2) // 101 (101 cents, not 100)\n */\nexport function toMinorUnits(\n\tamount: number,\n\tdigits: number,\n\tfield = \"amount\",\n\toptions?: ValidateAmountOptions,\n): number {\n\tvalidateDigits(digits)\n\tvalidateMonetaryAmount(amount, field, options)\n\tconst sign = amount < 0 ? -1 : 1\n\tconst scaled = scaleDecimalString(Math.abs(amount), digits)\n\tconst result = sign * Math.round(scaled) + 0\n\tif (!Number.isSafeInteger(result)) {\n\t\tthrow new MoneyValidationError(\n\t\t\tfield,\n\t\t\tamount,\n\t\t\t\"Conversion to minor units failed or exceeded safe integer bounds\",\n\t\t)\n\t}\n\treturn result\n}\n\n/**\n * Converts integer Minor Units back to a major-unit amount.\n *\n * Purpose: Inverse of `toMinorUnits`, producing the shortest decimal a double can carry.\n * Math: Divides by `10 ** digits` and fixes the result to `digits` decimals, which also\n * normalises `-0` to `+0`.\n * Units: input as integer Minor Units, output in major units.\n * Throws: MoneyValidationError when `digits` is out of range, or the input is not a safe integer.\n *\n * @param minorUnits Integer Minor Units.\n * @param digits Fractional decimal digits of the currency.\n * @param field Diagnostic field name reported on failure.\n * @param options Validation options.\n * @returns Amount in major units.\n * @example fromMinorUnits(1055, 2) // 10.55\n */\nexport function fromMinorUnits(\n\tminorUnits: number,\n\tdigits: number,\n\tfield = \"minorUnits\",\n\toptions?: ValidateAmountOptions,\n): number {\n\tvalidateDigits(digits)\n\tvalidateIntegerMinorUnits(minorUnits, field, options)\n\tconst factor = 10 ** digits\n\tconst sign = minorUnits < 0 ? -1 : 1\n\tconst abs = Math.abs(minorUnits)\n\treturn sign * Number((abs / factor).toFixed(digits)) + 0\n}\n"],"mappings":";;;;;;;;;AAOA,IAAa,uBAAb,MAAa,6BAA6B,MAAM;CAC/C;CACA;CACA;CAEA,YAAY,OAAe,OAAgB,QAAgB;EAC1D,MAAM,oCAAoC,MAAM,KAAK,OAAO,cAAc,OAAO,KAAK,EAAE,EAAE;EAC1F,KAAK,OAAO;EACZ,KAAK,QAAQ;EACb,KAAK,QAAQ;EACb,KAAK,SAAS;EACd,OAAO,eAAe,MAAM,qBAAqB,SAAS;CAC3D;AACD;;;;;;;;;;;;;ACWA,SAAgB,eAAe,QAAgB,QAAQ,UAAgB;CACtE,IAAI,CAAC,OAAO,cAAc,MAAM,GAC/B,MAAM,IAAI,qBAAqB,OAAO,QAAQ,kCAAkC;CAEjF,IAAI,SAAS,KAAK,SAAA,IACjB,MAAM,IAAI,qBACT,OACA,QACA,2CACD;AAEF;;;;;;;;;;;;AAaA,SAAgB,uBACf,OACA,OACA,SACO;CACP,IAAI,OAAO,MAAM,KAAK,GACrB,MAAM,IAAI,qBAAqB,OAAO,OAAO,qBAAqB;CAEnE,IAAI,CAAC,OAAO,SAAS,KAAK,GACzB,MAAM,IAAI,qBAAqB,OAAO,OAAO,+BAA+B;CAE7E,IAAI,CAAC,SAAS,iBAAiB,QAAQ,GACtC,MAAM,IAAI,qBAAqB,OAAO,OAAO,0BAA0B;AAEzE;;;;;;;;;;;;AAaA,SAAgB,0BACf,YACA,OACA,SACO;CACP,uBAAuB,YAAY,OAAO,OAAO;CACjD,IAAI,CAAC,OAAO,cAAc,UAAU,GACnC,MAAM,IAAI,qBAAqB,OAAO,YAAY,2CAA2C;AAE/F;;ACnFA,SAAS,mBAAmB,KAAa,WAA2B;CACnE,MAAM,SAAS,MAAM;CACrB,IAAI,OAAO,GAAG,CAAC,CAAC,SAAS,GAAG,GAC3B,OAAO,MAAM;CAEd,MAAM,QAAQ,OAAO,GAAG,CAAC,CAAC,MAAM,GAAG;CACnC,MAAM,UAAU,MAAM,MAAM;CAC5B,MAAM,WAAW,MAAM,MAAM,GAAA,CAAI,OAAO,WAAW,GAAG;CACtD,MAAM,QAAQ,UAAU,QAAQ,MAAM,GAAG,SAAS;CAClD,MAAM,WAAW,QAAQ,MAAM,SAAS;CACxC,OAAO,OAAO,SAAS,SAAS,SAAS,IAAI,IAAI,aAAa,GAAG;AAClE;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,aACf,QACA,QACA,QAAQ,UACR,SACS;CACT,eAAe,MAAM;CACrB,uBAAuB,QAAQ,OAAO,OAAO;CAC7C,MAAM,OAAO,SAAS,IAAI,KAAK;CAC/B,MAAM,SAAS,mBAAmB,KAAK,IAAI,MAAM,GAAG,MAAM;CAC1D,MAAM,SAAS,OAAO,KAAK,MAAM,MAAM,IAAI;CAC3C,IAAI,CAAC,OAAO,cAAc,MAAM,GAC/B,MAAM,IAAI,qBACT,OACA,QACA,kEACD;CAED,OAAO;AACR;;;;;;;;;;;;;;;;;AAkBA,SAAgB,eACf,YACA,QACA,QAAQ,cACR,SACS;CACT,eAAe,MAAM;CACrB,0BAA0B,YAAY,OAAO,OAAO;CACpD,MAAM,SAAS,MAAM;CAGrB,QAFa,aAAa,IAAI,KAAK,KAErB,QADF,KAAK,IAAI,UACG,IAAI,OAAA,CAAQ,QAAQ,MAAM,CAAC,IAAI;AACxD"}

package/dist/index.d.cts

@@ -0,0 +1,56 @@
+/**
+ * Error thrown when a monetary value violates a decimal-scaling invariant.
+ *
+ * Purpose: One failure type for both conversions, carrying the diagnostic field, the offending
+ * value and the reason, so each consumer can map it onto the error class its own API promises.
+ * Units: `value` is whatever the caller supplied - major units, integer Minor Units, or a digit count.
+ */
+export declare class MoneyValidationError extends Error {
+  readonly field: string;
+  readonly value: unknown;
+  readonly reason: string;
+  constructor(field: string, value: unknown, reason: string);
+}
+/**
+ * Options controlling monetary validation.
+ */
+interface ValidateAmountOptions {
+  /** If true, negative values are accepted (e.g. a refund balance). */
+  readonly allowNegative?: boolean;
+}
+/**
+ * Converts a major-unit amount to integer Minor Units.
+ *
+ * Purpose: Exact major-to-Minor conversion for any currency, with precision supplied by the caller.
+ * Math: Expands the shortest decimal representation and rounds half away from zero, so binary
+ * float noise (`1.005 * 100`) never decides the result; scientific notation is scaled directly.
+ * Units: input in major units, output as integer Minor Units.
+ * Throws: MoneyValidationError when `digits` is out of range, the amount is `NaN`, infinite or
+ * negative without `allowNegative`, or the result leaves the safe integer range.
+ *
+ * @param amount Amount in major units.
+ * @param digits Fractional decimal digits of the currency (0 for JPY, 2 for USD, 3 for KWD).
+ * @param field Diagnostic field name reported on failure.
+ * @param options Validation options.
+ * @returns Amount as an integer number of Minor Units.
+ * @example toMinorUnits(1.005, 2) // 101 (101 cents, not 100)
+ */
+export declare function toMinorUnits(amount: number, digits: number, field?: string, options?: ValidateAmountOptions): number;
+/**
+ * Converts integer Minor Units back to a major-unit amount.
+ *
+ * Purpose: Inverse of `toMinorUnits`, producing the shortest decimal a double can carry.
+ * Math: Divides by `10 ** digits` and fixes the result to `digits` decimals, which also
+ * normalises `-0` to `+0`.
+ * Units: input as integer Minor Units, output in major units.
+ * Throws: MoneyValidationError when `digits` is out of range, or the input is not a safe integer.
+ *
+ * @param minorUnits Integer Minor Units.
+ * @param digits Fractional decimal digits of the currency.
+ * @param field Diagnostic field name reported on failure.
+ * @param options Validation options.
+ * @returns Amount in major units.
+ * @example fromMinorUnits(1055, 2) // 10.55
+ */
+export declare function fromMinorUnits(minorUnits: number, digits: number, field?: string, options?: ValidateAmountOptions): number;
+export type { ValidateAmountOptions };

package/dist/index.d.mts

@@ -0,0 +1,56 @@
+/**
+ * Error thrown when a monetary value violates a decimal-scaling invariant.
+ *
+ * Purpose: One failure type for both conversions, carrying the diagnostic field, the offending
+ * value and the reason, so each consumer can map it onto the error class its own API promises.
+ * Units: `value` is whatever the caller supplied - major units, integer Minor Units, or a digit count.
+ */
+export declare class MoneyValidationError extends Error {
+  readonly field: string;
+  readonly value: unknown;
+  readonly reason: string;
+  constructor(field: string, value: unknown, reason: string);
+}
+/**
+ * Options controlling monetary validation.
+ */
+interface ValidateAmountOptions {
+  /** If true, negative values are accepted (e.g. a refund balance). */
+  readonly allowNegative?: boolean;
+}
+/**
+ * Converts a major-unit amount to integer Minor Units.
+ *
+ * Purpose: Exact major-to-Minor conversion for any currency, with precision supplied by the caller.
+ * Math: Expands the shortest decimal representation and rounds half away from zero, so binary
+ * float noise (`1.005 * 100`) never decides the result; scientific notation is scaled directly.
+ * Units: input in major units, output as integer Minor Units.
+ * Throws: MoneyValidationError when `digits` is out of range, the amount is `NaN`, infinite or
+ * negative without `allowNegative`, or the result leaves the safe integer range.
+ *
+ * @param amount Amount in major units.
+ * @param digits Fractional decimal digits of the currency (0 for JPY, 2 for USD, 3 for KWD).
+ * @param field Diagnostic field name reported on failure.
+ * @param options Validation options.
+ * @returns Amount as an integer number of Minor Units.
+ * @example toMinorUnits(1.005, 2) // 101 (101 cents, not 100)
+ */
+export declare function toMinorUnits(amount: number, digits: number, field?: string, options?: ValidateAmountOptions): number;
+/**
+ * Converts integer Minor Units back to a major-unit amount.
+ *
+ * Purpose: Inverse of `toMinorUnits`, producing the shortest decimal a double can carry.
+ * Math: Divides by `10 ** digits` and fixes the result to `digits` decimals, which also
+ * normalises `-0` to `+0`.
+ * Units: input as integer Minor Units, output in major units.
+ * Throws: MoneyValidationError when `digits` is out of range, or the input is not a safe integer.
+ *
+ * @param minorUnits Integer Minor Units.
+ * @param digits Fractional decimal digits of the currency.
+ * @param field Diagnostic field name reported on failure.
+ * @param options Validation options.
+ * @returns Amount in major units.
+ * @example fromMinorUnits(1055, 2) // 10.55
+ */
+export declare function fromMinorUnits(minorUnits: number, digits: number, field?: string, options?: ValidateAmountOptions): number;
+export type { ValidateAmountOptions };

package/dist/index.mjs

@@ -0,0 +1,130 @@
+// src/errors.ts
+/**
+* Error thrown when a monetary value violates a decimal-scaling invariant.
+*
+* Purpose: One failure type for both conversions, carrying the diagnostic field, the offending
+* value and the reason, so each consumer can map it onto the error class its own API promises.
+* Units: `value` is whatever the caller supplied - major units, integer Minor Units, or a digit count.
+*/
+var MoneyValidationError = class MoneyValidationError extends Error {
+	field;
+	value;
+	reason;
+	constructor(field, value, reason) {
+		super(`Money validation error on field '${field}': ${reason} (received: ${String(value)})`);
+		this.name = "MoneyValidationError";
+		this.field = field;
+		this.value = value;
+		this.reason = reason;
+		Object.setPrototypeOf(this, MoneyValidationError.prototype);
+	}
+};
+/**
+* Validates a currency precision supplied by the caller.
+*
+* Purpose: Rejects an out-of-range precision with a typed error instead of letting a raw
+* `RangeError` escape from `toFixed` or a silent mis-scaling from `10 ** digits`.
+* Math: Requires `Number.isSafeInteger(digits)` and `0 <= digits <= MAX_DIGITS`.
+* Units: count of fractional decimal digits.
+* Throws: MoneyValidationError when the count is fractional, negative, or above MAX_DIGITS.
+*
+* @param digits Fractional decimal digits of the currency, supplied by the caller.
+* @param field Diagnostic field name reported on failure.
+*/
+function validateDigits(digits, field = "digits") {
+	if (!Number.isSafeInteger(digits)) throw new MoneyValidationError(field, digits, "Precision must be a safe integer");
+	if (digits < 0 || digits > 15) throw new MoneyValidationError(field, digits, `Precision must be between 0 and 15 digits`);
+}
+/**
+* Validates a monetary input against numerical boundaries.
+*
+* Math: Rejects `NaN`, non-finite values and negatives unless `allowNegative` is set.
+* Units: major units or integer Minor Units, depending on the caller.
+* Throws: MoneyValidationError on any violation.
+*
+* @param value Amount to validate.
+* @param field Diagnostic field name reported on failure.
+* @param options Validation options.
+*/
+function validateMonetaryAmount(value, field, options) {
+	if (Number.isNaN(value)) throw new MoneyValidationError(field, value, "Value cannot be NaN");
+	if (!Number.isFinite(value)) throw new MoneyValidationError(field, value, "Value must be a finite number");
+	if (!options?.allowNegative && value < 0) throw new MoneyValidationError(field, value, "Value cannot be negative");
+}
+/**
+* Validates that an amount is an exact integer number of Minor Units.
+*
+* Math: Requires a finite, sign-allowed `Number.isSafeInteger`.
+* Units: integer Minor Units.
+* Throws: MoneyValidationError when the amount is not a safe integer.
+*
+* @param minorUnits Integer Minor Units to validate.
+* @param field Diagnostic field name reported on failure.
+* @param options Validation options.
+*/
+function validateIntegerMinorUnits(minorUnits, field, options) {
+	validateMonetaryAmount(minorUnits, field, options);
+	if (!Number.isSafeInteger(minorUnits)) throw new MoneyValidationError(field, minorUnits, "Minor units amount must be a safe integer");
+}
+// src/minor-units.ts
+function scaleDecimalString(abs, precision) {
+	const factor = 10 ** precision;
+	if (String(abs).includes("e")) return abs * factor;
+	const parts = String(abs).split(".");
+	const intPart = parts[0] ?? "0";
+	const decPart = (parts[1] ?? "").padEnd(precision, "0");
+	const whole = intPart + decPart.slice(0, precision);
+	const fraction = decPart.slice(precision);
+	return Number(whole + (fraction.length > 0 ? `.${fraction}` : ""));
+}
+/**
+* Converts a major-unit amount to integer Minor Units.
+*
+* Purpose: Exact major-to-Minor conversion for any currency, with precision supplied by the caller.
+* Math: Expands the shortest decimal representation and rounds half away from zero, so binary
+* float noise (`1.005 * 100`) never decides the result; scientific notation is scaled directly.
+* Units: input in major units, output as integer Minor Units.
+* Throws: MoneyValidationError when `digits` is out of range, the amount is `NaN`, infinite or
+* negative without `allowNegative`, or the result leaves the safe integer range.
+*
+* @param amount Amount in major units.
+* @param digits Fractional decimal digits of the currency (0 for JPY, 2 for USD, 3 for KWD).
+* @param field Diagnostic field name reported on failure.
+* @param options Validation options.
+* @returns Amount as an integer number of Minor Units.
+* @example toMinorUnits(1.005, 2) // 101 (101 cents, not 100)
+*/
+function toMinorUnits(amount, digits, field = "amount", options) {
+	validateDigits(digits);
+	validateMonetaryAmount(amount, field, options);
+	const sign = amount < 0 ? -1 : 1;
+	const scaled = scaleDecimalString(Math.abs(amount), digits);
+	const result = sign * Math.round(scaled) + 0;
+	if (!Number.isSafeInteger(result)) throw new MoneyValidationError(field, amount, "Conversion to minor units failed or exceeded safe integer bounds");
+	return result;
+}
+/**
+* Converts integer Minor Units back to a major-unit amount.
+*
+* Purpose: Inverse of `toMinorUnits`, producing the shortest decimal a double can carry.
+* Math: Divides by `10 ** digits` and fixes the result to `digits` decimals, which also
+* normalises `-0` to `+0`.
+* Units: input as integer Minor Units, output in major units.
+* Throws: MoneyValidationError when `digits` is out of range, or the input is not a safe integer.
+*
+* @param minorUnits Integer Minor Units.
+* @param digits Fractional decimal digits of the currency.
+* @param field Diagnostic field name reported on failure.
+* @param options Validation options.
+* @returns Amount in major units.
+* @example fromMinorUnits(1055, 2) // 10.55
+*/
+function fromMinorUnits(minorUnits, digits, field = "minorUnits", options) {
+	validateDigits(digits);
+	validateIntegerMinorUnits(minorUnits, field, options);
+	const factor = 10 ** digits;
+	return (minorUnits < 0 ? -1 : 1) * Number((Math.abs(minorUnits) / factor).toFixed(digits)) + 0;
+}
+export { MoneyValidationError, fromMinorUnits, toMinorUnits };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/errors.ts","../src/validate.ts","../src/minor-units.ts"],"sourcesContent":["/**\n * Error thrown when a monetary value violates a decimal-scaling invariant.\n *\n * Purpose: One failure type for both conversions, carrying the diagnostic field, the offending\n * value and the reason, so each consumer can map it onto the error class its own API promises.\n * Units: `value` is whatever the caller supplied - major units, integer Minor Units, or a digit count.\n */\nexport class MoneyValidationError extends Error {\n\treadonly field: string\n\treadonly value: unknown\n\treadonly reason: string\n\n\tconstructor(field: string, value: unknown, reason: string) {\n\t\tsuper(`Money validation error on field '${field}': ${reason} (received: ${String(value)})`)\n\t\tthis.name = \"MoneyValidationError\"\n\t\tthis.field = field\n\t\tthis.value = value\n\t\tthis.reason = reason\n\t\tObject.setPrototypeOf(this, MoneyValidationError.prototype)\n\t}\n}\n","import { MoneyValidationError } from \"./errors\"\n\n/**\n * Options controlling monetary validation.\n */\nexport interface ValidateAmountOptions {\n\t/** If true, negative values are accepted (e.g. a refund balance). */\n\treadonly allowNegative?: boolean\n}\n\n/**\n * Highest decimal precision the conversions accept.\n *\n * Math: `10 ** 15` is the largest power of ten a double holds exactly, so any larger precision\n * could not be scaled without losing digits.\n * Units: count of fractional decimal digits.\n */\nexport const MAX_DIGITS = 15\n\n/**\n * Validates a currency precision supplied by the caller.\n *\n * Purpose: Rejects an out-of-range precision with a typed error instead of letting a raw\n * `RangeError` escape from `toFixed` or a silent mis-scaling from `10 ** digits`.\n * Math: Requires `Number.isSafeInteger(digits)` and `0 <= digits <= MAX_DIGITS`.\n * Units: count of fractional decimal digits.\n * Throws: MoneyValidationError when the count is fractional, negative, or above MAX_DIGITS.\n *\n * @param digits Fractional decimal digits of the currency, supplied by the caller.\n * @param field Diagnostic field name reported on failure.\n */\nexport function validateDigits(digits: number, field = \"digits\"): void {\n\tif (!Number.isSafeInteger(digits)) {\n\t\tthrow new MoneyValidationError(field, digits, \"Precision must be a safe integer\")\n\t}\n\tif (digits < 0 || digits > MAX_DIGITS) {\n\t\tthrow new MoneyValidationError(\n\t\t\tfield,\n\t\t\tdigits,\n\t\t\t`Precision must be between 0 and ${MAX_DIGITS} digits`,\n\t\t)\n\t}\n}\n\n/**\n * Validates a monetary input against numerical boundaries.\n *\n * Math: Rejects `NaN`, non-finite values and negatives unless `allowNegative` is set.\n * Units: major units or integer Minor Units, depending on the caller.\n * Throws: MoneyValidationError on any violation.\n *\n * @param value Amount to validate.\n * @param field Diagnostic field name reported on failure.\n * @param options Validation options.\n */\nexport function validateMonetaryAmount(\n\tvalue: number,\n\tfield: string,\n\toptions?: ValidateAmountOptions,\n): void {\n\tif (Number.isNaN(value)) {\n\t\tthrow new MoneyValidationError(field, value, \"Value cannot be NaN\")\n\t}\n\tif (!Number.isFinite(value)) {\n\t\tthrow new MoneyValidationError(field, value, \"Value must be a finite number\")\n\t}\n\tif (!options?.allowNegative && value < 0) {\n\t\tthrow new MoneyValidationError(field, value, \"Value cannot be negative\")\n\t}\n}\n\n/**\n * Validates that an amount is an exact integer number of Minor Units.\n *\n * Math: Requires a finite, sign-allowed `Number.isSafeInteger`.\n * Units: integer Minor Units.\n * Throws: MoneyValidationError when the amount is not a safe integer.\n *\n * @param minorUnits Integer Minor Units to validate.\n * @param field Diagnostic field name reported on failure.\n * @param options Validation options.\n */\nexport function validateIntegerMinorUnits(\n\tminorUnits: number,\n\tfield: string,\n\toptions?: ValidateAmountOptions,\n): void {\n\tvalidateMonetaryAmount(minorUnits, field, options)\n\tif (!Number.isSafeInteger(minorUnits)) {\n\t\tthrow new MoneyValidationError(field, minorUnits, \"Minor units amount must be a safe integer\")\n\t}\n}\n","import { MoneyValidationError } from \"./errors\"\nimport {\n\ttype ValidateAmountOptions,\n\tvalidateDigits,\n\tvalidateIntegerMinorUnits,\n\tvalidateMonetaryAmount,\n} from \"./validate\"\n\nfunction scaleDecimalString(abs: number, precision: number): number {\n\tconst factor = 10 ** precision\n\tif (String(abs).includes(\"e\")) {\n\t\treturn abs * factor\n\t}\n\tconst parts = String(abs).split(\".\")\n\tconst intPart = parts[0] ?? \"0\"\n\tconst decPart = (parts[1] ?? \"\").padEnd(precision, \"0\")\n\tconst whole = intPart + decPart.slice(0, precision)\n\tconst fraction = decPart.slice(precision)\n\treturn Number(whole + (fraction.length > 0 ? `.${fraction}` : \"\"))\n}\n\n/**\n * Converts a major-unit amount to integer Minor Units.\n *\n * Purpose: Exact major-to-Minor conversion for any currency, with precision supplied by the caller.\n * Math: Expands the shortest decimal representation and rounds half away from zero, so binary\n * float noise (`1.005 * 100`) never decides the result; scientific notation is scaled directly.\n * Units: input in major units, output as integer Minor Units.\n * Throws: MoneyValidationError when `digits` is out of range, the amount is `NaN`, infinite or\n * negative without `allowNegative`, or the result leaves the safe integer range.\n *\n * @param amount Amount in major units.\n * @param digits Fractional decimal digits of the currency (0 for JPY, 2 for USD, 3 for KWD).\n * @param field Diagnostic field name reported on failure.\n * @param options Validation options.\n * @returns Amount as an integer number of Minor Units.\n * @example toMinorUnits(1.005, 2) // 101 (101 cents, not 100)\n */\nexport function toMinorUnits(\n\tamount: number,\n\tdigits: number,\n\tfield = \"amount\",\n\toptions?: ValidateAmountOptions,\n): number {\n\tvalidateDigits(digits)\n\tvalidateMonetaryAmount(amount, field, options)\n\tconst sign = amount < 0 ? -1 : 1\n\tconst scaled = scaleDecimalString(Math.abs(amount), digits)\n\tconst result = sign * Math.round(scaled) + 0\n\tif (!Number.isSafeInteger(result)) {\n\t\tthrow new MoneyValidationError(\n\t\t\tfield,\n\t\t\tamount,\n\t\t\t\"Conversion to minor units failed or exceeded safe integer bounds\",\n\t\t)\n\t}\n\treturn result\n}\n\n/**\n * Converts integer Minor Units back to a major-unit amount.\n *\n * Purpose: Inverse of `toMinorUnits`, producing the shortest decimal a double can carry.\n * Math: Divides by `10 ** digits` and fixes the result to `digits` decimals, which also\n * normalises `-0` to `+0`.\n * Units: input as integer Minor Units, output in major units.\n * Throws: MoneyValidationError when `digits` is out of range, or the input is not a safe integer.\n *\n * @param minorUnits Integer Minor Units.\n * @param digits Fractional decimal digits of the currency.\n * @param field Diagnostic field name reported on failure.\n * @param options Validation options.\n * @returns Amount in major units.\n * @example fromMinorUnits(1055, 2) // 10.55\n */\nexport function fromMinorUnits(\n\tminorUnits: number,\n\tdigits: number,\n\tfield = \"minorUnits\",\n\toptions?: ValidateAmountOptions,\n): number {\n\tvalidateDigits(digits)\n\tvalidateIntegerMinorUnits(minorUnits, field, options)\n\tconst factor = 10 ** digits\n\tconst sign = minorUnits < 0 ? -1 : 1\n\tconst abs = Math.abs(minorUnits)\n\treturn sign * Number((abs / factor).toFixed(digits)) + 0\n}\n"],"mappings":";;;;;;;;AAOA,IAAa,uBAAb,MAAa,6BAA6B,MAAM;CAC/C;CACA;CACA;CAEA,YAAY,OAAe,OAAgB,QAAgB;EAC1D,MAAM,oCAAoC,MAAM,KAAK,OAAO,cAAc,OAAO,KAAK,EAAE,EAAE;EAC1F,KAAK,OAAO;EACZ,KAAK,QAAQ;EACb,KAAK,QAAQ;EACb,KAAK,SAAS;EACd,OAAO,eAAe,MAAM,qBAAqB,SAAS;CAC3D;AACD;;;;;;;;;;;;;ACWA,SAAgB,eAAe,QAAgB,QAAQ,UAAgB;CACtE,IAAI,CAAC,OAAO,cAAc,MAAM,GAC/B,MAAM,IAAI,qBAAqB,OAAO,QAAQ,kCAAkC;CAEjF,IAAI,SAAS,KAAK,SAAA,IACjB,MAAM,IAAI,qBACT,OACA,QACA,2CACD;AAEF;;;;;;;;;;;;AAaA,SAAgB,uBACf,OACA,OACA,SACO;CACP,IAAI,OAAO,MAAM,KAAK,GACrB,MAAM,IAAI,qBAAqB,OAAO,OAAO,qBAAqB;CAEnE,IAAI,CAAC,OAAO,SAAS,KAAK,GACzB,MAAM,IAAI,qBAAqB,OAAO,OAAO,+BAA+B;CAE7E,IAAI,CAAC,SAAS,iBAAiB,QAAQ,GACtC,MAAM,IAAI,qBAAqB,OAAO,OAAO,0BAA0B;AAEzE;;;;;;;;;;;;AAaA,SAAgB,0BACf,YACA,OACA,SACO;CACP,uBAAuB,YAAY,OAAO,OAAO;CACjD,IAAI,CAAC,OAAO,cAAc,UAAU,GACnC,MAAM,IAAI,qBAAqB,OAAO,YAAY,2CAA2C;AAE/F;;ACnFA,SAAS,mBAAmB,KAAa,WAA2B;CACnE,MAAM,SAAS,MAAM;CACrB,IAAI,OAAO,GAAG,CAAC,CAAC,SAAS,GAAG,GAC3B,OAAO,MAAM;CAEd,MAAM,QAAQ,OAAO,GAAG,CAAC,CAAC,MAAM,GAAG;CACnC,MAAM,UAAU,MAAM,MAAM;CAC5B,MAAM,WAAW,MAAM,MAAM,GAAA,CAAI,OAAO,WAAW,GAAG;CACtD,MAAM,QAAQ,UAAU,QAAQ,MAAM,GAAG,SAAS;CAClD,MAAM,WAAW,QAAQ,MAAM,SAAS;CACxC,OAAO,OAAO,SAAS,SAAS,SAAS,IAAI,IAAI,aAAa,GAAG;AAClE;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,aACf,QACA,QACA,QAAQ,UACR,SACS;CACT,eAAe,MAAM;CACrB,uBAAuB,QAAQ,OAAO,OAAO;CAC7C,MAAM,OAAO,SAAS,IAAI,KAAK;CAC/B,MAAM,SAAS,mBAAmB,KAAK,IAAI,MAAM,GAAG,MAAM;CAC1D,MAAM,SAAS,OAAO,KAAK,MAAM,MAAM,IAAI;CAC3C,IAAI,CAAC,OAAO,cAAc,MAAM,GAC/B,MAAM,IAAI,qBACT,OACA,QACA,kEACD;CAED,OAAO;AACR;;;;;;;;;;;;;;;;;AAkBA,SAAgB,eACf,YACA,QACA,QAAQ,cACR,SACS;CACT,eAAe,MAAM;CACrB,0BAA0B,YAAY,OAAO,OAAO;CACpD,MAAM,SAAS,MAAM;CAGrB,QAFa,aAAa,IAAI,KAAK,KAErB,QADF,KAAK,IAAI,UACG,IAAI,OAAA,CAAQ,QAAQ,MAAM,CAAC,IAAI;AACxD"}

package/package.json

@@ -1,6 +1,57 @@
 {
-  "name": "@trajectonomics/money",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@trajectonomics/money",
+	"version": "0.1.0-alpha.0",
+	"description": "Pure decimal scaling: major units to integer Minor Units and back, with precision supplied by the caller.",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/trajectonomics/money.git"
+	},
+	"type": "module",
+	"sideEffects": false,
+	"packageManager": "bun@1.4.4",
+	"engines": {
+		"node": ">=20.0.0"
+	},
+	"main": "./dist/index.cjs",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.cts",
+	"exports": {
+		".": {
+			"import": {
+				"types": "./dist/index.d.mts",
+				"default": "./dist/index.mjs"
+			},
+			"require": {
+				"types": "./dist/index.d.cts",
+				"default": "./dist/index.cjs"
+			}
+		},
+		"./package.json": "./package.json"
+	},
+	"files": [
+		"dist"
+	],
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	},
+	"scripts": {
+		"build": "tsdown",
+		"test": "bun test --coverage --coverage-reporter=lcov --coverage-reporter=text && bun run scripts/check-coverage.ts",
+		"typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.test.json",
+		"lint": "biome ci --error-on-warnings .",
+		"format": "biome check --write .",
+		"check": "bun run lint && bun run typecheck && bun run test && bun run build && bun run lint:package",
+		"lint:package": "publint --strict && attw --pack . --profile node16"
+	},
+	"devDependencies": {
+		"@arethetypeswrong/cli": "^0.18.5",
+		"@biomejs/biome": "2.6.3",
+		"@trajectonomics/tooling": "1.1.0",
+		"@types/bun": "^1.4.4",
+		"publint": "^0.3.25",
+		"tsdown": "^0.23.2",
+		"typescript": "^7.0.2"
+	}
+}