@jetta/axle-load-calculator 0.2.0 → 0.3.2

package/README.md

@@ -17,19 +17,57 @@ npm run build
 ## Usage
 
 ```typescript
-import { calculate_weight_on_axles_physics } from '@jetta/axle-load-calculator'
+import {
+    calculate_weight_on_axles_physics,
+    UnsupportedVehicleTypeError,
+    type WeightByAxisRequestInput,
+    type WeightByAxisSuccessOutput
+} from '@jetta/axle-load-calculator'
+import { ZodError } from 'zod'
+
+const request: WeightByAxisRequestInput = { envs: [...] }
+
+try {
+    const response: WeightByAxisSuccessOutput = calculate_weight_on_axles_physics(request)
+    // response.envs with axle weights
+} catch (error) {
+    if (error instanceof ZodError) {
+        // invalid request shape (null, array, missing containers, etc.)
+    } else if (error instanceof UnsupportedVehicleTypeError) {
+        // unsupported tipoVeiculo
+    }
+}
+```
 
-const response_json = calculate_weight_on_axles_physics(input_json_string)
+**Contract:**
 
-const request_object = JSON.parse(input_json_string)
-const response_from_object = calculate_weight_on_axles_physics(request_object)
-```
+- Input: object `{ envs, config? }` with required `containers` on each env (cloned before processing)
+- Success: `{ envs }` with `containers[].pesoEixos` filled; `items` and `faixas` cleared on containers
+- Failure: throws (see **Errors** below)
+
+## Errors
+
+### Thrown by `calculate_weight_on_axles_physics`
+
+| Class | When |
+|-------|------|
+| `ZodError` (from `zod`, not re-exported) | Invalid request shape (`null`, array, missing `containers`, etc.) |
+| `UnsupportedVehicleTypeError` | Unknown `tipoVeiculo` |
+| `UnrecognizedSuspensionTypeError` | Invalid vanderleia suspension type |
+| `GrouperNotFoundError` | Merged-container grouper not found |
+
+Import `ZodError` directly from [`zod`](https://github.com/colinhacks/zod).
+
+### Exported for lower-level use
 
-**Contract:** same as `WeightByAxisTask.run()` in ms-faixas-porcentuais:
+Also exported from `@jetta/axle-load-calculator` for `instanceof` checks when using internal physics modules (not thrown by `calculate_weight_on_axles_physics`):
 
-- Input: JSON string or object `{ envs, config? }` (object input is cloned before processing)
-- Success: `envs[].conteiners[].pesoEixos` filled; `items` and `faixas` cleared on containers
-- Error: `{ msg, apiError }`
+| Class | When |
+|-------|------|
+| `ContainerSequenceNotFoundError` | Container sequence missing on transport |
+| `MissingContainerError` | Container lookup failed |
+| `UnknownItemIdError` | Unknown item template id |
+| `DeflectionModelNotImplementedError` | No deflection model for the vehicle |
 
 ## Dependencies
 

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/OutputBuilder.d.ts

@@ -1,11 +1,7 @@
+import type { WeightByAxisSuccessOutput } from './WeightByAxisResponse.js';
 /**
  * @param envs - Output env list.
- * @returns Success JSON string.
+ * @returns Success response object.
  */
-export declare function build_success_output(envs: Record<string, unknown>[]): string;
-/**
- * @param error - Thrown error.
- * @returns Error JSON string matching ms-faixas format.
- */
-export declare function build_error_output(error: unknown): string;
+export declare function build_success_output(envs: Record<string, unknown>[]): WeightByAxisSuccessOutput;
 //# sourceMappingURL=OutputBuilder.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"OutputBuilder.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/OutputBuilder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,MAAM,CAG5E;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAIzD"}
+{"version":3,"file":"OutputBuilder.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/OutputBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAA;AAE1E;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,yBAAyB,CAG/F"}

package/build/core/orchestration/OutputBuilder.js

@@ -1,15 +1,7 @@
 /**
  * @param envs - Output env list.
- * @returns Success JSON string.
+ * @returns Success response object.
  */
 export function build_success_output(envs) {
-    return JSON.stringify({ envs });
-}
-/**
- * @param error - Thrown error.
- * @returns Error JSON string matching ms-faixas format.
- */
-export function build_error_output(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return JSON.stringify({ msg: message, apiError: message });
+    return { envs };
 }

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

@@ -3,54 +3,45 @@ declare const request_schema: z.ZodObject<{
     envs: z.ZodArray<z.ZodObject<{
         _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
         eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
-        conteiners: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
-        containers: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
         eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
-        conteiners: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
-        containers: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
         eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
-        conteiners: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
-        containers: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
     }, z.ZodTypeAny, "passthrough">>, "many">;
     config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
     envs: z.ZodArray<z.ZodObject<{
         _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
         eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
-        conteiners: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
-        containers: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
         eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
-        conteiners: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
-        containers: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
         eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
-        conteiners: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
-        containers: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
     }, z.ZodTypeAny, "passthrough">>, "many">;
     config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
     envs: z.ZodArray<z.ZodObject<{
         _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
         eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
-        conteiners: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
-        containers: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
         eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
-        conteiners: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
-        containers: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
         eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
-        conteiners: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
-        containers: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
     }, z.ZodTypeAny, "passthrough">>, "many">;
     config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.ZodTypeAny, "passthrough">>;
@@ -61,12 +52,6 @@ export type WeightByAxisRequestInput = z.input<typeof request_schema>;
  * @param data - JSON string or plain `{ envs, config? }` object.
  * @returns Parsed request object.
  */
-export declare function parse_weight_by_axis_request_data(data: string | WeightByAxisRequestInput): WeightByAxisRequest;
-/**
- * Parses and validates weight-by-axis JSON at the library boundary.
- * @param json_data - Raw request string.
- * @returns Parsed request object.
- */
-export declare function parse_weight_by_axis_request(json_data: string): WeightByAxisRequest;
+export declare function parse_weight_by_axis_request_data(data: WeightByAxisRequestInput): WeightByAxisRequest;
 export {};
 //# sourceMappingURL=RequestSchema.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"RequestSchema.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/RequestSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AASvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAGJ,CAAA;AAEhB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAChE,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAErE;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC7C,IAAI,EAAE,MAAM,GAAG,wBAAwB,GACxC,mBAAmB,CAIrB;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,CAGnF"}
+{"version":3,"file":"RequestSchema.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/RequestSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAGJ,CAAA;AAEhB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAChE,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAErE;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC7C,IAAI,EAAE,wBAAwB,GAC/B,mBAAmB,CAGrB"}

package/build/core/orchestration/RequestSchema.js

@@ -2,8 +2,7 @@ import { z } from 'zod';
 const env_schema = z.object({
     _id: z.union([z.string(), z.number()]).optional(),
     eixos: z.array(z.record(z.unknown())).min(1),
-    conteiners: z.array(z.record(z.unknown())).optional(),
-    containers: z.array(z.record(z.unknown())).optional()
+    containers: z.array(z.record(z.unknown())).min(1)
 }).passthrough();
 const request_schema = z.object({
     envs: z.array(env_schema).min(1),
@@ -15,27 +14,5 @@ const request_schema = z.object({
  * @returns Parsed request object.
  */
 export function parse_weight_by_axis_request_data(data) {
-    const raw = normalize_request_raw(data);
-    return request_schema.parse(raw);
-}
-/**
- * Parses and validates weight-by-axis JSON at the library boundary.
- * @param json_data - Raw request string.
- * @returns Parsed request object.
- */
-export function parse_weight_by_axis_request(json_data) {
-    return parse_weight_by_axis_request_data(json_data);
-}
-/**
- * @param data - Request string or object.
- * @returns Raw value for Zod parsing.
- */
-function normalize_request_raw(data) {
-    if (typeof data === 'string') {
-        return JSON.parse(data);
-    }
-    if (data !== null && typeof data === 'object' && !Array.isArray(data)) {
-        return structuredClone(data);
-    }
-    throw new Error('Invalid weight-by-axis request type');
+    return request_schema.parse(data);
 }

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

@@ -0,0 +1,11 @@
+/**
+ * Successful weight-by-axis response payload.
+ */
+export type WeightByAxisSuccessOutput = {
+    envs: Record<string, unknown>[];
+};
+/**
+ * Weight-by-axis task success response.
+ */
+export type WeightByAxisResponse = WeightByAxisSuccessOutput;
+//# sourceMappingURL=WeightByAxisResponse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WeightByAxisResponse.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/WeightByAxisResponse.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACpC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAA;CAClC,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,yBAAyB,CAAA"}

package/build/core/orchestration/WeightByAxisResponse.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,8 +1,17 @@
 import { type WeightByAxisRequestInput } from './RequestSchema.js';
+import type { WeightByAxisSuccessOutput } from './WeightByAxisResponse.js';
 /**
  * Runs weight-by-axis for ms-faixas input (WeightByAxisTask.run contract).
- * @param request_data - JSON string or `{ envs, config? }` object.
- * @returns Response JSON string.
+ * @param request_data - `{ envs, config? }` object.
+ * @returns Response object with envs and axle weights.
+ * @throws {import('zod').ZodError} When request validation fails.
+ * @throws {import('../physics/models/UnsupportedVehicleTypeError.js').UnsupportedVehicleTypeError} When physics rejects the vehicle type.
+ * @throws {import('../physics/models/UnrecognizedSuspensionTypeError.js').UnrecognizedSuspensionTypeError} When vanderleia suspension type is invalid.
+ * @throws {import('../physics/transports/GrouperNotFoundError.js').GrouperNotFoundError} When a merged-container grouper is missing.
+ * @throws {import('../physics/transports/ContainerSequenceNotFoundError.js').ContainerSequenceNotFoundError} When a container sequence is missing.
+ * @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.
  */
-export declare function run_weight_by_axis_task(request_data: string | WeightByAxisRequestInput): string;
+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":"AAGA,OAAO,EAEH,KAAK,wBAAwB,EAChC,MAAM,oBAAoB,CAAA;AAE3B;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,wBAAwB,GAAG,MAAM,CAoB/F"}
+{"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"}

package/build/core/orchestration/WeightByAxisTask.js

@@ -1,28 +1,29 @@
 import { calculate_loaded_weights_for_env } from './AxleWeightPhysics.js';
-import { build_success_output, build_error_output } from './OutputBuilder.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';
 /**
  * Runs weight-by-axis for ms-faixas input (WeightByAxisTask.run contract).
- * @param request_data - JSON string or `{ envs, config? }` object.
- * @returns Response JSON string.
+ * @param request_data - `{ envs, config? }` object.
+ * @returns Response object with envs and axle weights.
+ * @throws {import('zod').ZodError} When request validation fails.
+ * @throws {import('../physics/models/UnsupportedVehicleTypeError.js').UnsupportedVehicleTypeError} When physics rejects the vehicle type.
+ * @throws {import('../physics/models/UnrecognizedSuspensionTypeError.js').UnrecognizedSuspensionTypeError} When vanderleia suspension type is invalid.
+ * @throws {import('../physics/transports/GrouperNotFoundError.js').GrouperNotFoundError} When a merged-container grouper is missing.
+ * @throws {import('../physics/transports/ContainerSequenceNotFoundError.js').ContainerSequenceNotFoundError} When a container sequence is missing.
+ * @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.
  */
 export function run_weight_by_axis_task(request_data) {
-    try {
-        const request = parse_weight_by_axis_request_data(request_data);
-        const envs = request.envs;
-        const output_envs = [];
-        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);
-    }
-    catch (error) {
-        return build_error_output(error);
+    const request = parse_weight_by_axis_request_data(request_data);
+    const envs = request.envs;
+    const output_envs = [];
+    for (const env of envs) {
+        const loaded_weights = calculate_loaded_weights_for_env(env);
+        apply_loaded_weights_to_env(env, loaded_weights);
+        output_envs.push(strip_items_and_bands(env));
     }
+    return build_success_output(output_envs);
 }
 /**
  * Writes loaded axle and container pesoEixos fields on the env vehicle.
@@ -38,10 +39,7 @@ function apply_loaded_weights_to_env(env, loaded_weights) {
         axle.pesoCarregado = cargo;
         axle.pesoCarregadoFinal = tare + cargo;
     }
-    const containers = env.conteiners ?? env.containers;
-    if (!Array.isArray(containers)) {
-        return;
-    }
+    const containers = env.containers;
     apply_to_containers(containers, loaded_weights, axles);
 }
 /**
@@ -96,8 +94,7 @@ function build_peso_eixo_entry(axle, cargo) {
  */
 function strip_items_and_bands(env) {
     const clone = JSON.parse(JSON.stringify(env));
-    const key = clone.conteiners ? 'conteiners' : 'containers';
-    const containers = clone[key];
+    const containers = clone.containers;
     for (const container of containers) {
         container.items = [];
         container.faixas = [];

package/build/index.d.ts

@@ -1,15 +1,23 @@
 import type { WeightByAxisRequest, WeightByAxisRequestInput } from './core/orchestration/RequestSchema.js';
-export type { WeightByAxisRequest, WeightByAxisRequestInput };
+import type { WeightByAxisResponse, WeightByAxisSuccessOutput } from './core/orchestration/WeightByAxisResponse.js';
+import { UnknownItemIdError } from './core/physics/items/UnknownItemIdError.js';
+import { DeflectionModelNotImplementedError } from './core/physics/models/deflection/DeflectionModelNotImplementedError.js';
+import { UnrecognizedSuspensionTypeError } from './core/physics/models/UnrecognizedSuspensionTypeError.js';
+import { UnsupportedVehicleTypeError } from './core/physics/models/UnsupportedVehicleTypeError.js';
+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 type { WeightByAxisRequest, WeightByAxisRequestInput, WeightByAxisResponse, WeightByAxisSuccessOutput };
+export { ContainerSequenceNotFoundError, DeflectionModelNotImplementedError, GrouperNotFoundError, MissingContainerError, UnrecognizedSuspensionTypeError, UnknownItemIdError, UnsupportedVehicleTypeError };
 /**
  * Calculates loaded cargo weight per axle for each transport in the payload.
- * Same contract as WeightByAxisTask.run() in ms-faixas-porcentuais.
- * @param json_data - Raw JSON string with `{ envs, config? }`.
- * @returns JSON string with `envs` and axle weights, or error payload.
+ * @param request - Request with `{ envs, config? }`.
+ * @returns Object with `envs` and axle weights.
+ * @throws {import('zod').ZodError} When request validation fails (import from `zod`).
+ * @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.
+ * Other exported error classes are for lower-level physics modules, not thrown here.
  */
-export declare function calculate_weight_on_axles_physics(json_data: string): string;
-/**
- * @param request - Parsed request with `{ envs, config? }`.
- * @returns JSON string with `envs` and axle weights, or error payload.
- */
-export declare function calculate_weight_on_axles_physics(request: WeightByAxisRequestInput): string;
+export declare function calculate_weight_on_axles_physics(request: WeightByAxisRequestInput): WeightByAxisSuccessOutput;
 //# sourceMappingURL=index.d.ts.map

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;AAE9C,YAAY,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,CAAA;AAE7D;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;AAE5E;;;GAGG;AACH,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,wBAAwB,GAAG,MAAM,CAAA"}
+{"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"}

package/build/index.js

@@ -1,8 +1,22 @@
 import { run_weight_by_axis_task } from './core/orchestration/WeightByAxisTask.js';
+import { UnknownItemIdError } from './core/physics/items/UnknownItemIdError.js';
+import { DeflectionModelNotImplementedError } from './core/physics/models/deflection/DeflectionModelNotImplementedError.js';
+import { UnrecognizedSuspensionTypeError } from './core/physics/models/UnrecognizedSuspensionTypeError.js';
+import { UnsupportedVehicleTypeError } from './core/physics/models/UnsupportedVehicleTypeError.js';
+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 };
 /**
- * @param input - JSON string or `{ envs, config? }` object.
- * @returns JSON string with `envs` and axle weights, or error payload.
+ * Calculates loaded cargo weight per axle for each transport in the payload.
+ * @param request - Request with `{ envs, config? }`.
+ * @returns Object with `envs` and axle weights.
+ * @throws {import('zod').ZodError} When request validation fails (import from `zod`).
+ * @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.
+ * Other exported error classes are for lower-level physics modules, not thrown here.
  */
-export function calculate_weight_on_axles_physics(input) {
-    return run_weight_by_axis_task(input);
+export function calculate_weight_on_axles_physics(request) {
+    return run_weight_by_axis_task(request);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jetta/axle-load-calculator",
-    "version": "0.2.0",
+    "version": "0.3.2",
     "description": "Merged weight_by_axis physics and orchestration library",
     "main": "build/index.js",
     "types": "build/index.d.ts",
@@ -19,7 +19,7 @@
         "publish:alpha": "npm version --tag-version-prefix=alpha-v",
         "publish:stable": "npm version",
         "prerelease:alpha": "npm version prerelease --tag-version-prefix=alpha-v",
-        "coverage": "c8 --reporter=html --reporter=text npm run test"
+        "coverage": "c8 --check-coverage --lines 80 --functions 80 --branches 80 --statements 80 --reporter=html --reporter=text npm run test"
     },
     "dependencies": {
         "zod": "^3.24.0"

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

@@ -1,6 +0,0 @@
-/**
- * Validates allocated items do not overlap (Java CollisionChecker parity for tests).
- * @param env_vehicle - Env vehicle with containers and items.
- */
-export declare function check_cargo_collision(env_vehicle: Record<string, unknown>): void;
-//# sourceMappingURL=CollisionChecker.d.ts.map

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

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

package/build/core/orchestration/CollisionChecker.js

@@ -1,69 +0,0 @@
-import { ItemOverlapError } from './ItemOverlapError.js';
-/**
- * Validates allocated items do not overlap (Java CollisionChecker parity for tests).
- * @param env_vehicle - Env vehicle with containers and items.
- */
-export function check_cargo_collision(env_vehicle) {
-    const key = env_vehicle.conteiners ? 'conteiners' : 'containers';
-    const containers = env_vehicle[key];
-    if (!containers) {
-        return;
-    }
-    for (const container of containers) {
-        check_container_items(container);
-    }
-}
-/**
- * Pairwise overlap check for all items in a container.
- * @param container - Container with items.
- */
-function check_container_items(container) {
-    const items = container.items;
-    if (!items || items.length <= 1) {
-        return;
-    }
-    for (let i = 0; i < items.length - 1; i++) {
-        for (let j = i + 1; j < items.length; j++) {
-            if (items_intersect(items[i], items[j])) {
-                throw new ItemOverlapError();
-            }
-        }
-    }
-}
-/**
- * @param left - First item.
- * @param right - Second item.
- * @returns True when 3D boxes overlap (Java Item.intersect axes swap).
- */
-function items_intersect(left, right) {
-    const left_box = item_intervals(left);
-    const right_box = item_intervals(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);
-}
-/**
- * @param item - Item JSON.
- * @returns Axis intervals using Java coordinate mapping.
- */
-function item_intervals(item) {
-    const x0 = Number(item.x ?? 0);
-    const width = Number(item.largura ?? item.width ?? 0);
-    const json_y = Number(item.y ?? 0);
-    const json_z = Number(item.z ?? 0);
-    const length = Number(item.comprimento ?? item.length ?? 0);
-    const height = Number(item.altura ?? item.height ?? 0);
-    return {
-        x: [x0, x0 + width],
-        y: [json_z, json_z + height],
-        z: [json_y, json_y + length]
-    };
-}
-/**
- * @param left - Interval.
- * @param right - Interval.
- * @returns True when open intervals overlap.
- */
-function intervals_overlap(left, right) {
-    return left[0] < right[1] && right[0] < left[1];
-}

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

@@ -1,9 +0,0 @@
-/**
- * Raised when allocated cargo items overlap in the same container.
- */
-export declare class ItemOverlapError extends Error {
-    /**
-     */
-    constructor();
-}
-//# sourceMappingURL=ItemOverlapError.d.ts.map

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

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

package/build/core/orchestration/ItemOverlapError.js

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