@jetta/cargo-stabilizer 0.1.0-9 → 0.1.0

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

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+export declare const stabilizer_axle_schema: 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>;
+export declare const stabilizer_vehicle_schema: 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>;
+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>;
+        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>;
+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>;
+            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>>;
+}, z.core.$strict>;
+export type StabilizerAxle = z.infer<typeof stabilizer_axle_schema>;
+export type StabilizerVehicle = z.infer<typeof stabilizer_vehicle_schema>;
+export type StabilizerContainer = z.infer<typeof stabilizer_container_schema>;
+export type StabilizerEnv = z.infer<typeof stabilizer_env_schema>;
+//# sourceMappingURL=stabilizer_env_schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stabilizer_env_schema.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/stabilizer_env_schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,sBAAsB;;;;;;;kBAOxB,CAAA;AAEX,eAAO,MAAM,yBAAyB;;;;;;;;;kBAS3B,CAAA;AAEX,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAY7B,CAAA;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAIvB,CAAA;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACnE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AACzE,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"}

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

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { stabilizer_item_schema } from './stabilizer_item_schema.js';
+export const stabilizer_axle_schema = z.object({
+    distance_from_origin: z.number().optional(),
+    max_supported_weight: z.number().optional(),
+    dnit_weight: z.number().optional(),
+    tare: z.number().optional(),
+    container_sequence: z.number().optional(),
+    sequence: z.number().optional()
+}).strict();
+export const stabilizer_vehicle_schema = z.object({
+    vehicle_id: z.union([z.string(), z.number()]).optional(),
+    vehicle_type: z.number().optional(),
+    version_type: z.number().optional(),
+    suspension_type: z.string().optional(),
+    first_axle: z.number().optional(),
+    tare: z.number().optional(),
+    max_supported_weight: z.number().optional(),
+    quantity: 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),
+    kingpin_distance: z.number().optional(),
+    container_distance_ahead: z.number().optional(),
+    max_supported_weight: z.number().optional(),
+    tare: z.number().optional(),
+    cargo_weight: z.number().optional(),
+    grouper: z.number().optional()
+}).strict();
+export const stabilizer_env_schema = z.object({
+    containers: z.array(stabilizer_container_schema).min(1),
+    axles: z.array(stabilizer_axle_schema).optional(),
+    vehicle: stabilizer_vehicle_schema.optional()
+}).strict();

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

@@ -20,17 +20,61 @@ 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>>;
+                    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>;
-    original_input: z.ZodOptional<z.ZodUnknown>;
-    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    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>>;
 }, 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;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;AAOvB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQlC,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,
-    original_input: z.unknown().optional(),
-    config: z.record(z.string(), z.unknown()).optional()
+    config: stabilizer_config_schema.optional()
 }).strict().superRefine((input_data, context) => {
     add_waypoint_validation_issues(input_data.cargo_state, context);
 });

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

@@ -0,0 +1,25 @@
+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>;
+    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>;
+export type StabilizerItem = z.infer<typeof stabilizer_item_schema>;
+//# sourceMappingURL=stabilizer_item_schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stabilizer_item_schema.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/stabilizer_item_schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;kBAqBxB,CAAA;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+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(),
+    tie_ratio_orientation: z.string().optional(),
+    family: z.string().optional(),
+    supported_families: z.array(z.string()).optional(),
+    constraint: z.string().optional(),
+    stack_families: z.boolean().optional(),
+    stack_same_item: z.boolean().optional(),
+    stack_same_area: z.boolean().optional(),
+    stacking_unit: z.string().optional(),
+    supported_weight: z.number().optional(),
+    priority: z.number().optional()
+}).strict();

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

@@ -19,14 +19,43 @@ 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>>;
+                    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>;
     messages: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
@@ -55,14 +84,43 @@ 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>>;
+                    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>;
     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/uniquify_contract_item_ids.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Makes contract item_id unique when the same SKU id repeats.
+ * Duplicate catalog ids receive a `#occurrence` suffix on `item_id`.
+ * @param items - Mapped contract items.
+ * @returns Items with unique `item_id` values.
+ */
+export declare function uniquify_contract_item_ids(items: unknown[]): unknown[];
+/**
+ * Removes a numeric `#occurrence` suffix added by uniquify.
+ * @param item_id - Possibly uniquified item id.
+ * @returns Original item id.
+ */
+export declare function strip_uniquify_suffix(item_id: string): string;
+//# sourceMappingURL=uniquify_contract_item_ids.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uniquify_contract_item_ids.d.ts","sourceRoot":"","sources":["../../../../src/core/validation/contract/uniquify_contract_item_ids.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAKtE;AA0CD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAa7D"}

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

@@ -0,0 +1,54 @@
+import { is_record } from './wire_mapper_record_utils.js';
+/**
+ * Makes contract item_id unique when the same SKU id repeats.
+ * Duplicate catalog ids receive a `#occurrence` suffix on `item_id`.
+ * @param items - Mapped contract items.
+ * @returns Items with unique `item_id` values.
+ */
+export function uniquify_contract_item_ids(items) {
+    const counts = count_item_ids(items);
+    const seen = new Map();
+    return items.map(item => uniquify_one_item(item, counts, seen));
+}
+function count_item_ids(items) {
+    const counts = new Map();
+    for (const item of items) {
+        const item_id = read_item_id(item);
+        if (item_id === undefined) {
+            continue;
+        }
+        counts.set(item_id, (counts.get(item_id) ?? 0) + 1);
+    }
+    return counts;
+}
+function uniquify_one_item(item, counts, seen) {
+    const item_id = read_item_id(item);
+    if (item_id === undefined || (counts.get(item_id) ?? 0) <= 1 || !is_record(item)) {
+        return item;
+    }
+    const occurrence = seen.get(item_id) ?? 0;
+    seen.set(item_id, occurrence + 1);
+    return { ...item, item_id: `${item_id}#${occurrence}` };
+}
+function read_item_id(item) {
+    if (!is_record(item) || typeof item.item_id !== 'string') {
+        return undefined;
+    }
+    return item.item_id;
+}
+/**
+ * Removes a numeric `#occurrence` suffix added by uniquify.
+ * @param item_id - Possibly uniquified item id.
+ * @returns Original item id.
+ */
+export function strip_uniquify_suffix(item_id) {
+    const index = item_id.lastIndexOf('#');
+    if (index < 0) {
+        return item_id;
+    }
+    const suffix = item_id.slice(index + 1);
+    if (!/^\d+$/.test(suffix)) {
+        return item_id;
+    }
+    return item_id.slice(0, index);
+}

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

@@ -12,8 +12,9 @@ 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.$strip>;
+}, z.core.$strict>;
 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;;;;;;;;;;;;;;;iBAanC,CAAA;AAEF,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;;;;;;;;;;;;;;;;kBAc1B,CAAA;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA"}

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

@@ -11,6 +11,7 @@ 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,3 +1,4 @@
+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';
@@ -6,21 +7,19 @@ 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 = {
-    status: 'success';
-    data: unknown;
-    messages: string[];
-} | {
-    status: 'error';
-    data: string;
-    messages: string[];
-};
+export type StabilizerWireResponse = StabilizerResponse;
 /**
- * Stabilizes cargo by reordering loose items (legacy CM-compatible response).
+ * Parses unknown wire or English input, then runs the typed stabilizer.
  * @param input - Cargo-movement wire payload or English contract input.
- * @returns Success or error response with CM wire cargo_state on success.
+ * @returns Success or error response with typed cargo_state on success.
  */
-export declare function stabilize(input: unknown): Promise<StabilizerWireResponse>;
+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 { 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":"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"}
+{"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"}

package/build/index.js

@@ -1,7 +1,7 @@
 import { Logger } from '@jetta/logger';
-import { run_stabilizer_flow_from_unknown } from './core/orchestration/StabilizerFlow.js';
+import { run_stabilizer_flow } from './core/orchestration/StabilizerFlow.js';
 import { stabilizer_logger } from './core/logging/stabilizer_logger.js';
-import { map_contract_to_wire_output, parse_stabilizer_output } from './core/validation/contract/index.js';
+import { parse_stabilizer_input, 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,13 +11,36 @@ export { parse_stabilizer_input, safe_parse_stabilizer_input, parse_stabilizer_o
 const messages = [];
 const UNKNOWN_IDENTITY = 'UNKNOWN';
 /**
- * Stabilizes cargo by reordering loose items (legacy CM-compatible response).
+ * Parses unknown wire or English input, then runs the typed stabilizer.
  * @param input - Cargo-movement wire payload or English contract input.
- * @returns Success or error response with CM wire cargo_state on success.
+ * @returns Success or error response with typed 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, () => run_stabilize(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);
+    }
 }
 function read_stabilizer_identity(input) {
     if (typeof input !== 'object' || input === null) {
@@ -29,17 +52,6 @@ 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',
@@ -50,11 +62,7 @@ function build_success_response(cargo_state) {
     if (validated.status !== 'success') {
         throw new Error('Expected success response after stabilizer flow');
     }
-    return {
-        status: 'success',
-        data: map_contract_to_wire_output(validated.data),
-        messages: validated.messages
-    };
+    return validated;
 }
 function build_error_response(err) {
     stabilizer_logger.warn('cargo-stabilizer finished with error');