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

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"}

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

@@ -1,35 +1,11 @@
 import { z } from 'zod';
 import { MixedWaypointIdError } from '../../exceptions/MixedWaypointIdError.js';
 import { validate_waypoint_ids } from '../../waypoint/validate_waypoint_ids.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(),
-    attributes: z.record(z.string(), z.unknown()).optional()
-}).strict();
-export const stabilizer_container_schema = z.object({
-    sequence: z.number().optional(),
-    width: z.number().positive(),
-    height: z.number().positive(),
-    length: z.number().positive(),
-    items: z.array(stabilizer_item_schema),
-    attributes: z.record(z.string(), z.unknown()).optional()
-}).strict();
-export const stabilizer_env_schema = z.object({
-    containers: z.array(stabilizer_container_schema).min(1),
-    axles: z.array(z.record(z.string(), z.unknown())).optional(),
-    vehicle: z.record(z.string(), z.unknown()).optional()
-}).strict();
+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_cargo_state_schema = z.object({
-    envs: z.array(stabilizer_env_schema).min(1),
-    config: z.record(z.string(), z.unknown()).optional()
+    envs: z.array(stabilizer_env_schema).min(1)
 }).strict();
 /**
  * Validates waypoint consistency across all items in the primary env.
@@ -50,15 +26,17 @@ export function add_waypoint_validation_issues(cargo_state, context) {
         validate_primary_env_waypoints(cargo_state);
     }
     catch (error) {
-        if (error instanceof MixedWaypointIdError) {
-            context.addIssue({
-                code: 'custom',
-                message: error.message,
-                path: ['cargo_state', 'envs', 0]
-            });
-        }
-        else {
-            throw 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;
     }
+    throw error;
 }

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"}