@jetta/cargo-stabilizer 0.1.0-8 → 0.1.0

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

@@ -0,0 +1,40 @@
+import { is_record } from './wire_mapper_record_utils.js';
+import { merge_algoritmo_maps, read_raw_stabilizer_config } from '../../factory/read_stabilizer_config_helpers.js';
+const ALGORITMO_PREFIX = 'cargo_stabilizer.';
+/**
+ * Maps envelope plus cargo-profile algoritmo maps onto English stabilizer config.
+ * English config objects are returned unchanged for strict Zod checking.
+ * @param envelope_config - Envelope config from wire or English input.
+ * @param wire_cargo_state - Wire cargo state that may hold profile algoritmo.
+ * @returns Raw English config, or the original English object.
+ */
+export function map_envelope_config(envelope_config, wire_cargo_state) {
+    if (envelope_config === undefined && !has_profile_algoritmo(wire_cargo_state)) {
+        return undefined;
+    }
+    if (is_algoritmo_shaped(envelope_config) || has_profile_algoritmo(wire_cargo_state)) {
+        return read_raw_stabilizer_config(merge_algoritmo_maps(as_record(envelope_config), { config: read_wire_profile_config(wire_cargo_state) }));
+    }
+    return envelope_config;
+}
+function is_algoritmo_shaped(config) {
+    if (!is_record(config)) {
+        return false;
+    }
+    if (is_record(config.algoritmo)) {
+        return true;
+    }
+    return Object.keys(config).some(key => key.startsWith(ALGORITMO_PREFIX));
+}
+function has_profile_algoritmo(wire_cargo_state) {
+    return is_record(read_wire_profile_config(wire_cargo_state)?.algoritmo);
+}
+function read_wire_profile_config(wire_cargo_state) {
+    if (!is_record(wire_cargo_state) || !is_record(wire_cargo_state.config)) {
+        return undefined;
+    }
+    return wire_cargo_state.config;
+}
+function as_record(value) {
+    return is_record(value) ? value : undefined;
+}

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":"AAUA,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":"AAkBA,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAYnE"}

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

@@ -1,16 +1,19 @@
-import { CONTAINER_WIRE_TO_CONTRACT, ENV_WIRE_TO_CONTRACT } from './cargo_movement_wire_field_map.js';
+import { AXLE_WIRE_TO_CONTRACT, CONTAINER_WIRE_TO_CONTRACT, ENV_WIRE_TO_CONTRACT, VEHICLE_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'];
+import { uniquify_contract_item_ids } from './uniquify_contract_item_ids.js';
+import { is_record, pick_keys, rename_keys } from './wire_mapper_record_utils.js';
+const CONTAINER_CONTRACT_KEYS = [
+    'sequence', 'width', 'height', 'length', 'kingpin_distance',
+    'container_distance_ahead', 'max_supported_weight', 'tare', 'cargo_weight', 'grouper'
+];
+const ENV_CONTRACT_KEYS = ['axles', 'vehicle'];
+const VEHICLE_CONTRACT_KEYS = Object.values(VEHICLE_WIRE_TO_CONTRACT);
+const AXLE_CONTRACT_KEYS = Object.values(AXLE_WIRE_TO_CONTRACT);
 export function map_cargo_state_to_contract(value) {
     if (!is_record(value)) {
         return value;
     }
     const mapped = {};
-    if (value.config !== undefined) {
-        mapped.config = value.config;
-    }
     if (Array.isArray(value.envs)) {
         mapped.envs = value.envs.map(map_env_to_contract);
     }
@@ -24,6 +27,13 @@ function map_env_to_contract(value) {
     if (Array.isArray(value.containers)) {
         mapped.containers = value.containers.map(map_container_to_contract);
     }
+    if (Array.isArray(mapped.axles)) {
+        mapped.axles = mapped.axles.map(map_axle_to_contract);
+    }
+    const vehicle = map_vehicle_to_contract(value);
+    if (vehicle !== undefined) {
+        mapped.vehicle = vehicle;
+    }
     return pick_env_contract_keys(mapped);
 }
 function map_container_to_contract(value) {
@@ -32,29 +42,25 @@ 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_wire_item_to_contract);
+        mapped.items = uniquify_contract_item_ids(value.items.map(map_wire_item_to_contract));
     }
-    return pick_container_contract_keys(mapped);
+    return pick_keys(mapped, [...CONTAINER_CONTRACT_KEYS, 'items']);
 }
-function pick_container_contract_keys(source) {
-    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;
+function map_axle_to_contract(value) {
+    if (!is_record(value)) {
+        return value;
     }
-    return picked;
+    return pick_keys(rename_keys(value, AXLE_WIRE_TO_CONTRACT), AXLE_CONTRACT_KEYS);
+}
+function map_vehicle_to_contract(env) {
+    const source = is_record(env.vehicle) ? env.vehicle : env;
+    const mapped = pick_keys(rename_keys(source, VEHICLE_WIRE_TO_CONTRACT), VEHICLE_CONTRACT_KEYS);
+    return Object.keys(mapped).length > 0 ? mapped : undefined;
 }
 function pick_env_contract_keys(source) {
     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_stacking.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Lifts nested CM stacking and restriction fields onto the contract item.
+ * @param contract - Contract item being filled.
+ * @param source - Wire or English item record.
+ */
+export declare function assign_stacking_fields(contract: Record<string, unknown>, source: Record<string, unknown>): void;
+//# sourceMappingURL=map_wire_item_stacking.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"map_wire_item_stacking.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/map_wire_item_stacking.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,sBAAsB,CAClC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,IAAI,CAYN"}

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

@@ -0,0 +1,40 @@
+import { is_record } from './wire_mapper_record_utils.js';
+/**
+ * Lifts nested CM stacking and restriction fields onto the contract item.
+ * @param contract - Contract item being filled.
+ * @param source - Wire or English item record.
+ */
+export function assign_stacking_fields(contract, source) {
+    assign_nested_stacking(contract, source.stacking);
+    assign_restriction_flags(contract, source.restrictions ?? source.restricoes);
+    if (typeof source.pesoMaxSuportado === 'number' && contract.supported_weight === undefined) {
+        contract.supported_weight = source.pesoMaxSuportado;
+    }
+    if (typeof source.stackingUnit === 'string' && contract.stacking_unit === undefined) {
+        contract.stacking_unit = source.stackingUnit;
+    }
+}
+function assign_nested_stacking(contract, stacking) {
+    if (!is_record(stacking)) {
+        return;
+    }
+    if (typeof stacking.family === 'string' && contract.family === undefined) {
+        contract.family = stacking.family;
+    }
+    if (Array.isArray(stacking.supported_families) && contract.supported_families === undefined) {
+        contract.supported_families = stacking.supported_families;
+    }
+}
+function assign_restriction_flags(contract, restrictions) {
+    if (!is_record(restrictions)) {
+        return;
+    }
+    assign_boolean_if_absent(contract, 'stack_families', restrictions.empilharFamilias);
+    assign_boolean_if_absent(contract, 'stack_same_item', restrictions.empilharItemIgual);
+    assign_boolean_if_absent(contract, 'stack_same_area', restrictions.empilharAreaIgual);
+}
+function assign_boolean_if_absent(contract, key, value) {
+    if (typeof value === 'boolean' && contract[key] === undefined) {
+        contract[key] = value;
+    }
+}

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

@@ -1,10 +1,6 @@
 /**
  * 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.
+ * Only modelled fields are copied; leftover SKU keys are dropped.
  * @param value - Raw wire item.
  * @returns Contract item, or the input unchanged when it is not a record.
  */

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

@@ -1 +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"}
+{"version":3,"file":"map_wire_item_to_contract.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/map_wire_item_to_contract.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAUjE"}

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

@@ -1,12 +1,9 @@
 import { ITEM_CONTRACT_WIRE_KEYS, ITEM_POSITION_KEYS } from './cargo_movement_wire_field_map.js';
+import { assign_stacking_fields } from './map_wire_item_stacking.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.
+ * Only modelled fields are copied; leftover SKU keys are dropped.
  * @param value - Raw wire item.
  * @returns Contract item, or the input unchanged when it is not a record.
  */
@@ -15,18 +12,11 @@ export function map_wire_item_to_contract(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;
-    }
+    assign_stacking_fields(contract, omit_keys(value, ITEM_POSITION_KEYS));
     return contract;
 }
 function read_contract_item_fields(source) {
-    const contract = {
-        x: source.x,
-        y: source.y,
-        z: source.z
-    };
+    const contract = read_contract_position(source);
     for (const [contract_key, wire_keys] of Object.entries(ITEM_CONTRACT_WIRE_KEYS)) {
         const value = read_first_present(source, wire_keys);
         if (value !== undefined) {
@@ -35,6 +25,18 @@ function read_contract_item_fields(source) {
     }
     return contract;
 }
+/**
+ * BWA `to_json` stores length on `y` and height on `z`. Candidate geometry
+ * uses the opposite (y = height, z = length), so CM wire items are swapped.
+ * @param source - Wire or English item record.
+ * @returns Contract x/y/z.
+ */
+function read_contract_position(source) {
+    if (typeof source.w === 'number') {
+        return { x: source.x, y: source.z, z: source.y };
+    }
+    return { x: source.x, y: source.y, z: source.z };
+}
 /**
  * Coerces blocks-wall numeric group ids to the string contract type.
  * @param contract_key - English contract field name.

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

@@ -23,20 +23,62 @@ 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;
+                    tie_ratio_orientation?: string | undefined;
+                    family?: string | undefined;
+                    supported_families?: string[] | undefined;
+                    constraint?: string | undefined;
+                    stack_families?: boolean | undefined;
+                    stack_same_item?: boolean | undefined;
+                    stack_same_area?: boolean | undefined;
+                    stacking_unit?: string | undefined;
+                    supported_weight?: number | undefined;
+                    priority?: number | undefined;
                 }[];
                 sequence?: number | undefined;
-                attributes?: Record<string, unknown> | undefined;
+                kingpin_distance?: number | undefined;
+                container_distance_ahead?: number | undefined;
+                max_supported_weight?: number | undefined;
+                tare?: number | undefined;
+                cargo_weight?: number | undefined;
+                grouper?: number | undefined;
             }[];
-            axles?: Record<string, unknown>[] | undefined;
-            vehicle?: Record<string, unknown> | undefined;
+            axles?: {
+                distance_from_origin?: number | undefined;
+                max_supported_weight?: number | undefined;
+                dnit_weight?: number | undefined;
+                tare?: number | undefined;
+                container_sequence?: number | undefined;
+                sequence?: number | undefined;
+            }[] | undefined;
+            vehicle?: {
+                vehicle_id?: string | number | undefined;
+                vehicle_type?: number | undefined;
+                version_type?: number | undefined;
+                suspension_type?: string | undefined;
+                first_axle?: number | undefined;
+                tare?: number | undefined;
+                max_supported_weight?: number | undefined;
+                quantity?: number | undefined;
+            } | undefined;
         }[];
-        config?: Record<string, unknown> | undefined;
     };
     id?: string | number | undefined;
     company?: string | number | undefined;
-    original_input?: unknown;
-    config?: Record<string, unknown> | undefined;
+    config?: {
+        reorder_strategy: string;
+        transport_stability_floor: number;
+        max_iteration: number;
+        genetic_population: number;
+        genetic_generations: number;
+        genetic_mutation_rate: number;
+        beam_width: number;
+        beam_top_k: number;
+        axle_load_margin_percent: number;
+        preserve_tie_block_organization: boolean;
+        pin_tie_ratio_blocks: boolean;
+        enforce_milkrun_wall_reservation: boolean;
+        number_of_wall_to_allocate_from_last_waypoints: number;
+    } | undefined;
 }>;
 /**
  * Parses stabilizer input at the public boundary.

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;AAExD,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,CAU3E;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAA"}

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

@@ -1,6 +1,7 @@
 import { InvalidStabilizerInputError } from '../../exceptions/InvalidStabilizerInputError.js';
 import { map_wire_input_to_contract } from './cargo_movement_wire_mapper.js';
 import { format_zod_error } from './format_zod_error.js';
+import { reject_forbidden_input_fields } from './reject_forbidden_input_fields.js';
 import { stabilizer_input_schema } from './stabilizer_input_schema.js';
 /**
  * Safely parses stabilizer input after wire mapping.
@@ -17,6 +18,7 @@ export function safe_parse_stabilizer_input(input_data) {
  * @returns Validated stabilizer input in English contract shape.
  */
 export function parse_stabilizer_input(input_data) {
+    reject_forbidden_input_fields(input_data);
     const result = safe_parse_stabilizer_input(input_data);
     if (!result.success) {
         throw new InvalidStabilizerInputError(format_zod_error(result.error));

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

@@ -24,15 +24,44 @@ 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;
+                    tie_ratio_orientation?: string | undefined;
+                    family?: string | undefined;
+                    supported_families?: string[] | undefined;
+                    constraint?: string | undefined;
+                    stack_families?: boolean | undefined;
+                    stack_same_item?: boolean | undefined;
+                    stack_same_area?: boolean | undefined;
+                    stacking_unit?: string | undefined;
+                    supported_weight?: number | undefined;
+                    priority?: number | undefined;
                 }[];
                 sequence?: number | undefined;
-                attributes?: Record<string, unknown> | undefined;
+                kingpin_distance?: number | undefined;
+                container_distance_ahead?: number | undefined;
+                max_supported_weight?: number | undefined;
+                tare?: number | undefined;
+                cargo_weight?: number | undefined;
+                grouper?: number | undefined;
             }[];
-            axles?: Record<string, unknown>[] | undefined;
-            vehicle?: Record<string, unknown> | undefined;
+            axles?: {
+                distance_from_origin?: number | undefined;
+                max_supported_weight?: number | undefined;
+                dnit_weight?: number | undefined;
+                tare?: number | undefined;
+                container_sequence?: number | undefined;
+                sequence?: number | undefined;
+            }[] | undefined;
+            vehicle?: {
+                vehicle_id?: string | number | undefined;
+                vehicle_type?: number | undefined;
+                version_type?: number | undefined;
+                suspension_type?: string | undefined;
+                first_axle?: number | undefined;
+                tare?: number | undefined;
+                max_supported_weight?: number | undefined;
+                quantity?: number | undefined;
+            } | undefined;
         }[];
-        config?: Record<string, unknown> | undefined;
     };
     messages: string[];
 } | {

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

@@ -0,0 +1,6 @@
+/**
+ * Rejects dropped contract bags (`original_input`, item `attributes`) before mapping.
+ * @param input_data - Raw stabilizer input.
+ */
+export declare function reject_forbidden_input_fields(input_data: unknown): void;
+//# sourceMappingURL=reject_forbidden_input_fields.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reject_forbidden_input_fields.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/reject_forbidden_input_fields.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI,CAWvE"}

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

@@ -0,0 +1,53 @@
+import { InvalidStabilizerInputError } from '../../exceptions/InvalidStabilizerInputError.js';
+/**
+ * Rejects dropped contract bags (`original_input`, item `attributes`) before mapping.
+ * @param input_data - Raw stabilizer input.
+ */
+export function reject_forbidden_input_fields(input_data) {
+    if (typeof input_data !== 'object' || input_data === null) {
+        return;
+    }
+    if ('original_input' in input_data) {
+        throw new InvalidStabilizerInputError('original_input is not part of the stabilizer contract');
+    }
+    reject_item_attributes(input_data);
+}
+function reject_item_attributes(input_data) {
+    const cargo_state = input_data.cargo_state;
+    if (typeof cargo_state !== 'object' || cargo_state === null) {
+        return;
+    }
+    const envs = cargo_state.envs;
+    if (!Array.isArray(envs)) {
+        return;
+    }
+    for (const env of envs) {
+        reject_env_item_attributes(env);
+    }
+}
+function reject_env_item_attributes(env) {
+    if (typeof env !== 'object' || env === null) {
+        return;
+    }
+    const containers = env.containers;
+    if (!Array.isArray(containers)) {
+        return;
+    }
+    for (const container of containers) {
+        reject_container_item_attributes(container);
+    }
+}
+function reject_container_item_attributes(container) {
+    if (typeof container !== 'object' || container === null) {
+        return;
+    }
+    const items = container.items;
+    if (!Array.isArray(items)) {
+        return;
+    }
+    for (const item of items) {
+        if (typeof item === 'object' && item !== null && 'attributes' in item) {
+            throw new InvalidStabilizerInputError('item attributes is not part of the stabilizer contract');
+        }
+    }
+}

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

@@ -1,61 +1,6 @@
 import { z } from 'zod';
-export declare const stabilizer_item_schema: z.ZodObject<{
-    item_id: z.ZodString;
-    group_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
-    waypoint_id: z.ZodOptional<z.ZodString>;
-    x: z.ZodNumber;
-    y: z.ZodNumber;
-    z: z.ZodNumber;
-    width: z.ZodNumber;
-    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>;
-    width: z.ZodNumber;
-    height: z.ZodNumber;
-    length: z.ZodNumber;
-    items: z.ZodArray<z.ZodObject<{
-        item_id: z.ZodString;
-        group_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
-        waypoint_id: z.ZodOptional<z.ZodString>;
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-        width: z.ZodNumber;
-        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<{
-        sequence: z.ZodOptional<z.ZodNumber>;
-        width: z.ZodNumber;
-        height: z.ZodNumber;
-        length: z.ZodNumber;
-        items: z.ZodArray<z.ZodObject<{
-            item_id: z.ZodString;
-            group_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
-            waypoint_id: z.ZodOptional<z.ZodString>;
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            z: z.ZodNumber;
-            width: z.ZodNumber;
-            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 { stabilizer_item_schema, type StabilizerItem } from './stabilizer_item_schema.js';
+export { stabilizer_axle_schema, stabilizer_vehicle_schema, stabilizer_container_schema, stabilizer_env_schema, type StabilizerAxle, type StabilizerVehicle, type StabilizerContainer, type StabilizerEnv } from './stabilizer_env_schema.js';
 export declare const stabilizer_cargo_state_schema: z.ZodObject<{
     envs: z.ZodArray<z.ZodObject<{
         containers: z.ZodArray<z.ZodObject<{
@@ -74,18 +19,44 @@ 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>>;
+                tie_ratio_orientation: z.ZodOptional<z.ZodString>;
+                family: z.ZodOptional<z.ZodString>;
+                supported_families: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                constraint: z.ZodOptional<z.ZodString>;
+                stack_families: z.ZodOptional<z.ZodBoolean>;
+                stack_same_item: z.ZodOptional<z.ZodBoolean>;
+                stack_same_area: z.ZodOptional<z.ZodBoolean>;
+                stacking_unit: z.ZodOptional<z.ZodString>;
+                supported_weight: z.ZodOptional<z.ZodNumber>;
+                priority: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strict>>;
-            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            kingpin_distance: z.ZodOptional<z.ZodNumber>;
+            container_distance_ahead: z.ZodOptional<z.ZodNumber>;
+            max_supported_weight: z.ZodOptional<z.ZodNumber>;
+            tare: z.ZodOptional<z.ZodNumber>;
+            cargo_weight: z.ZodOptional<z.ZodNumber>;
+            grouper: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        axles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            distance_from_origin: z.ZodOptional<z.ZodNumber>;
+            max_supported_weight: z.ZodOptional<z.ZodNumber>;
+            dnit_weight: z.ZodOptional<z.ZodNumber>;
+            tare: z.ZodOptional<z.ZodNumber>;
+            container_sequence: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        vehicle: z.ZodOptional<z.ZodObject<{
+            vehicle_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+            vehicle_type: z.ZodOptional<z.ZodNumber>;
+            version_type: z.ZodOptional<z.ZodNumber>;
+            suspension_type: z.ZodOptional<z.ZodString>;
+            first_axle: z.ZodOptional<z.ZodNumber>;
+            tare: z.ZodOptional<z.ZodNumber>;
+            max_supported_weight: z.ZodOptional<z.ZodNumber>;
+            quantity: z.ZodOptional<z.ZodNumber>;
         }, 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>;
-export type StabilizerItem = z.infer<typeof stabilizer_item_schema>;
-export type StabilizerContainer = z.infer<typeof stabilizer_container_schema>;
-export type StabilizerEnv = z.infer<typeof stabilizer_env_schema>;
 export type StabilizerCargoState = z.infer<typeof stabilizer_cargo_state_schema>;
 /**
  * Validates waypoint consistency across all items in the primary env.

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;;;;;;;;;;;;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"}
+{"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;AAKvB,OAAO,EACH,sBAAsB,EACtB,KAAK,cAAc,EACtB,MAAM,6BAA6B,CAAA;AACpC,OAAO,EACH,sBAAsB,EACtB,yBAAyB,EACzB,2BAA2B,EAC3B,qBAAqB,EACrB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,aAAa,EACrB,MAAM,4BAA4B,CAAA;AAEnC,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE/B,CAAA;AAEX,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,CAUN"}