@jetta/axle-load-calculator 0.3.1 → 0.3.3

package/CHANGELOG.md

@@ -0,0 +1,71 @@
+# Changelog
+
+All notable changes to `@jetta/axle-load-calculator` are documented in this file.
+
+Format based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## [Unreleased]
+
+### Added
+
+- Cargo collision check after axle loads are written (`CollisionChecker`), using `lt` from `@jetta/number-compare` (default epsilon `1e-9`).
+- Public `ItemOverlapError` thrown by `calculate_weight_on_axles_physics` when two allocated items share volume.
+
+### Fixed
+
+- Face-touching boxes (IEEE ULP on edges such as `4.075 + 0.815` vs `4.89`) are no longer treated as overlap, so callers can keep axle kg instead of skipping the gate.
+
+## [0.3.2] - 2026-07-23
+
+### Fixed
+
+- Same-grouper container loads are merged for mass-center so results match MS.
+
+## [0.3.0] - 2026-06-02
+
+### Changed
+
+- Public API accepts objects only, returns objects, and throws domain errors instead of mixed string/object I/O.
+
+### Removed
+
+- Collision test artifacts and unused overlap error after `CollisionChecker` removal.
+
+### Added
+
+- npm coverage script with 80% line, function, branch, and statement thresholds.
+
+## [0.2.1] - 2026-06-02
+
+### Removed
+
+- `CollisionChecker` and its call from the weight-by-axis task.
+
+## [0.2.0] - 2026-06-02
+
+### Added
+
+- First published library surface: `calculate_weight_on_axles_physics`, domain exceptions, Zod request validation, and in-process physics plus orchestration.
+
+### Changed
+
+- Package entry points use lowercase `index`.
+- Weight calculation accepted both JSON strings and objects (superseded in 0.3.0).
+
+## [0.1.3] - 2026-06-02
+
+### Changed
+
+- Package is public (`private: false`) for npm publish.
+
+## [0.1.2] - 2026-06-02
+
+### Added
+
+- Bitbucket Pipelines for CI/CD.
+
+## [0.1.0] - 2026-06-02
+
+### Added
+
+- Project scaffolding, transport and vehicle models, deflection and tare, axle-weight services, weight-by-axis orchestration, and golden deflection fixtures.

package/README.md

@@ -55,6 +55,7 @@ try {
 | `UnsupportedVehicleTypeError` | Unknown `tipoVeiculo` |
 | `UnrecognizedSuspensionTypeError` | Invalid vanderleia suspension type |
 | `GrouperNotFoundError` | Merged-container grouper not found |
+| `ItemOverlapError` | Two allocated items occupy the same volume |
 
 Import `ZodError` directly from [`zod`](https://github.com/colinhacks/zod).
 
@@ -72,6 +73,7 @@ Also exported from `@jetta/axle-load-calculator` for `instanceof` checks when us
 ## Dependencies
 
 - [zod](https://github.com/colinhacks/zod) — request validation at the public boundary
+- [`@jetta/number-compare`](https://www.npmjs.com/package/@jetta/number-compare) — float-safe interval tests in cargo collision
 
 ## Scripts
 

package/build/core/orchestration/CollisionChecker.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Rejects an env whose allocated items occupy the same volume.
+ * Face-touching boxes are allowed; comparison uses `@jetta/number-compare`.
+ * @param env - Env vehicle with containers and items.
+ * @throws {ItemOverlapError} When two items share volume on all three axes.
+ */
+export declare function check_cargo_collision(env: Record<string, unknown>): void;
+//# sourceMappingURL=CollisionChecker.d.ts.map

package/build/core/orchestration/CollisionChecker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollisionChecker.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/CollisionChecker.ts"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAWxE"}

package/build/core/orchestration/CollisionChecker.js

@@ -0,0 +1,60 @@
+import { lt } from '@jetta/number-compare';
+import { ItemOverlapError } from './ItemOverlapError.js';
+/**
+ * Rejects an env whose allocated items occupy the same volume.
+ * Face-touching boxes are allowed; comparison uses `@jetta/number-compare`.
+ * @param env - Env vehicle with containers and items.
+ * @throws {ItemOverlapError} When two items share volume on all three axes.
+ */
+export function check_cargo_collision(env) {
+    const containers = env.containers;
+    if (!containers) {
+        return;
+    }
+    for (const container of containers) {
+        check_container_items(container);
+    }
+}
+function check_container_items(container) {
+    const items = container.items;
+    if (!items || items.length <= 1) {
+        return;
+    }
+    throw_if_any_pair_overlaps(items);
+}
+function throw_if_any_pair_overlaps(items) {
+    for (let index = 0; index < items.length - 1; index++) {
+        for (let other = index + 1; other < items.length; other++) {
+            if (items_overlap(items[index], items[other])) {
+                throw new ItemOverlapError();
+            }
+        }
+    }
+}
+function items_overlap(left, right) {
+    const left_box = item_box(left);
+    const right_box = item_box(right);
+    return intervals_overlap(left_box.x, right_box.x)
+        && intervals_overlap(left_box.y, right_box.y)
+        && intervals_overlap(left_box.z, right_box.z);
+}
+/**
+ * Maps CM / Java item JSON onto axis intervals.
+ * Height lives on JSON `z`; length on JSON `y` + `comprimento`.
+ */
+function item_box(item) {
+    const origin_x = Number(item.x ?? 0);
+    const origin_y = Number(item.y ?? 0);
+    const origin_z = Number(item.z ?? 0);
+    const width = Number(item.largura ?? item.width ?? 0);
+    const height = Number(item.altura ?? item.height ?? 0);
+    const length = Number(item.comprimento ?? item.length ?? 0);
+    return {
+        x: { min: origin_x, max: origin_x + width },
+        y: { min: origin_z, max: origin_z + height },
+        z: { min: origin_y, max: origin_y + length }
+    };
+}
+function intervals_overlap(left, right) {
+    return lt(left.min, right.max) && lt(right.min, left.max);
+}

package/build/core/orchestration/ItemOverlapError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Raised when two allocated items occupy the same volume.
+ */
+export declare class ItemOverlapError extends Error {
+    constructor();
+}
+//# sourceMappingURL=ItemOverlapError.d.ts.map

package/build/core/orchestration/ItemOverlapError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ItemOverlapError.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/ItemOverlapError.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;;CAO1C"}

package/build/core/orchestration/ItemOverlapError.js

@@ -0,0 +1,9 @@
+/**
+ * Raised when two allocated items occupy the same volume.
+ */
+export class ItemOverlapError extends Error {
+    constructor() {
+        super('Item overlap error');
+        this.name = 'ItemOverlapError';
+    }
+}

package/build/core/orchestration/JavaMassCenter.d.ts

@@ -2,6 +2,7 @@ import { CenterOfMass } from '../physics/items/CenterOfMass.js';
 /**
  * Computes mass center per grouper using ms-faixas Java Item / MassCenter rules.
  * Longitudinal position uses JSON `y` (maps to Ponto3D.z in Java CubeRepresentation).
+ * Same-grouper containers are merged; empty necks do not shift later beds (MS parity).
  * @param env_vehicle - Single env vehicle object from weight_by_axis payload.
  * @returns Map of grouper id to center of mass.
  */

package/build/core/orchestration/JavaMassCenter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JavaMassCenter.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/JavaMassCenter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAE/D;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC3C,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACrC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAe9B"}
+{"version":3,"file":"JavaMassCenter.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/JavaMassCenter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAE/D;;;;;;GAMG;AACH,wBAAgB,+BAA+B,CAC3C,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACrC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAQ9B"}

package/build/core/orchestration/JavaMassCenter.js

@@ -2,46 +2,99 @@ import { CenterOfMass } from '../physics/items/CenterOfMass.js';
 /**
  * Computes mass center per grouper using ms-faixas Java Item / MassCenter rules.
  * Longitudinal position uses JSON `y` (maps to Ponto3D.z in Java CubeRepresentation).
+ * Same-grouper containers are merged; empty necks do not shift later beds (MS parity).
  * @param env_vehicle - Single env vehicle object from weight_by_axis payload.
  * @returns Map of grouper id to center of mass.
  */
 export function mass_center_by_grouper_from_env(env_vehicle) {
-    const result = {};
     const containers = env_vehicle.containers;
     if (!containers) {
-        return result;
+        return {};
     }
+    return accumulate_grouper_mass_centers(sort_containers_by_sequence(containers));
+}
+/**
+ * @param containers - Containers sorted by sequencia.
+ * @returns Merged center of mass map keyed by grouper.
+ */
+function accumulate_grouper_mass_centers(containers) {
+    const result = {};
+    const longitudinal_offset_by_grouper = {};
     for (const container of containers) {
-        const grouper = Number(container.grouper);
-        // Java AxleWeightConnector overwrites per container in loop order (last wins).
-        result[grouper] = compute_container_mass_center(container);
+        absorb_container_into_grouper(result, longitudinal_offset_by_grouper, container);
     }
     return result;
 }
+/**
+ * @param result - Accumulated grouper centers (mutated).
+ * @param offsets - Longitudinal offset per grouper (mutated).
+ * @param container - Env container to absorb.
+ */
+function absorb_container_into_grouper(result, offsets, container) {
+    const grouper = Number(container.grouper);
+    const sequence_offset = offsets[grouper] ?? 0;
+    const container_center = compute_container_mass_center(container, sequence_offset);
+    result[grouper] = result[grouper]
+        ? merge_mass_centers(result[grouper], container_center)
+        : container_center;
+    if (container_center.mass > 0) {
+        offsets[grouper] = sequence_offset + Number(container.comprimento ?? 0);
+    }
+}
+/**
+ * @param containers - Env containers.
+ * @returns Containers sorted by sequencia ascending.
+ */
+function sort_containers_by_sequence(containers) {
+    return [...containers].sort((left, right) => Number(left.sequencia) - Number(right.sequencia));
+}
+/**
+ * @param left - Existing grouper center of mass.
+ * @param right - Additional container center of mass.
+ * @returns Combined center of mass.
+ */
+function merge_mass_centers(left, right) {
+    const merged = new CenterOfMass();
+    merged.mass = left.mass + right.mass;
+    if (merged.mass === 0) {
+        merged.z = 0;
+        return merged;
+    }
+    merged.z = (left.mass * left.z + right.mass * right.z) / merged.mass;
+    return merged;
+}
 /**
  * @param container - Container object with items array.
+ * @param sequence_offset - Longitudinal offset from prior same-grouper containers.
  * @returns Center of mass for container items.
  */
-function compute_container_mass_center(container) {
+function compute_container_mass_center(container, sequence_offset) {
     const center_of_mass = new CenterOfMass();
     const items = container.items;
     if (!items || items.length === 0) {
-        center_of_mass.mass = 0;
-        center_of_mass.z = 0;
         return center_of_mass;
     }
-    const container_offset = read_container_longitudinal_offset(container);
+    const moments = accumulate_item_moments(items, sequence_offset, container);
+    center_of_mass.mass = moments.mass;
+    center_of_mass.z = moments.mass === 0 ? 0 : moments.accumulated / moments.mass;
+    return center_of_mass;
+}
+/**
+ * @param items - Container items.
+ * @param sequence_offset - Prior loaded length in grouper.
+ * @param container - Container for faixa offset.
+ * @returns Accumulated mass and first moment.
+ */
+function accumulate_item_moments(items, sequence_offset, container) {
+    const container_offset = sequence_offset + read_container_longitudinal_offset(container);
     let accumulated = 0;
     let mass = 0;
     for (const item of items) {
         const weight = read_item_weight(item);
-        const position = container_offset + read_item_longitudinal_position(item);
-        accumulated += weight * position;
+        accumulated += weight * (container_offset + read_item_longitudinal_position(item));
         mass += weight;
     }
-    center_of_mass.mass = mass;
-    center_of_mass.z = mass === 0 ? 0 : accumulated / mass;
-    return center_of_mass;
+    return { accumulated, mass };
 }
 /**
  * @param container - Container JSON.

package/build/core/orchestration/WeightByAxisTask.d.ts

@@ -12,6 +12,7 @@ import type { WeightByAxisSuccessOutput } from './WeightByAxisResponse.js';
  * @throws {import('../physics/transports/MissingContainerError.js').MissingContainerError} When a container lookup fails.
  * @throws {import('../physics/items/UnknownItemIdError.js').UnknownItemIdError} When an item template id is unknown.
  * @throws {import('../physics/models/deflection/DeflectionModelNotImplementedError.js').DeflectionModelNotImplementedError} When no deflection model exists.
+ * @throws {import('./ItemOverlapError.js').ItemOverlapError} When two allocated items occupy the same volume.
  */
 export declare function run_weight_by_axis_task(request_data: WeightByAxisRequestInput): WeightByAxisSuccessOutput;
 //# sourceMappingURL=WeightByAxisTask.d.ts.map

package/build/core/orchestration/WeightByAxisTask.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WeightByAxisTask.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/WeightByAxisTask.ts"],"names":[],"mappings":"AAEA,OAAO,EAEH,KAAK,wBAAwB,EAChC,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAA;AAE1E;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACnC,YAAY,EAAE,wBAAwB,GACvC,yBAAyB,CAY3B"}
+{"version":3,"file":"WeightByAxisTask.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/WeightByAxisTask.ts"],"names":[],"mappings":"AAGA,OAAO,EAEH,KAAK,wBAAwB,EAChC,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAA;AAE1E;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACnC,YAAY,EAAE,wBAAwB,GACvC,yBAAyB,CAa3B"}

package/build/core/orchestration/WeightByAxisTask.js

@@ -1,4 +1,5 @@
 import { calculate_loaded_weights_for_env } from './AxleWeightPhysics.js';
+import { check_cargo_collision } from './CollisionChecker.js';
 import { build_success_output } from './OutputBuilder.js';
 import { parse_weight_by_axis_request_data } from './RequestSchema.js';
 /**
@@ -13,6 +14,7 @@ import { parse_weight_by_axis_request_data } from './RequestSchema.js';
  * @throws {import('../physics/transports/MissingContainerError.js').MissingContainerError} When a container lookup fails.
  * @throws {import('../physics/items/UnknownItemIdError.js').UnknownItemIdError} When an item template id is unknown.
  * @throws {import('../physics/models/deflection/DeflectionModelNotImplementedError.js').DeflectionModelNotImplementedError} When no deflection model exists.
+ * @throws {import('./ItemOverlapError.js').ItemOverlapError} When two allocated items occupy the same volume.
  */
 export function run_weight_by_axis_task(request_data) {
     const request = parse_weight_by_axis_request_data(request_data);
@@ -21,6 +23,7 @@ export function run_weight_by_axis_task(request_data) {
     for (const env of envs) {
         const loaded_weights = calculate_loaded_weights_for_env(env);
         apply_loaded_weights_to_env(env, loaded_weights);
+        check_cargo_collision(env);
         output_envs.push(strip_items_and_bands(env));
     }
     return build_success_output(output_envs);

package/build/index.d.ts

@@ -7,8 +7,9 @@ import { UnsupportedVehicleTypeError } from './core/physics/models/UnsupportedVe
 import { ContainerSequenceNotFoundError } from './core/physics/transports/ContainerSequenceNotFoundError.js';
 import { GrouperNotFoundError } from './core/physics/transports/GrouperNotFoundError.js';
 import { MissingContainerError } from './core/physics/transports/MissingContainerError.js';
+import { ItemOverlapError } from './core/orchestration/ItemOverlapError.js';
 export type { WeightByAxisRequest, WeightByAxisRequestInput, WeightByAxisResponse, WeightByAxisSuccessOutput };
-export { ContainerSequenceNotFoundError, DeflectionModelNotImplementedError, GrouperNotFoundError, MissingContainerError, UnrecognizedSuspensionTypeError, UnknownItemIdError, UnsupportedVehicleTypeError };
+export { ContainerSequenceNotFoundError, DeflectionModelNotImplementedError, GrouperNotFoundError, ItemOverlapError, MissingContainerError, UnrecognizedSuspensionTypeError, UnknownItemIdError, UnsupportedVehicleTypeError };
 /**
  * Calculates loaded cargo weight per axle for each transport in the payload.
  * @param request - Request with `{ envs, config? }`.
@@ -17,6 +18,7 @@ export { ContainerSequenceNotFoundError, DeflectionModelNotImplementedError, Gro
  * @throws {UnsupportedVehicleTypeError} When physics rejects the vehicle type.
  * @throws {UnrecognizedSuspensionTypeError} When vanderleia suspension type is invalid.
  * @throws {GrouperNotFoundError} When a merged-container grouper is missing.
+ * @throws {ItemOverlapError} When two allocated items occupy the same volume.
  * Other exported error classes are for lower-level physics modules, not thrown here.
  */
 export declare function calculate_weight_on_axles_physics(request: WeightByAxisRequestInput): WeightByAxisSuccessOutput;

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACR,mBAAmB,EACnB,wBAAwB,EAC3B,MAAM,uCAAuC,CAAA;AAC9C,OAAO,KAAK,EACR,oBAAoB,EACpB,yBAAyB,EAC5B,MAAM,8CAA8C,CAAA;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAA;AAC/E,OAAO,EAAE,kCAAkC,EAAE,MAAM,wEAAwE,CAAA;AAC3H,OAAO,EAAE,+BAA+B,EAAE,MAAM,0DAA0D,CAAA;AAC1G,OAAO,EAAE,2BAA2B,EAAE,MAAM,sDAAsD,CAAA;AAClG,OAAO,EAAE,8BAA8B,EAAE,MAAM,6DAA6D,CAAA;AAC5G,OAAO,EAAE,oBAAoB,EAAE,MAAM,mDAAmD,CAAA;AACxF,OAAO,EAAE,qBAAqB,EAAE,MAAM,oDAAoD,CAAA;AAE1F,YAAY,EACR,mBAAmB,EACnB,wBAAwB,EACxB,oBAAoB,EACpB,yBAAyB,EAC5B,CAAA;AAED,OAAO,EACH,8BAA8B,EAC9B,kCAAkC,EAClC,oBAAoB,EACpB,qBAAqB,EACrB,+BAA+B,EAC/B,kBAAkB,EAClB,2BAA2B,EAC9B,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAC7C,OAAO,EAAE,wBAAwB,GAClC,yBAAyB,CAG3B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACR,mBAAmB,EACnB,wBAAwB,EAC3B,MAAM,uCAAuC,CAAA;AAC9C,OAAO,KAAK,EACR,oBAAoB,EACpB,yBAAyB,EAC5B,MAAM,8CAA8C,CAAA;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAA;AAC/E,OAAO,EAAE,kCAAkC,EAAE,MAAM,wEAAwE,CAAA;AAC3H,OAAO,EAAE,+BAA+B,EAAE,MAAM,0DAA0D,CAAA;AAC1G,OAAO,EAAE,2BAA2B,EAAE,MAAM,sDAAsD,CAAA;AAClG,OAAO,EAAE,8BAA8B,EAAE,MAAM,6DAA6D,CAAA;AAC5G,OAAO,EAAE,oBAAoB,EAAE,MAAM,mDAAmD,CAAA;AACxF,OAAO,EAAE,qBAAqB,EAAE,MAAM,oDAAoD,CAAA;AAC1F,OAAO,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAA;AAE3E,YAAY,EACR,mBAAmB,EACnB,wBAAwB,EACxB,oBAAoB,EACpB,yBAAyB,EAC5B,CAAA;AAED,OAAO,EACH,8BAA8B,EAC9B,kCAAkC,EAClC,oBAAoB,EACpB,gBAAgB,EAChB,qBAAqB,EACrB,+BAA+B,EAC/B,kBAAkB,EAClB,2BAA2B,EAC9B,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iCAAiC,CAC7C,OAAO,EAAE,wBAAwB,GAClC,yBAAyB,CAG3B"}

package/build/index.js

@@ -6,7 +6,8 @@ import { UnsupportedVehicleTypeError } from './core/physics/models/UnsupportedVe
 import { ContainerSequenceNotFoundError } from './core/physics/transports/ContainerSequenceNotFoundError.js';
 import { GrouperNotFoundError } from './core/physics/transports/GrouperNotFoundError.js';
 import { MissingContainerError } from './core/physics/transports/MissingContainerError.js';
-export { ContainerSequenceNotFoundError, DeflectionModelNotImplementedError, GrouperNotFoundError, MissingContainerError, UnrecognizedSuspensionTypeError, UnknownItemIdError, UnsupportedVehicleTypeError };
+import { ItemOverlapError } from './core/orchestration/ItemOverlapError.js';
+export { ContainerSequenceNotFoundError, DeflectionModelNotImplementedError, GrouperNotFoundError, ItemOverlapError, MissingContainerError, UnrecognizedSuspensionTypeError, UnknownItemIdError, UnsupportedVehicleTypeError };
 /**
  * Calculates loaded cargo weight per axle for each transport in the payload.
  * @param request - Request with `{ envs, config? }`.
@@ -15,6 +16,7 @@ export { ContainerSequenceNotFoundError, DeflectionModelNotImplementedError, Gro
  * @throws {UnsupportedVehicleTypeError} When physics rejects the vehicle type.
  * @throws {UnrecognizedSuspensionTypeError} When vanderleia suspension type is invalid.
  * @throws {GrouperNotFoundError} When a merged-container grouper is missing.
+ * @throws {ItemOverlapError} When two allocated items occupy the same volume.
  * Other exported error classes are for lower-level physics modules, not thrown here.
  */
 export function calculate_weight_on_axles_physics(request) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jetta/axle-load-calculator",
-    "version": "0.3.1",
+    "version": "0.3.3",
     "description": "Merged weight_by_axis physics and orchestration library",
     "main": "build/index.js",
     "types": "build/index.d.ts",
@@ -22,6 +22,7 @@
         "coverage": "c8 --check-coverage --lines 80 --functions 80 --branches 80 --statements 80 --reporter=html --reporter=text npm run test"
     },
     "dependencies": {
+        "@jetta/number-compare": "^3.0.3",
         "zod": "^3.24.0"
     },
     "devDependencies": {