@jetta/axle-load-calculator 0.1.3

package/build/core/contracts/wire_flags.d.ts

@@ -0,0 +1,27 @@
+export declare const WIRE_FLAGS: Readonly<{
+    TRANSPORT_ID: "_id";
+    CONTAINERS: "containers";
+    AXLE_LIST: "eixos";
+    MAIN_PIN_DISTANCE: "distPinoRei";
+    CONTAINER_DISTANCE_AHEAD: "containerDistanceAhead";
+    FIRST_AXLE_DISTANCE: "primeiroEixo";
+    VEHICLE_TYPE: "tipoVeiculo";
+    VEHICLE_VERSION: "tipoVersao";
+    SUSPENSION_TYPE: "tipoSuspensao";
+    SUPPORTED_WEIGHT: "pesoDeCarga";
+    AMOUNT: "qtd";
+    LENGTH: "comprimento";
+    WIDTH: "largura";
+    HEIGHT: "altura";
+    SEQUENCE: "sequencia";
+    GROUPER: "grouper";
+    DISTANCE_FROM_ORIGIN: "distanciaOrigem";
+    MAX_SUPPORTED_WEIGHT: "pesoMaxSuportado";
+    SEQUENCE_CONTAINER: "sequenciaContainer";
+    DNIT_WEIGHT: "pesoDnit";
+    TARE: "tara";
+    CM_SERVICE_CENTER_OF_MASS: "center_of_mass";
+    CM_SERVICE_Z: "z_position";
+    CM_SERVICE_MASS: "mass";
+}>;
+//# sourceMappingURL=wire_flags.d.ts.map

package/build/core/contracts/wire_flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire_flags.d.ts","sourceRoot":"","sources":["../../../src/core/contracts/wire_flags.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;EAyBrB,CAAA"}

package/build/core/contracts/wire_flags.js

@@ -0,0 +1,26 @@
+export const WIRE_FLAGS = Object.freeze({
+    TRANSPORT_ID: '_id',
+    CONTAINERS: 'containers',
+    AXLE_LIST: 'eixos',
+    MAIN_PIN_DISTANCE: 'distPinoRei',
+    CONTAINER_DISTANCE_AHEAD: 'containerDistanceAhead',
+    FIRST_AXLE_DISTANCE: 'primeiroEixo',
+    VEHICLE_TYPE: 'tipoVeiculo',
+    VEHICLE_VERSION: 'tipoVersao',
+    SUSPENSION_TYPE: 'tipoSuspensao',
+    SUPPORTED_WEIGHT: 'pesoDeCarga',
+    AMOUNT: 'qtd',
+    LENGTH: 'comprimento',
+    WIDTH: 'largura',
+    HEIGHT: 'altura',
+    SEQUENCE: 'sequencia',
+    GROUPER: 'grouper',
+    DISTANCE_FROM_ORIGIN: 'distanciaOrigem',
+    MAX_SUPPORTED_WEIGHT: 'pesoMaxSuportado',
+    SEQUENCE_CONTAINER: 'sequenciaContainer',
+    DNIT_WEIGHT: 'pesoDnit',
+    TARE: 'tara',
+    CM_SERVICE_CENTER_OF_MASS: 'center_of_mass',
+    CM_SERVICE_Z: 'z_position',
+    CM_SERVICE_MASS: 'mass'
+});

package/build/core/math/float_tools.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Converts nested float lists to a plain number matrix (NumPy float_list_to_np_array equivalent).
+ * @param float_list - Nested numeric list.
+ * @returns Plain number matrix or vector.
+ */
+export declare function float_list_to_matrix(float_list: number[] | number[][]): number[] | number[][];
+//# sourceMappingURL=float_tools.d.ts.map

package/build/core/math/float_tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"float_tools.d.ts","sourceRoot":"","sources":["../../../src/core/math/float_tools.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,EAAE,CAW7F"}

package/build/core/math/float_tools.js

@@ -0,0 +1,14 @@
+/**
+ * Converts nested float lists to a plain number matrix (NumPy float_list_to_np_array equivalent).
+ * @param float_list - Nested numeric list.
+ * @returns Plain number matrix or vector.
+ */
+export function float_list_to_matrix(float_list) {
+    if (float_list.length === 0) {
+        return [];
+    }
+    if (typeof float_list[0] === 'number') {
+        return float_list;
+    }
+    return float_list.map((row) => row.map((value) => Number(value)));
+}

package/build/core/math/gaussian_elimination.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Solves Ax = b for square matrix A using Gaussian elimination (NumPy-compatible order).
+ * @param matrix - Coefficient matrix row-major n×n.
+ * @param independent - Right-hand side vector length n.
+ * @returns Solution vector length n.
+ */
+export declare function solve_linear_system(matrix: number[][], independent: number[]): number[];
+//# sourceMappingURL=gaussian_elimination.d.ts.map

package/build/core/math/gaussian_elimination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussian_elimination.d.ts","sourceRoot":"","sources":["../../../src/core/math/gaussian_elimination.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CASvF"}

package/build/core/math/gaussian_elimination.js

@@ -0,0 +1,85 @@
+/**
+ * Solves Ax = b for square matrix A using Gaussian elimination (NumPy-compatible order).
+ * @param matrix - Coefficient matrix row-major n×n.
+ * @param independent - Right-hand side vector length n.
+ * @returns Solution vector length n.
+ */
+export function solve_linear_system(matrix, independent) {
+    const size = independent.length;
+    const augmented = matrix.map((row, row_index) => [...row, independent[row_index]]);
+    for (let pivot_column = 0; pivot_column < size; pivot_column++) {
+        forward_eliminate(augmented, pivot_column, size);
+    }
+    return back_substitute(augmented, size);
+}
+/**
+ * @param augmented - Augmented matrix.
+ * @param pivot_column - Current pivot column index.
+ * @param size - System size.
+ */
+function forward_eliminate(augmented, pivot_column, size) {
+    const pivot_row = find_pivot_row(augmented, pivot_column, size);
+    swap_rows(augmented, pivot_row, pivot_column);
+    eliminate_below(augmented, pivot_column, size);
+}
+/**
+ * @param augmented - Augmented matrix.
+ * @param pivot_column - Pivot column.
+ * @param size - System size.
+ * @returns Row index with largest absolute pivot.
+ */
+function find_pivot_row(augmented, pivot_column, size) {
+    let pivot_row = pivot_column;
+    let max_abs = Math.abs(augmented[pivot_column][pivot_column]);
+    for (let row = pivot_column + 1; row < size; row++) {
+        const candidate = Math.abs(augmented[row][pivot_column]);
+        if (candidate > max_abs) {
+            max_abs = candidate;
+            pivot_row = row;
+        }
+    }
+    return pivot_row;
+}
+/**
+ * @param augmented - Augmented matrix.
+ * @param pivot_row - Row to swap to pivot position.
+ * @param pivot_column - Pivot column index.
+ */
+function swap_rows(augmented, pivot_row, pivot_column) {
+    if (pivot_row === pivot_column) {
+        return;
+    }
+    const temp = augmented[pivot_column];
+    augmented[pivot_column] = augmented[pivot_row];
+    augmented[pivot_row] = temp;
+}
+/**
+ * @param augmented - Augmented matrix.
+ * @param pivot_column - Pivot column index.
+ * @param size - System size.
+ */
+function eliminate_below(augmented, pivot_column, size) {
+    const pivot_value = augmented[pivot_column][pivot_column];
+    for (let row = pivot_column + 1; row < size; row++) {
+        const factor = augmented[row][pivot_column] / pivot_value;
+        for (let column = pivot_column; column <= size; column++) {
+            augmented[row][column] -= factor * augmented[pivot_column][column];
+        }
+    }
+}
+/**
+ * @param augmented - Row-echelon augmented matrix.
+ * @param size - System size.
+ * @returns Solution vector.
+ */
+function back_substitute(augmented, size) {
+    const solution = new Array(size).fill(0);
+    for (let row = size - 1; row >= 0; row--) {
+        let sum = augmented[row][size];
+        for (let column = row + 1; column < size; column++) {
+            sum -= augmented[row][column] * solution[column];
+        }
+        solution[row] = sum / augmented[row][row];
+    }
+    return solution;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Calculates loaded weights per vehicle axle (in-process, no HTTP).
+ * @param env_vehicle - Single env from weight_by_axis payload.
+ * @returns Loaded cargo weight per axle index.
+ */
+export declare function calculate_loaded_weights_for_env(env_vehicle: Record<string, unknown>): number[];
+//# sourceMappingURL=axle_weight_physics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"axle_weight_physics.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/axle_weight_physics.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,wBAAgB,gCAAgC,CAC5C,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACrC,MAAM,EAAE,CAMV"}

package/build/core/orchestration/axle_weight_physics.js

@@ -0,0 +1,27 @@
+import { CmAxleWeightService } from '../physics/services/cm_axle_weight_service.js';
+import { build_connector_payload } from './connector_payload_builder.js';
+import { mass_center_by_grouper_from_env } from './java_mass_center.js';
+/**
+ * Calculates loaded weights per vehicle axle (in-process, no HTTP).
+ * @param env_vehicle - Single env from weight_by_axis payload.
+ * @returns Loaded cargo weight per axle index.
+ */
+export function calculate_loaded_weights_for_env(env_vehicle) {
+    const center_of_mass_by_grouper = mass_center_by_grouper_from_env(env_vehicle);
+    const wire_center_of_mass = map_center_of_mass_wire(center_of_mass_by_grouper);
+    const payload = build_connector_payload(env_vehicle, wire_center_of_mass);
+    return new CmAxleWeightService().calculate(payload);
+}
+/**
+ * @param center_of_mass_by_grouper - CM objects keyed by grouper.
+ * @returns Plain mass/z map for wire builder.
+ */
+function map_center_of_mass_wire(center_of_mass_by_grouper) {
+    const wire = {};
+    for (const grouper of Object.keys(center_of_mass_by_grouper)) {
+        const id = Number(grouper);
+        const entry = center_of_mass_by_grouper[id];
+        wire[id] = { mass: entry.mass, z: entry.z };
+    }
+    return wire;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * 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=collision_checker.d.ts.map

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

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

package/build/core/orchestration/collision_checker.js

@@ -0,0 +1,67 @@
+/**
+ * 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);
+    }
+}
+/**
+ * @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 Error('Item overlap error');
+            }
+        }
+    }
+}
+/**
+ * @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/connector_payload_builder.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Builds axle-weight service payload from a prepared env vehicle (Java AxleWeightConnector).
+ * @param env_vehicle - Vehicle object inside envs[].
+ * @param center_of_mass_by_grouper - CM per grouper for CM service flag.
+ * @returns Transport record for CmAxleWeightService.
+ */
+export declare function build_connector_payload(env_vehicle: Record<string, unknown>, center_of_mass_by_grouper: Record<number, {
+    mass: number;
+    z: number;
+}>): Record<string, unknown>;
+//# sourceMappingURL=connector_payload_builder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connector_payload_builder.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/connector_payload_builder.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACnC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACvE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAezB"}

package/build/core/orchestration/connector_payload_builder.js

@@ -0,0 +1,67 @@
+import { WIRE_FLAGS } from '../contracts/wire_flags.js';
+/**
+ * Builds axle-weight service payload from a prepared env vehicle (Java AxleWeightConnector).
+ * @param env_vehicle - Vehicle object inside envs[].
+ * @param center_of_mass_by_grouper - CM per grouper for CM service flag.
+ * @returns Transport record for CmAxleWeightService.
+ */
+export function build_connector_payload(env_vehicle, center_of_mass_by_grouper) {
+    const center_of_mass = map_center_of_mass_wire(center_of_mass_by_grouper);
+    return {
+        [WIRE_FLAGS.CONTAINERS]: build_containers(env_vehicle),
+        [WIRE_FLAGS.AXLE_LIST]: build_axles(env_vehicle),
+        [WIRE_FLAGS.TRANSPORT_ID]: env_vehicle._id,
+        [WIRE_FLAGS.AMOUNT]: 1,
+        [WIRE_FLAGS.SUPPORTED_WEIGHT]: env_vehicle.pesoDeCarga,
+        [WIRE_FLAGS.FIRST_AXLE_DISTANCE]: env_vehicle.primeiroEixo,
+        [WIRE_FLAGS.VEHICLE_TYPE]: env_vehicle.tipoVeiculo,
+        [WIRE_FLAGS.VEHICLE_VERSION]: env_vehicle.tipoVersao,
+        [WIRE_FLAGS.SUSPENSION_TYPE]: env_vehicle.tipoSuspensao,
+        [WIRE_FLAGS.CM_SERVICE_CENTER_OF_MASS]: center_of_mass
+    };
+}
+/**
+ * @param center_of_mass_by_grouper - CM per grouper from Java MassCenter.
+ * @returns Wire map for CM service.
+ */
+function map_center_of_mass_wire(center_of_mass_by_grouper) {
+    const center_of_mass = {};
+    for (const grouper_key of Object.keys(center_of_mass_by_grouper)) {
+        const entry = center_of_mass_by_grouper[Number(grouper_key)];
+        center_of_mass[grouper_key] = {
+            mass: entry.mass,
+            [WIRE_FLAGS.CM_SERVICE_Z]: entry.z
+        };
+    }
+    return center_of_mass;
+}
+/**
+ * @param env_vehicle - Env vehicle JSON.
+ * @returns Container wire list without items.
+ */
+function build_containers(env_vehicle) {
+    const list = env_vehicle.containers;
+    return list.map((container) => ({
+        [WIRE_FLAGS.LENGTH]: container.comprimento,
+        [WIRE_FLAGS.WIDTH]: container.largura,
+        [WIRE_FLAGS.HEIGHT]: container.altura,
+        [WIRE_FLAGS.SEQUENCE]: container.sequencia,
+        [WIRE_FLAGS.MAIN_PIN_DISTANCE]: container.distPinoRei,
+        [WIRE_FLAGS.CONTAINER_DISTANCE_AHEAD]: container.containerDistanceAhead,
+        [WIRE_FLAGS.GROUPER]: container.grouper
+    }));
+}
+/**
+ * @param env_vehicle - Env vehicle JSON.
+ * @returns Axle wire list.
+ */
+function build_axles(env_vehicle) {
+    const list = env_vehicle.eixos;
+    return list.map((axle) => ({
+        [WIRE_FLAGS.DISTANCE_FROM_ORIGIN]: axle.distanciaOrigem,
+        [WIRE_FLAGS.MAX_SUPPORTED_WEIGHT]: axle.pesoMaxSuportado,
+        [WIRE_FLAGS.SEQUENCE_CONTAINER]: axle.sequenciaContainer,
+        [WIRE_FLAGS.DNIT_WEIGHT]: axle.pesoDnit ?? axle.pesoMaxSuportado,
+        [WIRE_FLAGS.TARE]: axle.tara
+    }));
+}

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

@@ -0,0 +1,9 @@
+import { CenterOfMass } from '../physics/items/center_of_mass.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).
+ * @param env_vehicle - Single env vehicle object from weight_by_axis payload.
+ * @returns Map of grouper id to center of mass.
+ */
+export declare function mass_center_by_grouper_from_env(env_vehicle: Record<string, unknown>): Record<number, CenterOfMass>;
+//# sourceMappingURL=java_mass_center.d.ts.map

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

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

package/build/core/orchestration/java_mass_center.js

@@ -0,0 +1,79 @@
+import { CenterOfMass } from '../physics/items/center_of_mass.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).
+ * @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;
+    }
+    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);
+    }
+    return result;
+}
+/**
+ * @param container - Container object with items array.
+ * @returns Center of mass for container items.
+ */
+function compute_container_mass_center(container) {
+    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);
+    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;
+        mass += weight;
+    }
+    center_of_mass.mass = mass;
+    center_of_mass.z = mass === 0 ? 0 : accumulated / mass;
+    return center_of_mass;
+}
+/**
+ * @param container - Container JSON.
+ * @returns Longitudinal offset of container body (first faixa z1 when present).
+ */
+function read_container_longitudinal_offset(container) {
+    const bands = container.faixas;
+    if (!bands || bands.length === 0) {
+        return 0;
+    }
+    return Number(bands[0].z1 ?? 0);
+}
+/**
+ * @param item - Ms-faixas item JSON.
+ * @returns Item weight.
+ */
+function read_item_weight(item) {
+    if (item.peso !== undefined) {
+        return Number(item.peso);
+    }
+    return Number(item.weight ?? 0);
+}
+/**
+ * @param item - Ms-faixas item JSON.
+ * @returns Longitudinal position for equilibrium (Java getZ on pontoDeInicio).
+ */
+function read_item_longitudinal_position(item) {
+    const origin_y = Number(item.y ?? 0);
+    const custom = item.centerOfGravity;
+    if (custom && custom.z !== undefined) {
+        return origin_y + Number(custom.z);
+    }
+    const length = Number(item.comprimento ?? item.length ?? 0);
+    return origin_y + length / 2;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * @param envs - Output env list.
+ * @returns Success JSON string.
+ */
+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;
+//# sourceMappingURL=output_builder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"output_builder.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/output_builder.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"}

package/build/core/orchestration/output_builder.js

@@ -0,0 +1,15 @@
+/**
+ * @param envs - Output env list.
+ * @returns Success JSON string.
+ */
+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 });
+}

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

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+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">>;
+    }, "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">>;
+    }, 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">>;
+    }, 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">>;
+    }, "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">>;
+    }, 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">>;
+    }, 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">>;
+    }, "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">>;
+    }, 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">>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type WeightByAxisRequest = z.infer<typeof request_schema>;
+/**
+ * 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 {};
+//# sourceMappingURL=request_schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"request_schema.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/request_schema.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;AAEhE;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,CAInF"}

package/build/core/orchestration/request_schema.js

@@ -0,0 +1,20 @@
+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()
+}).passthrough();
+const request_schema = z.object({
+    envs: z.array(env_schema).min(1),
+    config: z.record(z.unknown()).optional()
+}).passthrough();
+/**
+ * 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) {
+    const parsed = JSON.parse(json_data);
+    return request_schema.parse(parsed);
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Runs weight-by-axis for ms-faixas JSON input (WeightByAxisTask.run contract).
+ * @param json_data - Raw request JSON string.
+ * @returns Response JSON string.
+ */
+export declare function run_weight_by_axis_task(json_data: string): string;
+//# sourceMappingURL=weight_by_axis_task.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"weight_by_axis_task.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/weight_by_axis_task.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAoBjE"}