@jetta/cargo-stabilizer 0.1.0-5 → 0.1.0-7

package/CHANGELOG.md

@@ -16,6 +16,7 @@ Format based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 ### Changed
 
 - README documents I/O contract mapping, configuration keys, dependencies, and test/coverage commands.
+- Reorder objective is whole-cargo `transport_score`; loose-item score sum is only a tie-break. Axle, waypoint, and milkrun gates are unchanged.
 
 ### Testing
 

package/README.md

@@ -1,6 +1,6 @@
 # @jetta/cargo-stabilizer
 
-TypeScript library that reorders **loose items only** to improve cargo stability while keeping compound blocks pinned. Implements five config-selectable strategies with organization gates (waypoint order, milkrun wall reservation) and empty-space candidate discovery (JET-2262).
+TypeScript library that reorders **loose items only** to improve **whole-cargo transport stability** while keeping compound blocks pinned. The reorder objective is `transport_score` (loose-item score sum is a tie-break). Implements five config-selectable strategies with organization gates (waypoint order, milkrun wall reservation) and empty-space candidate discovery (JET-2262).
 
 ## Requirements
 
@@ -70,7 +70,7 @@ Exported parsers: `parse_stabilizer_input`, `parse_stabilizer_output`, `safe_par
 | Key | Default | Description |
 |-----|---------|-------------|
 | `cargo_stabilizer.reorder_strategy` | `gravity` | `gravity`, `greedy`, `beam_search`, `simulated_annealing`, `genetic` |
-| `cargo_stabilizer.transport_stability_floor` | `0` | Hard minimum transport stability score |
+| `cargo_stabilizer.transport_stability_floor` | `0` | Hard minimum transport stability score (gate, not the maximize objective) |
 | `cargo_stabilizer.max_iteration` | `10` | Greedy / SA iteration budget |
 | `cargo_stabilizer.preserve_tie_block_organization` | `true` | When true, enforce waypoint Z zones and macro delivery order |
 | `cargo_stabilizer.enforce_milkrun_wall_reservation` | `false` | When true, reserve rear compound-wall Z bands using profile key below |

package/build/core/adapters/axle_adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"axle_adapter.d.ts","sourceRoot":"","sources":["../../../src/core/adapters/axle_adapter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oDAAoD,CAAA;AAEvF;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAC9B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAClB,OAAO,CAGT;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAUjF"}
+{"version":3,"file":"axle_adapter.d.ts","sourceRoot":"","sources":["../../../src/core/adapters/axle_adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oDAAoD,CAAA;AAEvF;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAC9B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAClB,OAAO,CAGT;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAejF"}

package/build/core/adapters/axle_adapter.js

@@ -1,5 +1,4 @@
-import { calculate_weight_on_axles_physics } from '@jetta/axle-load-calculator';
-import { map_contract_to_wire_output } from '../validation/contract/cargo_movement_wire_mapper.js';
+import { run_axle_calculator } from './run_axle_calculator.js';
 /**
  * @param final_kg - Loaded weight including tare.
  * @param max_kg - Axle supported max.
@@ -19,16 +18,13 @@ export function is_axle_load_valid(env, folga_pct) {
     if (!env.axles || env.axles.length === 0) {
         return true;
     }
-    const output_env = parse_axle_calculator_output(env);
-    const containers = (output_env.containers ?? []);
+    const result = run_axle_calculator(env);
+    if (!result.calculated) {
+        return false;
+    }
+    const containers = (result.env.containers ?? []);
     return containers.every(container => container_axles_within_folga(container, folga_pct));
 }
-function parse_axle_calculator_output(env) {
-    const wire_cargo_state = map_contract_to_wire_output({ envs: [env] });
-    const request = { envs: wire_cargo_state.envs };
-    const output = JSON.parse(calculate_weight_on_axles_physics(JSON.stringify(request)));
-    return output.envs[0];
-}
 function container_axles_within_folga(container, folga_pct) {
     const axles = (container.pesoEixos ?? []);
     return axles.every(axle => {

package/build/core/adapters/build_axle_request.d.ts

@@ -0,0 +1,15 @@
+import type { StabilizerEnv } from '../validation/contract/stabilizer_domain_schema.js';
+/**
+ * Builds the axle-load-calculator request for a single env.
+ *
+ * The calculator physics reads `peso`, `largura`, `altura` and `comprimento`
+ * (ItemTemplates and JavaMassCenter), none of which exist in the
+ * cargo-movement wire item shape (`wg`, `w`, `h`, `d`). Without these aliases
+ * every item weighs zero and the axle gate can never reject a layout, so the
+ * contract values are stamped onto each request item here. Longitudinal extent
+ * is `depth`, matching the wire `y` axis the calculator uses for equilibrium.
+ * @param env - Stabilizer env with containers and axles.
+ * @returns Calculator request payload.
+ */
+export declare function build_axle_request(env: StabilizerEnv): Record<string, unknown>;
+//# sourceMappingURL=build_axle_request.d.ts.map

package/build/core/adapters/build_axle_request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_axle_request.d.ts","sourceRoot":"","sources":["../../../src/core/adapters/build_axle_request.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAER,aAAa,EAEhB,MAAM,oDAAoD,CAAA;AAE3D;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAS9E"}

package/build/core/adapters/build_axle_request.js

@@ -0,0 +1,39 @@
+import { map_contract_to_wire_output } from '../validation/contract/cargo_movement_wire_mapper.js';
+/**
+ * Builds the axle-load-calculator request for a single env.
+ *
+ * The calculator physics reads `peso`, `largura`, `altura` and `comprimento`
+ * (ItemTemplates and JavaMassCenter), none of which exist in the
+ * cargo-movement wire item shape (`wg`, `w`, `h`, `d`). Without these aliases
+ * every item weighs zero and the axle gate can never reject a layout, so the
+ * contract values are stamped onto each request item here. Longitudinal extent
+ * is `depth`, matching the wire `y` axis the calculator uses for equilibrium.
+ * @param env - Stabilizer env with containers and axles.
+ * @returns Calculator request payload.
+ */
+export function build_axle_request(env) {
+    const wire = map_contract_to_wire_output({ envs: [env] });
+    const wire_env = wire.envs[0];
+    const wire_containers = (wire_env.containers ?? []);
+    wire_env.containers = wire_containers.map((wire_container, index) => stamp_container_physics_aliases(wire_container, env.containers[index]));
+    return { envs: wire.envs };
+}
+function stamp_container_physics_aliases(wire_container, container) {
+    const wire_items = (wire_container.items ?? []);
+    return {
+        ...wire_container,
+        items: wire_items.map((wire_item, index) => stamp_item_physics_aliases(wire_item, container?.items[index]))
+    };
+}
+function stamp_item_physics_aliases(wire_item, item) {
+    if (item === undefined) {
+        return wire_item;
+    }
+    return {
+        ...wire_item,
+        peso: item.weight ?? 0,
+        largura: item.width,
+        altura: item.height,
+        comprimento: item.depth
+    };
+}

package/build/core/adapters/run_axle_calculator.d.ts

@@ -0,0 +1,16 @@
+import type { StabilizerEnv } from '../validation/contract/stabilizer_domain_schema.js';
+export type AxleCalculatorResult = {
+    calculated: true;
+    env: Record<string, unknown>;
+} | {
+    calculated: false;
+    reason: string;
+};
+/**
+ * Runs the axle-load calculator for a candidate env layout.
+ * @param env - Stabilizer env with containers and axles.
+ * @returns Calculated env, or the reason the layout was rejected.
+ * @throws {AxleCalculationError} When the vehicle or item configuration cannot be calculated.
+ */
+export declare function run_axle_calculator(env: StabilizerEnv): AxleCalculatorResult;
+//# sourceMappingURL=run_axle_calculator.d.ts.map

package/build/core/adapters/run_axle_calculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run_axle_calculator.d.ts","sourceRoot":"","sources":["../../../src/core/adapters/run_axle_calculator.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oDAAoD,CAAA;AASvF,MAAM,MAAM,oBAAoB,GAC1B;IAAE,UAAU,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAClD;IAAE,UAAU,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3C;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,aAAa,GAAG,oBAAoB,CAoB5E"}

package/build/core/adapters/run_axle_calculator.js

@@ -0,0 +1,32 @@
+import { calculate_weight_on_axles_physics } from '@jetta/axle-load-calculator';
+import { build_axle_request } from './build_axle_request.js';
+import { AxleCalculationError } from '../exceptions/AxleCalculationError.js';
+import { stabilizer_logger } from '../logging/stabilizer_logger.js';
+/**
+ * Calculator failures caused by the candidate layout rather than by the vehicle
+ * or item configuration. These reject the candidate layout; every other failure
+ * means the env can never be evaluated and aborts the run.
+ */
+const LAYOUT_REJECTION_MESSAGES = Object.freeze(['Item overlap error']);
+/**
+ * Runs the axle-load calculator for a candidate env layout.
+ * @param env - Stabilizer env with containers and axles.
+ * @returns Calculated env, or the reason the layout was rejected.
+ * @throws {AxleCalculationError} When the vehicle or item configuration cannot be calculated.
+ */
+export function run_axle_calculator(env) {
+    const request = build_axle_request(env);
+    const output = JSON.parse(calculate_weight_on_axles_physics(JSON.stringify(request)));
+    if (Array.isArray(output.envs) && output.envs.length > 0) {
+        return { calculated: true, env: output.envs[0] };
+    }
+    const reason = output.apiError ?? 'calculator returned no envs';
+    if (!is_layout_rejection(reason)) {
+        throw new AxleCalculationError(reason);
+    }
+    stabilizer_logger.debug('axle gate rejected candidate layout: ' + reason);
+    return { calculated: false, reason };
+}
+function is_layout_rejection(reason) {
+    return LAYOUT_REJECTION_MESSAGES.some(message => reason.includes(message));
+}

package/build/core/evaluation/compute_reorder_objective.d.ts

@@ -0,0 +1,13 @@
+import { type StabilityEvaluation } from '../adapters/stability_adapter.js';
+import type { StabilizerContainer } from '../validation/contract/stabilizer_domain_schema.js';
+import type { LooseItemRef } from '../filters/loose_item_filter.js';
+export declare const LOOSE_SUM_TIE_BREAK_SCALE = 0.000001;
+/**
+ * Computes the reorder objective: maximize transport stability, then loose-item sum.
+ * @param stability - Transport stability evaluation.
+ * @param containers - Container layout used for loose-item index lookup.
+ * @param loose_items - Loose items included in the tie-break term.
+ * @returns Scalar objective; higher is better.
+ */
+export declare function compute_reorder_objective(stability: StabilityEvaluation, containers: StabilizerContainer[], loose_items: LooseItemRef[]): number;
+//# sourceMappingURL=compute_reorder_objective.d.ts.map

package/build/core/evaluation/compute_reorder_objective.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute_reorder_objective.d.ts","sourceRoot":"","sources":["../../../src/core/evaluation/compute_reorder_objective.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,KAAK,mBAAmB,EAC3B,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oDAAoD,CAAA;AAC7F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAA;AAEnE,eAAO,MAAM,yBAAyB,WAAO,CAAA;AAE7C;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACrC,SAAS,EAAE,mBAAmB,EAC9B,UAAU,EAAE,mBAAmB,EAAE,EACjC,WAAW,EAAE,YAAY,EAAE,GAC5B,MAAM,CAIR"}

package/build/core/evaluation/compute_reorder_objective.js

@@ -0,0 +1,13 @@
+import { sum_loose_item_scores } from '../adapters/stability_adapter.js';
+export const LOOSE_SUM_TIE_BREAK_SCALE = 1e-6;
+/**
+ * Computes the reorder objective: maximize transport stability, then loose-item sum.
+ * @param stability - Transport stability evaluation.
+ * @param containers - Container layout used for loose-item index lookup.
+ * @param loose_items - Loose items included in the tie-break term.
+ * @returns Scalar objective; higher is better.
+ */
+export function compute_reorder_objective(stability, containers, loose_items) {
+    const loose_sum = sum_loose_item_scores(stability, containers, loose_items);
+    return stability.transport_score + loose_sum * LOOSE_SUM_TIE_BREAK_SCALE;
+}

package/build/core/evaluation/state_evaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state_evaluator.d.ts","sourceRoot":"","sources":["../../../src/core/evaluation/state_evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oDAAoD,CAAA;AAC7F,OAAO,EAGH,KAAK,mBAAmB,EAC3B,MAAM,kCAAkC,CAAA;AAKzC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAA;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAA;AAE9E,MAAM,WAAW,gBAAgB;IAE7B,SAAS,EAAE,mBAAmB,CAAA;IAC9B,SAAS,EAAE,MAAM,CAAA;IACjB,qBAAqB,EAAE,OAAO,CAAA;IAC9B,UAAU,EAAE,OAAO,CAAA;IACnB,cAAc,EAAE,OAAO,CAAA;IACvB,aAAa,EAAE,OAAO,CAAA;IACtB,cAAc,EAAE,OAAO,CAAA;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC1B,UAAU,EAAE,mBAAmB,EAAE,EACjC,OAAO,EAAE,sBAAsB,GAChC,gBAAgB,CAUlB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACjC,KAAK,EAAE,mBAAmB,EAAE,EAC5B,OAAO,EAAE,sBAAsB,GAChC,gBAAgB,CAGlB;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,cAAc,GAAG,sBAAsB,CAU/F;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,mBAAmB,EAAE,GAAG,mBAAmB,EAAE,CAGvF;AAwBD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACvC,UAAU,EAAE,mBAAmB,EAAE,EACjC,OAAO,EAAE,sBAAsB,GAChC;IAAE,cAAc,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAA;CAAE,CAMrD"}
+{"version":3,"file":"state_evaluator.d.ts","sourceRoot":"","sources":["../../../src/core/evaluation/state_evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oDAAoD,CAAA;AAC7F,OAAO,EAEH,KAAK,mBAAmB,EAC3B,MAAM,kCAAkC,CAAA;AAMzC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAA;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAA;AAE9E,MAAM,WAAW,gBAAgB;IAE7B,SAAS,EAAE,mBAAmB,CAAA;IAC9B,SAAS,EAAE,MAAM,CAAA;IACjB,qBAAqB,EAAE,OAAO,CAAA;IAC9B,UAAU,EAAE,OAAO,CAAA;IACnB,cAAc,EAAE,OAAO,CAAA;IACvB,aAAa,EAAE,OAAO,CAAA;IACtB,cAAc,EAAE,OAAO,CAAA;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC1B,UAAU,EAAE,mBAAmB,EAAE,EACjC,OAAO,EAAE,sBAAsB,GAChC,gBAAgB,CAUlB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACjC,KAAK,EAAE,mBAAmB,EAAE,EAC5B,OAAO,EAAE,sBAAsB,GAChC,gBAAgB,CAGlB;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,cAAc,GAAG,sBAAsB,CAU/F;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,mBAAmB,EAAE,GAAG,mBAAmB,EAAE,CAGvF;AAwBD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACvC,UAAU,EAAE,mBAAmB,EAAE,EACjC,OAAO,EAAE,sBAAsB,GAChC;IAAE,cAAc,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAA;CAAE,CAMrD"}

package/build/core/evaluation/state_evaluator.js

@@ -1,4 +1,5 @@
-import { try_evaluate_transport_stability, sum_loose_item_scores } from '../adapters/stability_adapter.js';
+import { try_evaluate_transport_stability } from '../adapters/stability_adapter.js';
+import { compute_reorder_objective } from './compute_reorder_objective.js';
 import { is_axle_load_valid } from '../adapters/axle_adapter.js';
 import { preserves_waypoint_order } from '../waypoint/preserves_waypoint_order.js';
 import { is_layout_milkrun_valid } from '../waypoint/milkrun_wall_reservation.js';
@@ -50,7 +51,7 @@ export function clone_baseline(containers) {
     return clone_containers(containers);
 }
 function evaluate_gates(containers, context, stability) {
-    const objective = sum_loose_item_scores(stability, containers, context.loose_items);
+    const objective = compute_reorder_objective(stability, containers, context.loose_items);
     const transport_floor_valid = stability.transport_score >= context.config.transport_stability_floor;
     const axle_valid = is_axle_load_valid({ ...context.env, containers }, context.config.axle_load_margin_percent);
     const waypoint_valid = is_waypoint_order_valid(containers, context);

package/build/core/exceptions/AxleCalculationError.d.ts

@@ -0,0 +1,4 @@
+export declare class AxleCalculationError extends Error {
+    constructor(reason: string);
+}
+//# sourceMappingURL=AxleCalculationError.d.ts.map

package/build/core/exceptions/AxleCalculationError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AxleCalculationError.d.ts","sourceRoot":"","sources":["../../../src/core/exceptions/AxleCalculationError.ts"],"names":[],"mappings":"AAAA,qBAAa,oBAAqB,SAAQ,KAAK;gBAE/B,MAAM,EAAE,MAAM;CAK7B"}

package/build/core/exceptions/AxleCalculationError.js

@@ -0,0 +1,6 @@
+export class AxleCalculationError extends Error {
+    constructor(reason) {
+        super('Axle load calculation failed: ' + reason);
+        this.name = 'AxleCalculationError';
+    }
+}

package/build/core/validation/contract/cargo_movement_wire_field_map.d.ts

@@ -4,8 +4,24 @@ export declare const ITEM_WIRE_TO_CONTRACT: {
     readonly w: "width";
     readonly h: "height";
     readonly d: "depth";
-    readonly peso: "weight";
 };
+/**
+ * Cargo-movement wire keys feeding each contract item field, in precedence
+ * order. Items are read-only for the stabilizer apart from their position, so
+ * these keys are read rather than renamed: the original wire record is
+ * retained in `attributes` and is what gets emitted back.
+ */
+export declare const ITEM_CONTRACT_WIRE_KEYS: Readonly<{
+    item_id: string[];
+    group_id: string[];
+    waypoint_id: string[];
+    width: string[];
+    height: string[];
+    depth: string[];
+    weight: string[];
+}>;
+/** Item fields the stabilizer mutates, and therefore must emit itself. */
+export declare const ITEM_POSITION_KEYS: string[];
 export declare const CONTAINER_WIRE_TO_CONTRACT: {
     readonly sequencia: "sequence";
     readonly largura: "width";

package/build/core/validation/contract/cargo_movement_wire_field_map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cargo_movement_wire_field_map.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/cargo_movement_wire_field_map.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB;;;;;;;CAOxB,CAAA;AAEV,eAAO,MAAM,0BAA0B;;;;;CAK7B,CAAA;AAEV,eAAO,MAAM,oBAAoB;;CAEvB,CAAA;AAEV,eAAO,MAAM,qBAAqB,wBAAoC,CAAA;AACtE,eAAO,MAAM,0BAA0B,wBAAyC,CAAA;AAChF,eAAO,MAAM,oBAAoB,wBAAmC,CAAA"}
+{"version":3,"file":"cargo_movement_wire_field_map.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/cargo_movement_wire_field_map.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB;;;;;;CAMxB,CAAA;AAEV;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;EAQlC,CAAA;AAEF,0EAA0E;AAC1E,eAAO,MAAM,kBAAkB,UAAkB,CAAA;AAEjD,eAAO,MAAM,0BAA0B;;;;;CAK7B,CAAA;AAEV,eAAO,MAAM,oBAAoB;;CAEvB,CAAA;AAEV,eAAO,MAAM,qBAAqB,wBAAoC,CAAA;AACtE,eAAO,MAAM,0BAA0B,wBAAyC,CAAA;AAChF,eAAO,MAAM,oBAAoB,wBAAmC,CAAA"}

package/build/core/validation/contract/cargo_movement_wire_field_map.js

@@ -3,9 +3,25 @@ export const ITEM_WIRE_TO_CONTRACT = {
     groupId: 'group_id',
     w: 'width',
     h: 'height',
-    d: 'depth',
-    peso: 'weight'
+    d: 'depth'
 };
+/**
+ * Cargo-movement wire keys feeding each contract item field, in precedence
+ * order. Items are read-only for the stabilizer apart from their position, so
+ * these keys are read rather than renamed: the original wire record is
+ * retained in `attributes` and is what gets emitted back.
+ */
+export const ITEM_CONTRACT_WIRE_KEYS = Object.freeze({
+    item_id: ['item_id', '_id'],
+    group_id: ['groupId', 'group_id'],
+    waypoint_id: ['waypoint_id'],
+    width: ['w', 'width'],
+    height: ['h', 'height'],
+    depth: ['d', 'depth'],
+    weight: ['wg', 'peso', 'weight']
+});
+/** Item fields the stabilizer mutates, and therefore must emit itself. */
+export const ITEM_POSITION_KEYS = ['x', 'y', 'z'];
 export const CONTAINER_WIRE_TO_CONTRACT = {
     sequencia: 'sequence',
     largura: 'width',

package/build/core/validation/contract/map_contract_to_wire_shape.js

@@ -1,5 +1,5 @@
 import { CONTRACT_TO_CONTAINER_WIRE, CONTRACT_TO_ITEM_WIRE } from './cargo_movement_wire_field_map.js';
-import { rename_keys } from './wire_mapper_record_utils.js';
+import { omit_keys, rename_keys } from './wire_mapper_record_utils.js';
 export function map_cargo_state_to_wire(cargo_state) {
     const wire = {
         envs: cargo_state.envs.map(map_env_to_wire)
@@ -10,19 +10,33 @@ export function map_cargo_state_to_wire(cargo_state) {
     return wire;
 }
 function map_env_to_wire(env) {
-    const wire = {
-        containers: env.containers.map(map_container_to_wire)
-    };
+    const wire = { ...(env.vehicle ?? {}) };
+    wire.containers = env.containers.map(map_container_to_wire);
     if (env.axles !== undefined) {
         wire.eixos = env.axles;
     }
     return wire;
 }
 function map_container_to_wire(container) {
-    const wire = rename_keys(container, CONTRACT_TO_CONTAINER_WIRE);
+    const modelled = omit_keys(container, ['attributes', 'items']);
+    const wire = { ...(container.attributes ?? {}) };
+    Object.assign(wire, rename_keys(modelled, CONTRACT_TO_CONTAINER_WIRE));
     wire.items = container.items.map(map_item_to_wire);
     return wire;
 }
+/**
+ * Emits a contract item back to the wire.
+ *
+ * Position is the only field the stabilizer mutates, so an item that came from
+ * the cargo-movement wire is emitted as its retained original record with the
+ * new position stamped on. Items parsed straight from the English contract have
+ * no retained record and fall back to renaming the modelled fields.
+ * @param item - Contract item.
+ * @returns Wire item.
+ */
 function map_item_to_wire(item) {
-    return rename_keys(item, CONTRACT_TO_ITEM_WIRE);
+    if (item.attributes === undefined) {
+        return rename_keys(omit_keys(item, ['attributes']), CONTRACT_TO_ITEM_WIRE);
+    }
+    return { ...item.attributes, x: item.x, y: item.y, z: item.z };
 }

package/build/core/validation/contract/map_wire_input_to_contract_shape.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"map_wire_input_to_contract_shape.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/map_wire_input_to_contract_shape.ts"],"names":[],"mappings":"AAOA,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAiBnE"}
+{"version":3,"file":"map_wire_input_to_contract_shape.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/map_wire_input_to_contract_shape.ts"],"names":[],"mappings":"AAUA,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAiBnE"}

package/build/core/validation/contract/map_wire_input_to_contract_shape.js

@@ -1,5 +1,8 @@
-import { CONTAINER_WIRE_TO_CONTRACT, ENV_WIRE_TO_CONTRACT, ITEM_WIRE_TO_CONTRACT } from './cargo_movement_wire_field_map.js';
-import { is_record, pick_keys, rename_keys } from './wire_mapper_record_utils.js';
+import { CONTAINER_WIRE_TO_CONTRACT, ENV_WIRE_TO_CONTRACT } from './cargo_movement_wire_field_map.js';
+import { map_wire_item_to_contract } from './map_wire_item_to_contract.js';
+import { is_record, omit_keys, pick_keys, rename_keys } from './wire_mapper_record_utils.js';
+const CONTAINER_CONTRACT_KEYS = ['sequence', 'width', 'height', 'length'];
+const ENV_CONTRACT_KEYS = ['axles'];
 export function map_cargo_state_to_contract(value) {
     if (!is_record(value)) {
         return value;
@@ -29,34 +32,29 @@ function map_container_to_contract(value) {
     }
     const mapped = rename_keys(value, CONTAINER_WIRE_TO_CONTRACT);
     if (Array.isArray(value.items)) {
-        mapped.items = value.items.map(map_item_to_contract);
+        mapped.items = value.items.map(map_wire_item_to_contract);
     }
     return pick_container_contract_keys(mapped);
 }
-function map_item_to_contract(value) {
-    if (!is_record(value)) {
-        return value;
-    }
-    const mapped = rename_keys(value, ITEM_WIRE_TO_CONTRACT);
-    return pick_item_contract_keys(mapped);
-}
-function pick_item_contract_keys(source) {
-    return pick_keys(source, [
-        'item_id', 'group_id', 'waypoint_id', 'x', 'y', 'z',
-        'width', 'height', 'depth', 'weight'
-    ]);
-}
 function pick_container_contract_keys(source) {
-    const picked = pick_keys(source, ['sequence', 'width', 'height', 'length']);
+    const picked = pick_keys(source, CONTAINER_CONTRACT_KEYS);
     if (Array.isArray(source.items)) {
         picked.items = source.items;
     }
+    const attributes = omit_keys(source, [...CONTAINER_CONTRACT_KEYS, 'items']);
+    if (Object.keys(attributes).length > 0) {
+        picked.attributes = attributes;
+    }
     return picked;
 }
 function pick_env_contract_keys(source) {
-    const picked = pick_keys(source, ['axles']);
+    const picked = pick_keys(source, ENV_CONTRACT_KEYS);
     if (Array.isArray(source.containers)) {
         picked.containers = source.containers;
     }
+    const vehicle = omit_keys(source, [...ENV_CONTRACT_KEYS, 'containers']);
+    if (Object.keys(vehicle).length > 0) {
+        picked.vehicle = vehicle;
+    }
     return picked;
 }

package/build/core/validation/contract/map_wire_item_to_contract.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Maps a cargo-movement wire item to the stabilizer contract shape.
+ *
+ * Contract fields are read from the wire rather than renamed, because a CM item
+ * can carry both spellings of the same field (`_id` and `item_id`) and renaming
+ * makes one silently overwrite the other. The whole original record is kept in
+ * `attributes` so every allocation field survives the round-trip.
+ * @param value - Raw wire item.
+ * @returns Contract item, or the input unchanged when it is not a record.
+ */
+export declare function map_wire_item_to_contract(value: unknown): unknown;
+//# sourceMappingURL=map_wire_item_to_contract.d.ts.map

package/build/core/validation/contract/map_wire_item_to_contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map_wire_item_to_contract.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/map_wire_item_to_contract.ts"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAcjE"}

package/build/core/validation/contract/map_wire_item_to_contract.js

@@ -0,0 +1,49 @@
+import { ITEM_CONTRACT_WIRE_KEYS, ITEM_POSITION_KEYS } from './cargo_movement_wire_field_map.js';
+import { is_record, omit_keys, read_first_present } from './wire_mapper_record_utils.js';
+/**
+ * Maps a cargo-movement wire item to the stabilizer contract shape.
+ *
+ * Contract fields are read from the wire rather than renamed, because a CM item
+ * can carry both spellings of the same field (`_id` and `item_id`) and renaming
+ * makes one silently overwrite the other. The whole original record is kept in
+ * `attributes` so every allocation field survives the round-trip.
+ * @param value - Raw wire item.
+ * @returns Contract item, or the input unchanged when it is not a record.
+ */
+export function map_wire_item_to_contract(value) {
+    if (!is_record(value)) {
+        return value;
+    }
+    const contract = read_contract_item_fields(value);
+    const attributes = omit_keys(value, ITEM_POSITION_KEYS);
+    if (Object.keys(attributes).length > 0) {
+        contract.attributes = attributes;
+    }
+    return contract;
+}
+function read_contract_item_fields(source) {
+    const contract = {
+        x: source.x,
+        y: source.y,
+        z: source.z
+    };
+    for (const [contract_key, wire_keys] of Object.entries(ITEM_CONTRACT_WIRE_KEYS)) {
+        const value = read_first_present(source, wire_keys);
+        if (value !== undefined) {
+            contract[contract_key] = normalize_contract_field(contract_key, value);
+        }
+    }
+    return contract;
+}
+/**
+ * Coerces blocks-wall numeric group ids to the string contract type.
+ * @param contract_key - English contract field name.
+ * @param value - Wire value.
+ * @returns String group id when a finite number was provided; otherwise the value.
+ */
+function normalize_contract_field(contract_key, value) {
+    if (contract_key === 'group_id' && typeof value === 'number' && Number.isFinite(value)) {
+        return String(value);
+    }
+    return value;
+}

package/build/core/validation/contract/parse_stabilizer_input.d.ts

@@ -23,10 +23,13 @@ export declare function safe_parse_stabilizer_input(input_data: unknown): import
                     group_id?: string | null | undefined;
                     waypoint_id?: string | undefined;
                     weight?: number | undefined;
+                    attributes?: Record<string, unknown> | undefined;
                 }[];
                 sequence?: number | undefined;
+                attributes?: Record<string, unknown> | undefined;
             }[];
             axles?: Record<string, unknown>[] | undefined;
+            vehicle?: Record<string, unknown> | undefined;
         }[];
         config?: Record<string, unknown> | undefined;
     };

package/build/core/validation/contract/parse_stabilizer_input.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse_stabilizer_input.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/parse_stabilizer_input.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAA2B,KAAK,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAE5F;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAI9D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,CAS3E;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAA"}
+{"version":3,"file":"parse_stabilizer_input.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/parse_stabilizer_input.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAA2B,KAAK,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAE5F;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAI9D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,CAS3E;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAA"}

package/build/core/validation/contract/parse_stabilizer_output.d.ts

@@ -24,10 +24,13 @@ export declare function safe_parse_stabilizer_output(output_data: unknown): impo
                     group_id?: string | null | undefined;
                     waypoint_id?: string | undefined;
                     weight?: number | undefined;
+                    attributes?: Record<string, unknown> | undefined;
                 }[];
                 sequence?: number | undefined;
+                attributes?: Record<string, unknown> | undefined;
             }[];
             axles?: Record<string, unknown>[] | undefined;
+            vehicle?: Record<string, unknown> | undefined;
         }[];
         config?: Record<string, unknown> | undefined;
     };

package/build/core/validation/contract/parse_stabilizer_output.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse_stabilizer_output.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/parse_stabilizer_output.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAEH,KAAK,kBAAkB,EAC1B,MAAM,+BAA+B,CAAA;AAEtC;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,WAAW,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGhE;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,OAAO,GAAG,kBAAkB,CAShF;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAA"}
+{"version":3,"file":"parse_stabilizer_output.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/parse_stabilizer_output.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAEH,KAAK,kBAAkB,EAC1B,MAAM,+BAA+B,CAAA;AAEtC;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,WAAW,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGhE;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,OAAO,GAAG,kBAAkB,CAShF;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAA"}

package/build/core/validation/contract/stabilizer_domain_schema.d.ts

@@ -10,6 +10,7 @@ export declare const stabilizer_item_schema: z.ZodObject<{
     height: z.ZodNumber;
     depth: z.ZodNumber;
     weight: z.ZodOptional<z.ZodNumber>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
 export declare const stabilizer_container_schema: z.ZodObject<{
     sequence: z.ZodOptional<z.ZodNumber>;
@@ -27,7 +28,9 @@ export declare const stabilizer_container_schema: z.ZodObject<{
         height: z.ZodNumber;
         depth: z.ZodNumber;
         weight: z.ZodOptional<z.ZodNumber>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
 export declare const stabilizer_env_schema: z.ZodObject<{
     containers: z.ZodArray<z.ZodObject<{
@@ -46,9 +49,12 @@ export declare const stabilizer_env_schema: z.ZodObject<{
             height: z.ZodNumber;
             depth: z.ZodNumber;
             weight: z.ZodOptional<z.ZodNumber>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strict>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>;
     axles: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    vehicle: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
 export declare const stabilizer_cargo_state_schema: z.ZodObject<{
     envs: z.ZodArray<z.ZodObject<{
@@ -68,9 +74,12 @@ export declare const stabilizer_cargo_state_schema: z.ZodObject<{
                 height: z.ZodNumber;
                 depth: z.ZodNumber;
                 weight: z.ZodOptional<z.ZodNumber>;
+                attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             }, z.core.$strict>>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strict>>;
         axles: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        vehicle: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>;
     config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;

package/build/core/validation/contract/stabilizer_domain_schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stabilizer_domain_schema.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/stabilizer_domain_schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,sBAAsB;;;;;;;;;;;kBAWxB,CAAA;AAEX,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;kBAM7B,CAAA;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;kBAGvB,CAAA;AAEX,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;kBAG/B,CAAA;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACnE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAC7E,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACjE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEhF;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,oBAAoB,GAAG,IAAI,CAKtF;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC1C,WAAW,EAAE,oBAAoB,EACjC,OAAO,EAAE,CAAC,CAAC,aAAa,GACzB,IAAI,CAqBN"}
+{"version":3,"file":"stabilizer_domain_schema.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/stabilizer_domain_schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;kBAYxB,CAAA;AAEX,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;kBAO7B,CAAA;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;kBAIvB,CAAA;AAEX,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;kBAG/B,CAAA;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACnE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAC7E,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACjE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEhF;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,oBAAoB,GAAG,IAAI,CAKtF;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC1C,WAAW,EAAE,oBAAoB,EACjC,OAAO,EAAE,CAAC,CAAC,aAAa,GACzB,IAAI,CAqBN"}

package/build/core/validation/contract/stabilizer_domain_schema.js

@@ -11,18 +11,21 @@ export const stabilizer_item_schema = z.object({
     width: z.number().positive(),
     height: z.number().positive(),
     depth: z.number().positive(),
-    weight: z.number().optional()
+    weight: z.number().optional(),
+    attributes: z.record(z.string(), z.unknown()).optional()
 }).strict();
 export const stabilizer_container_schema = z.object({
     sequence: z.number().optional(),
     width: z.number().positive(),
     height: z.number().positive(),
     length: z.number().positive(),
-    items: z.array(stabilizer_item_schema)
+    items: z.array(stabilizer_item_schema),
+    attributes: z.record(z.string(), z.unknown()).optional()
 }).strict();
 export const stabilizer_env_schema = z.object({
     containers: z.array(stabilizer_container_schema).min(1),
-    axles: z.array(z.record(z.string(), z.unknown())).optional()
+    axles: z.array(z.record(z.string(), z.unknown())).optional(),
+    vehicle: z.record(z.string(), z.unknown()).optional()
 }).strict();
 export const stabilizer_cargo_state_schema = z.object({
     envs: z.array(stabilizer_env_schema).min(1),

package/build/core/validation/contract/stabilizer_input_schema.d.ts

@@ -20,9 +20,12 @@ export declare const stabilizer_input_schema: z.ZodObject<{
                     height: z.ZodNumber;
                     depth: z.ZodNumber;
                     weight: z.ZodOptional<z.ZodNumber>;
+                    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 }, z.core.$strict>>;
+                attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             }, z.core.$strict>>;
             axles: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            vehicle: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strict>>;
         config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;

package/build/core/validation/contract/stabilizer_input_schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stabilizer_input_schema.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/stabilizer_input_schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASlC,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA"}
+{"version":3,"file":"stabilizer_input_schema.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/stabilizer_input_schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASlC,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

package/build/core/validation/contract/stabilizer_output_schema.d.ts

@@ -19,9 +19,12 @@ export declare const stabilizer_success_response_schema: z.ZodObject<{
                     height: z.ZodNumber;
                     depth: z.ZodNumber;
                     weight: z.ZodOptional<z.ZodNumber>;
+                    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 }, z.core.$strict>>;
+                attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             }, z.core.$strict>>;
             axles: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            vehicle: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strict>>;
         config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;
@@ -52,9 +55,12 @@ export declare const stabilizer_response_schema: z.ZodDiscriminatedUnion<[z.ZodO
                     height: z.ZodNumber;
                     depth: z.ZodNumber;
                     weight: z.ZodOptional<z.ZodNumber>;
+                    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 }, z.core.$strict>>;
+                attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             }, z.core.$strict>>;
             axles: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            vehicle: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strict>>;
         config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;

package/build/core/validation/contract/stabilizer_output_schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stabilizer_output_schema.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/stabilizer_output_schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAIpC,CAAA;AAEX,eAAO,MAAM,gCAAgC;;;;kBAIlC,CAAA;AAEX,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAGrC,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAC1F,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AACtF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA"}
+{"version":3,"file":"stabilizer_output_schema.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/stabilizer_output_schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAIpC,CAAA;AAEX,eAAO,MAAM,gCAAgC;;;;kBAIlC,CAAA;AAEX,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAGrC,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAC1F,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AACtF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA"}

package/build/core/validation/contract/wire_mapper_record_utils.d.ts

@@ -17,4 +17,18 @@ export declare function rename_keys(source: Record<string, unknown>, key_map: Re
  * @returns Filtered record.
  */
 export declare function pick_keys(source: Record<string, unknown>, allowed_keys: string[]): Record<string, unknown>;
+/**
+ * Reads the value of the first candidate key present on the record.
+ * @param source - Source record.
+ * @param candidate_keys - Candidate keys in precedence order.
+ * @returns Value of the first present key, or undefined when none is present.
+ */
+export declare function read_first_present(source: Record<string, unknown>, candidate_keys: readonly string[]): unknown;
+/**
+ * Keeps every defined key except the excluded ones.
+ * @param source - Source record.
+ * @param excluded_keys - Keys to drop.
+ * @returns Filtered record.
+ */
+export declare function omit_keys(source: Record<string, unknown>, excluded_keys: string[]): Record<string, unknown>;
 //# sourceMappingURL=wire_mapper_record_utils.d.ts.map

package/build/core/validation/contract/wire_mapper_record_utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wire_mapper_record_utils.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/wire_mapper_record_utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAG1E;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACvB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASzB;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CACrB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,YAAY,EAAE,MAAM,EAAE,GACvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAWzB"}
+{"version":3,"file":"wire_mapper_record_utils.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/wire_mapper_record_utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAG1E;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACvB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASzB;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CACrB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,YAAY,EAAE,MAAM,EAAE,GACvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAWzB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAC9B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,cAAc,EAAE,SAAS,MAAM,EAAE,GAClC,OAAO,CAUT;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CACrB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,aAAa,EAAE,MAAM,EAAE,GACxB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAYzB"}

package/build/core/validation/contract/wire_mapper_record_utils.js

@@ -34,3 +34,33 @@ export function pick_keys(source, allowed_keys) {
     }
     return picked;
 }
+/**
+ * Reads the value of the first candidate key present on the record.
+ * @param source - Source record.
+ * @param candidate_keys - Candidate keys in precedence order.
+ * @returns Value of the first present key, or undefined when none is present.
+ */
+export function read_first_present(source, candidate_keys) {
+    for (const key of candidate_keys) {
+        if (Object.hasOwn(source, key)) {
+            return source[key];
+        }
+    }
+    return undefined;
+}
+/**
+ * Keeps every defined key except the excluded ones.
+ * @param source - Source record.
+ * @param excluded_keys - Keys to drop.
+ * @returns Filtered record.
+ */
+export function omit_keys(source, excluded_keys) {
+    const kept = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (excluded_keys.includes(key) || value === undefined) {
+            continue;
+        }
+        kept[key] = value;
+    }
+    return kept;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jetta/cargo-stabilizer",
-    "version": "0.1.0-5",
+    "version": "0.1.0-7",
     "description": "Stable loose-item reorder library for cargo-movement (JET-2262)",
     "main": "build/index.js",
     "types": "build/index.d.ts",