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

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

@@ -1,6 +1,55 @@
 import { z } from 'zod';
-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_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>;
+}, 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>;
+    }, z.core.$strict>>;
+}, 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>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    axles: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strict>;
 export declare const stabilizer_cargo_state_schema: z.ZodObject<{
     envs: z.ZodArray<z.ZodObject<{
         containers: z.ZodArray<z.ZodObject<{
@@ -19,44 +68,15 @@ export declare const stabilizer_cargo_state_schema: z.ZodObject<{
                 height: z.ZodNumber;
                 depth: z.ZodNumber;
                 weight: z.ZodOptional<z.ZodNumber>;
-                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>>;
-            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>>>;
     }, 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;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"}
+{"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"}

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

@@ -1,11 +1,32 @@
 import { z } from 'zod';
 import { MixedWaypointIdError } from '../../exceptions/MixedWaypointIdError.js';
 import { validate_waypoint_ids } from '../../waypoint/validate_waypoint_ids.js';
-import { stabilizer_env_schema } from './stabilizer_env_schema.js';
-export { stabilizer_item_schema } from './stabilizer_item_schema.js';
-export { stabilizer_axle_schema, stabilizer_vehicle_schema, stabilizer_container_schema, stabilizer_env_schema } from './stabilizer_env_schema.js';
+export const stabilizer_item_schema = z.object({
+    item_id: z.string().min(1),
+    group_id: z.union([z.string(), z.null()]).optional(),
+    waypoint_id: z.string().optional(),
+    x: z.number(),
+    y: z.number(),
+    z: z.number(),
+    width: z.number().positive(),
+    height: z.number().positive(),
+    depth: z.number().positive(),
+    weight: z.number().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)
+}).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()
+}).strict();
 export const stabilizer_cargo_state_schema = z.object({
-    envs: z.array(stabilizer_env_schema).min(1)
+    envs: z.array(stabilizer_env_schema).min(1),
+    config: z.record(z.string(), z.unknown()).optional()
 }).strict();
 /**
  * Validates waypoint consistency across all items in the primary env.
@@ -26,17 +47,15 @@ export function add_waypoint_validation_issues(cargo_state, context) {
         validate_primary_env_waypoints(cargo_state);
     }
     catch (error) {
-        add_waypoint_issue_or_throw(error, context);
-    }
-}
-function add_waypoint_issue_or_throw(error, context) {
-    if (error instanceof MixedWaypointIdError) {
-        context.addIssue({
-            code: 'custom',
-            message: error.message,
-            path: ['cargo_state', 'envs', 0]
-        });
-        return;
+        if (error instanceof MixedWaypointIdError) {
+            context.addIssue({
+                code: 'custom',
+                message: error.message,
+                path: ['cargo_state', 'envs', 0]
+            });
+        }
+        else {
+            throw error;
+        }
     }
-    throw error;
 }

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

@@ -20,61 +20,14 @@ export declare const stabilizer_input_schema: z.ZodObject<{
                     height: z.ZodNumber;
                     depth: z.ZodNumber;
                     weight: z.ZodOptional<z.ZodNumber>;
-                    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>>;
-                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>>>;
         }, z.core.$strict>>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;
-    config: z.ZodOptional<z.ZodObject<{
-        reorder_strategy: z.ZodDefault<z.ZodEnum<{
-            [x: string]: string;
-        }>>;
-        transport_stability_floor: z.ZodDefault<z.ZodNumber>;
-        max_iteration: z.ZodDefault<z.ZodNumber>;
-        genetic_population: z.ZodDefault<z.ZodNumber>;
-        genetic_generations: z.ZodDefault<z.ZodNumber>;
-        genetic_mutation_rate: z.ZodDefault<z.ZodNumber>;
-        beam_width: z.ZodDefault<z.ZodNumber>;
-        beam_top_k: z.ZodDefault<z.ZodNumber>;
-        axle_load_margin_percent: z.ZodDefault<z.ZodNumber>;
-        preserve_tie_block_organization: z.ZodDefault<z.ZodBoolean>;
-        pin_tie_ratio_blocks: z.ZodDefault<z.ZodBoolean>;
-        enforce_milkrun_wall_reservation: z.ZodDefault<z.ZodBoolean>;
-        number_of_wall_to_allocate_from_last_waypoints: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strict>>;
+    original_input: z.ZodOptional<z.ZodUnknown>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
 export type StabilizerInput = z.infer<typeof stabilizer_input_schema>;
 //# sourceMappingURL=stabilizer_input_schema.d.ts.map

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;AAOvB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQlC,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_input_schema.js

@@ -1,11 +1,11 @@
 import { z } from 'zod';
-import { stabilizer_config_schema } from '../schemas/stabilizer_config_schema.js';
 import { add_waypoint_validation_issues, stabilizer_cargo_state_schema } from './stabilizer_domain_schema.js';
 export const stabilizer_input_schema = z.object({
     id: z.union([z.string(), z.number()]).optional(),
     company: z.union([z.string(), z.number()]).optional(),
     cargo_state: stabilizer_cargo_state_schema,
-    config: stabilizer_config_schema.optional()
+    original_input: z.unknown().optional(),
+    config: z.record(z.string(), z.unknown()).optional()
 }).strict().superRefine((input_data, context) => {
     add_waypoint_validation_issues(input_data.cargo_state, context);
 });

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

@@ -19,43 +19,11 @@ export declare const stabilizer_success_response_schema: z.ZodObject<{
                     height: z.ZodNumber;
                     depth: z.ZodNumber;
                     weight: z.ZodOptional<z.ZodNumber>;
-                    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>>;
-                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>>>;
         }, z.core.$strict>>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;
     messages: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
@@ -84,43 +52,11 @@ export declare const stabilizer_response_schema: z.ZodDiscriminatedUnion<[z.ZodO
                     height: z.ZodNumber;
                     depth: z.ZodNumber;
                     weight: z.ZodOptional<z.ZodNumber>;
-                    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>>;
-                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>>>;
         }, z.core.$strict>>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;
     messages: z.ZodArray<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{

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,18 +17,4 @@ 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;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"}
+{"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"}

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

@@ -34,33 +34,3 @@ 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/build/core/validation/schemas/stabilizer_config_schema.d.ts

@@ -12,9 +12,8 @@ export declare const stabilizer_config_schema: z.ZodObject<{
     beam_top_k: z.ZodDefault<z.ZodNumber>;
     axle_load_margin_percent: z.ZodDefault<z.ZodNumber>;
     preserve_tie_block_organization: z.ZodDefault<z.ZodBoolean>;
-    pin_tie_ratio_blocks: z.ZodDefault<z.ZodBoolean>;
     enforce_milkrun_wall_reservation: z.ZodDefault<z.ZodBoolean>;
     number_of_wall_to_allocate_from_last_waypoints: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type StabilizerConfig = z.infer<typeof stabilizer_config_schema>;
 //# sourceMappingURL=stabilizer_config_schema.d.ts.map

package/build/core/validation/schemas/stabilizer_config_schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stabilizer_config_schema.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/schemas/stabilizer_config_schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;kBAc1B,CAAA;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA"}
+{"version":3,"file":"stabilizer_config_schema.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/schemas/stabilizer_config_schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;iBAanC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA"}

package/build/core/validation/schemas/stabilizer_config_schema.js

@@ -11,7 +11,6 @@ export const stabilizer_config_schema = z.object({
     beam_top_k: z.number().int().positive().default(3),
     axle_load_margin_percent: z.number().min(0).default(0),
     preserve_tie_block_organization: z.boolean().default(true),
-    pin_tie_ratio_blocks: z.boolean().default(false),
     enforce_milkrun_wall_reservation: z.boolean().default(false),
     number_of_wall_to_allocate_from_last_waypoints: z.number().int().min(0).default(0)
-}).strict();
+});

package/build/index.d.ts

@@ -1,4 +1,3 @@
-import { type StabilizerInput, type StabilizerResponse } from './core/validation/contract/index.js';
 export { REORDER_STRATEGY, REORDER_STRATEGY_VALUES } from './core/constants/ReorderStrategy.js';
 export type { ReorderStrategyValue } from './core/constants/ReorderStrategy.js';
 export { MixedWaypointIdError } from './core/exceptions/MixedWaypointIdError.js';
@@ -7,19 +6,21 @@ export { InvalidStabilizerInputError } from './core/exceptions/InvalidStabilizer
 export { InvalidStabilizerOutputError } from './core/exceptions/InvalidStabilizerOutputError.js';
 export type { StabilizerInput, StabilizerResponse, StabilizerSuccessResponse, StabilizerErrorResponse, StabilizerItem, StabilizerContainer, StabilizerEnv, StabilizerCargoState } from './core/validation/contract/index.js';
 export { parse_stabilizer_input, safe_parse_stabilizer_input, parse_stabilizer_output, safe_parse_stabilizer_output, map_wire_input_to_contract, map_contract_to_wire_output } from './core/validation/contract/index.js';
-export type StabilizerWireResponse = StabilizerResponse;
+export type StabilizerWireResponse = {
+    status: 'success';
+    data: unknown;
+    messages: string[];
+} | {
+    status: 'error';
+    data: string;
+    messages: string[];
+};
 /**
- * Parses unknown wire or English input, then runs the typed stabilizer.
+ * Stabilizes cargo by reordering loose items (legacy CM-compatible response).
  * @param input - Cargo-movement wire payload or English contract input.
- * @returns Success or error response with typed cargo_state on success.
+ * @returns Success or error response with CM wire cargo_state on success.
  */
-export declare function stabilize(input: unknown): Promise<StabilizerResponse>;
-/**
- * Runs stabilizer on a parsed contract input. `unknown` is not accepted.
- * @param input - Validated stabilizer input.
- * @returns Success or error response.
- */
-export declare function run_stabilize(input: StabilizerInput): StabilizerResponse;
+export declare function stabilize(input: unknown): Promise<StabilizerWireResponse>;
 export { run_stabilizer_flow_from_unknown } from './core/orchestration/StabilizerFlow.js';
 export { create_reorder_strategy } from './core/factory/strategy_factory.js';
 export { validate_waypoint_ids } from './core/waypoint/validate_waypoint_ids.js';

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAGH,KAAK,eAAe,EACpB,KAAK,kBAAkB,EAC1B,MAAM,qCAAqC,CAAA;AAE5C,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAA;AAC/F,YAAY,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAA;AAC/E,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAA;AAChF,OAAO,EAAE,2BAA2B,EAAE,MAAM,kDAAkD,CAAA;AAC9F,OAAO,EAAE,2BAA2B,EAAE,MAAM,kDAAkD,CAAA;AAC9F,OAAO,EAAE,4BAA4B,EAAE,MAAM,mDAAmD,CAAA;AAChG,YAAY,EACR,eAAe,EACf,kBAAkB,EAClB,yBAAyB,EACzB,uBAAuB,EACvB,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,oBAAoB,EACvB,MAAM,qCAAqC,CAAA;AAC5C,OAAO,EACH,sBAAsB,EACtB,2BAA2B,EAC3B,uBAAuB,EACvB,4BAA4B,EAC5B,0BAA0B,EAC1B,2BAA2B,EAC9B,MAAM,qCAAqC,CAAA;AAK5C,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,CAAA;AAEvD;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAc3E;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,eAAe,GAAG,kBAAkB,CAaxE;AAkDD,OAAO,EAAE,gCAAgC,EAAE,MAAM,wCAAwC,CAAA;AACzF,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAA;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAA;AAC/F,YAAY,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAA;AAC/E,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAA;AAChF,OAAO,EAAE,2BAA2B,EAAE,MAAM,kDAAkD,CAAA;AAC9F,OAAO,EAAE,2BAA2B,EAAE,MAAM,kDAAkD,CAAA;AAC9F,OAAO,EAAE,4BAA4B,EAAE,MAAM,mDAAmD,CAAA;AAChG,YAAY,EACR,eAAe,EACf,kBAAkB,EAClB,yBAAyB,EACzB,uBAAuB,EACvB,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,oBAAoB,EACvB,MAAM,qCAAqC,CAAA;AAC5C,OAAO,EACH,sBAAsB,EACtB,2BAA2B,EAC3B,uBAAuB,EACvB,4BAA4B,EAC5B,0BAA0B,EAC1B,2BAA2B,EAC9B,MAAM,qCAAqC,CAAA;AAK5C,MAAM,MAAM,sBAAsB,GAC5B;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,GACxD;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AAE3D;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAI/E;AAsED,OAAO,EAAE,gCAAgC,EAAE,MAAM,wCAAwC,CAAA;AACzF,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAA;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAA"}

package/build/index.js

@@ -1,7 +1,7 @@
 import { Logger } from '@jetta/logger';
-import { run_stabilizer_flow } from './core/orchestration/StabilizerFlow.js';
+import { run_stabilizer_flow_from_unknown } from './core/orchestration/StabilizerFlow.js';
 import { stabilizer_logger } from './core/logging/stabilizer_logger.js';
-import { parse_stabilizer_input, parse_stabilizer_output } from './core/validation/contract/index.js';
+import { map_contract_to_wire_output, parse_stabilizer_output } from './core/validation/contract/index.js';
 export { REORDER_STRATEGY, REORDER_STRATEGY_VALUES } from './core/constants/ReorderStrategy.js';
 export { MixedWaypointIdError } from './core/exceptions/MixedWaypointIdError.js';
 export { UnknownReorderStrategyError } from './core/exceptions/UnknownReorderStrategyError.js';
@@ -11,36 +11,13 @@ export { parse_stabilizer_input, safe_parse_stabilizer_input, parse_stabilizer_o
 const messages = [];
 const UNKNOWN_IDENTITY = 'UNKNOWN';
 /**
- * Parses unknown wire or English input, then runs the typed stabilizer.
+ * Stabilizes cargo by reordering loose items (legacy CM-compatible response).
  * @param input - Cargo-movement wire payload or English contract input.
- * @returns Success or error response with typed cargo_state on success.
+ * @returns Success or error response with CM wire cargo_state on success.
  */
 export async function stabilize(input) {
     const identity = read_stabilizer_identity(input);
-    return Logger.run_with_cargo_info(identity.company, identity.cargo_id, () => {
-        try {
-            return run_stabilize(parse_stabilizer_input(input));
-        }
-        catch (error) {
-            return build_error_response(error);
-        }
-    });
-}
-/**
- * Runs stabilizer on a parsed contract input. `unknown` is not accepted.
- * @param input - Validated stabilizer input.
- * @returns Success or error response.
- */
-export function run_stabilize(input) {
-    stabilizer_logger.log('cargo-stabilizer started');
-    try {
-        const cargo_state = run_stabilizer_flow(input);
-        stabilizer_logger.log('cargo-stabilizer finished successfully');
-        return build_success_response(cargo_state);
-    }
-    catch (error) {
-        return build_error_response(error);
-    }
+    return Logger.run_with_cargo_info(identity.company, identity.cargo_id, () => run_stabilize(input));
 }
 function read_stabilizer_identity(input) {
     if (typeof input !== 'object' || input === null) {
@@ -52,6 +29,17 @@ function read_stabilizer_identity(input) {
         cargo_id: record.id !== undefined ? String(record.id) : UNKNOWN_IDENTITY
     };
 }
+function run_stabilize(input) {
+    stabilizer_logger.log('cargo-stabilizer started');
+    try {
+        const cargo_state = run_stabilizer_flow_from_unknown(input);
+        stabilizer_logger.log('cargo-stabilizer finished successfully');
+        return build_success_response(cargo_state);
+    }
+    catch (error) {
+        return build_error_response(error);
+    }
+}
 function build_success_response(cargo_state) {
     const english_response = {
         status: 'success',
@@ -62,7 +50,11 @@ function build_success_response(cargo_state) {
     if (validated.status !== 'success') {
         throw new Error('Expected success response after stabilizer flow');
     }
-    return validated;
+    return {
+        status: 'success',
+        data: map_contract_to_wire_output(validated.data),
+        messages: validated.messages
+    };
 }
 function build_error_response(err) {
     stabilizer_logger.warn('cargo-stabilizer finished with error');

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jetta/cargo-stabilizer",
-    "version": "0.1.0-15",
+    "version": "0.1.0-5",
     "description": "Stable loose-item reorder library for cargo-movement (JET-2262)",
     "main": "build/index.js",
     "types": "build/index.d.ts",
@@ -29,25 +29,23 @@
         "coverage:ci": "c8 --reporter=text --reporter=text-summary --check-coverage --lines 75 --functions 75 --branches 75 --statements 75 npm run test"
     },
     "dependencies": {
-        "@jetta/axle-load-calculator": "^0.3.3",
+        "@jetta/axle-load-calculator": "^0.1.3",
         "@jetta/cargo-stability": "^2.0.1-3",
         "@jetta/empty-spaces-manager": "^0.1.1-0",
-        "@jetta/number-compare": "^3.0.3",
-        "@jetta/stacking-constraints": "^1.1.0",
         "zod": "^4.4.3"
     },
     "devDependencies": {
         "@types/chai": "^5.2.3",
         "@types/mocha": "^10.0.10",
-        "@types/node": "^26.3.0",
-        "@typescript-eslint/eslint-plugin": "^8.68.0",
-        "@typescript-eslint/parser": "^8.68.0",
-        "c8": "^12.0.0",
+        "@types/node": "^25.9.1",
+        "@typescript-eslint/eslint-plugin": "^8.59.4",
+        "@typescript-eslint/parser": "^8.59.4",
+        "c8": "^11.0.0",
         "chai": "^6.2.2",
-        "eslint": "^10.9.1",
-        "mocha": "^11.8.0",
-        "publint": "^0.3.24",
-        "tsx": "^4.23.12",
+        "eslint": "^9.39.4",
+        "mocha": "^11.7.6",
+        "publint": "^0.3.23",
+        "tsx": "^4.22.3",
         "typescript": "^6.0.3"
     }
 }

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

@@ -1,8 +0,0 @@
-/**
- * Result of one axle-load calculator pass.
- */
-export interface AxleLoadEvaluation {
-    valid: boolean;
-    excess_kg: number;
-}
-//# sourceMappingURL=axle_load_evaluation.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"axle_load_evaluation.d.ts","sourceRoot":"","sources":["../../../src/core/adapters/axle_load_evaluation.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAE/B,KAAK,EAAE,OAAO,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;CACpB"}