@jetta/cargo-stabilizer 0.1.0-10

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

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

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

@@ -0,0 +1,2 @@
+export declare function map_cargo_state_to_contract(value: unknown): unknown;
+//# sourceMappingURL=map_wire_input_to_contract_shape.d.ts.map

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

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

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

@@ -0,0 +1,60 @@
+import { CONTAINER_WIRE_TO_CONTRACT, ENV_WIRE_TO_CONTRACT } from './cargo_movement_wire_field_map.js';
+import { map_wire_item_to_contract } from './map_wire_item_to_contract.js';
+import { is_record, omit_keys, pick_keys, rename_keys } from './wire_mapper_record_utils.js';
+const CONTAINER_CONTRACT_KEYS = ['sequence', 'width', 'height', 'length'];
+const ENV_CONTRACT_KEYS = ['axles'];
+export function map_cargo_state_to_contract(value) {
+    if (!is_record(value)) {
+        return value;
+    }
+    const mapped = {};
+    if (value.config !== undefined) {
+        mapped.config = value.config;
+    }
+    if (Array.isArray(value.envs)) {
+        mapped.envs = value.envs.map(map_env_to_contract);
+    }
+    return mapped;
+}
+function map_env_to_contract(value) {
+    if (!is_record(value)) {
+        return value;
+    }
+    const mapped = rename_keys(value, ENV_WIRE_TO_CONTRACT);
+    if (Array.isArray(value.containers)) {
+        mapped.containers = value.containers.map(map_container_to_contract);
+    }
+    return pick_env_contract_keys(mapped);
+}
+function map_container_to_contract(value) {
+    if (!is_record(value)) {
+        return value;
+    }
+    const mapped = rename_keys(value, CONTAINER_WIRE_TO_CONTRACT);
+    if (Array.isArray(value.items)) {
+        mapped.items = value.items.map(map_wire_item_to_contract);
+    }
+    return pick_container_contract_keys(mapped);
+}
+function pick_container_contract_keys(source) {
+    const picked = pick_keys(source, CONTAINER_CONTRACT_KEYS);
+    if (Array.isArray(source.items)) {
+        picked.items = source.items;
+    }
+    const attributes = omit_keys(source, [...CONTAINER_CONTRACT_KEYS, 'items']);
+    if (Object.keys(attributes).length > 0) {
+        picked.attributes = attributes;
+    }
+    return picked;
+}
+function pick_env_contract_keys(source) {
+    const picked = pick_keys(source, ENV_CONTRACT_KEYS);
+    if (Array.isArray(source.containers)) {
+        picked.containers = source.containers;
+    }
+    const vehicle = omit_keys(source, [...ENV_CONTRACT_KEYS, 'containers']);
+    if (Object.keys(vehicle).length > 0) {
+        picked.vehicle = vehicle;
+    }
+    return picked;
+}

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

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

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

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

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

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

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

@@ -0,0 +1,48 @@
+import { format_zod_error } from './format_zod_error.js';
+import { type StabilizerInput } from './stabilizer_input_schema.js';
+/**
+ * Safely parses stabilizer input after wire mapping.
+ * @param input_data - Unknown wire payload.
+ * @returns Zod safe parse result.
+ */
+export declare function safe_parse_stabilizer_input(input_data: unknown): import("zod").ZodSafeParseResult<{
+    cargo_state: {
+        envs: {
+            containers: {
+                width: number;
+                height: number;
+                length: number;
+                items: {
+                    item_id: string;
+                    x: number;
+                    y: number;
+                    z: number;
+                    width: number;
+                    height: number;
+                    depth: number;
+                    group_id?: string | null | undefined;
+                    waypoint_id?: string | undefined;
+                    weight?: number | undefined;
+                    attributes?: Record<string, unknown> | undefined;
+                }[];
+                sequence?: number | undefined;
+                attributes?: Record<string, unknown> | undefined;
+            }[];
+            axles?: Record<string, unknown>[] | undefined;
+            vehicle?: Record<string, unknown> | undefined;
+        }[];
+        config?: Record<string, unknown> | undefined;
+    };
+    id?: string | number | undefined;
+    company?: string | number | undefined;
+    original_input?: unknown;
+    config?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Parses stabilizer input at the public boundary.
+ * @param input_data - Unknown wire payload.
+ * @returns Validated stabilizer input in English contract shape.
+ */
+export declare function parse_stabilizer_input(input_data: unknown): StabilizerInput;
+export { format_zod_error };
+//# sourceMappingURL=parse_stabilizer_input.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,26 @@
+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 { stabilizer_input_schema } from './stabilizer_input_schema.js';
+/**
+ * Safely parses stabilizer input after wire mapping.
+ * @param input_data - Unknown wire payload.
+ * @returns Zod safe parse result.
+ */
+export function safe_parse_stabilizer_input(input_data) {
+    const contract_payload = map_wire_input_to_contract(input_data);
+    return stabilizer_input_schema.safeParse(contract_payload);
+}
+/**
+ * Parses stabilizer input at the public boundary.
+ * @param input_data - Unknown wire payload.
+ * @returns Validated stabilizer input in English contract shape.
+ */
+export function parse_stabilizer_input(input_data) {
+    const result = safe_parse_stabilizer_input(input_data);
+    if (!result.success) {
+        throw new InvalidStabilizerInputError(format_zod_error(result.error));
+    }
+    return result.data;
+}
+export { format_zod_error };

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

@@ -0,0 +1,50 @@
+import { format_zod_error } from './format_zod_error.js';
+import { type StabilizerResponse } from './stabilizer_output_schema.js';
+/**
+ * Safely parses stabilizer output envelope.
+ * @param output_data - Unknown response payload.
+ * @returns Zod safe parse result.
+ */
+export declare function safe_parse_stabilizer_output(output_data: unknown): import("zod").ZodSafeParseResult<{
+    status: "success";
+    data: {
+        envs: {
+            containers: {
+                width: number;
+                height: number;
+                length: number;
+                items: {
+                    item_id: string;
+                    x: number;
+                    y: number;
+                    z: number;
+                    width: number;
+                    height: number;
+                    depth: number;
+                    group_id?: string | null | undefined;
+                    waypoint_id?: string | undefined;
+                    weight?: number | undefined;
+                    attributes?: Record<string, unknown> | undefined;
+                }[];
+                sequence?: number | undefined;
+                attributes?: Record<string, unknown> | undefined;
+            }[];
+            axles?: Record<string, unknown>[] | undefined;
+            vehicle?: Record<string, unknown> | undefined;
+        }[];
+        config?: Record<string, unknown> | undefined;
+    };
+    messages: string[];
+} | {
+    status: "error";
+    data: string;
+    messages: string[];
+}>;
+/**
+ * Parses stabilizer output at the public boundary.
+ * @param output_data - Unknown response payload.
+ * @returns Validated stabilizer response in English contract shape.
+ */
+export declare function parse_stabilizer_output(output_data: unknown): StabilizerResponse;
+export { format_zod_error };
+//# sourceMappingURL=parse_stabilizer_output.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,24 @@
+import { InvalidStabilizerOutputError } from '../../exceptions/InvalidStabilizerOutputError.js';
+import { format_zod_error } from './format_zod_error.js';
+import { stabilizer_response_schema } from './stabilizer_output_schema.js';
+/**
+ * Safely parses stabilizer output envelope.
+ * @param output_data - Unknown response payload.
+ * @returns Zod safe parse result.
+ */
+export function safe_parse_stabilizer_output(output_data) {
+    return stabilizer_response_schema.safeParse(output_data);
+}
+/**
+ * Parses stabilizer output at the public boundary.
+ * @param output_data - Unknown response payload.
+ * @returns Validated stabilizer response in English contract shape.
+ */
+export function parse_stabilizer_output(output_data) {
+    const result = safe_parse_stabilizer_output(output_data);
+    if (!result.success) {
+        throw new InvalidStabilizerOutputError(format_zod_error(result.error));
+    }
+    return result.data;
+}
+export { format_zod_error };

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

@@ -0,0 +1,101 @@
+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 declare const stabilizer_cargo_state_schema: z.ZodObject<{
+    envs: z.ZodArray<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>>;
+    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.
+ * @param cargo_state - Parsed cargo state.
+ */
+export declare function validate_primary_env_waypoints(cargo_state: StabilizerCargoState): void;
+/**
+ * Adds waypoint validation issues to a Zod context.
+ * @param cargo_state - Cargo state being validated.
+ * @param context - Zod refinement context.
+ */
+export declare function add_waypoint_validation_issues(cargo_state: StabilizerCargoState, context: z.RefinementCtx): void;
+//# sourceMappingURL=stabilizer_domain_schema.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,64 @@
+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();
+export const stabilizer_cargo_state_schema = z.object({
+    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.
+ * @param cargo_state - Parsed cargo state.
+ */
+export function validate_primary_env_waypoints(cargo_state) {
+    const primary_env = cargo_state.envs[0];
+    const all_items = primary_env.containers.flatMap(container => container.items);
+    validate_waypoint_ids(all_items);
+}
+/**
+ * Adds waypoint validation issues to a Zod context.
+ * @param cargo_state - Cargo state being validated.
+ * @param context - Zod refinement context.
+ */
+export function add_waypoint_validation_issues(cargo_state, context) {
+    try {
+        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;
+        }
+    }
+}

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

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export declare const stabilizer_input_schema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    company: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    cargo_state: z.ZodObject<{
+        envs: z.ZodArray<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>>;
+        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>>;
+}, 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

@@ -0,0 +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"}

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+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()
+}).strict().superRefine((input_data, context) => {
+    add_waypoint_validation_issues(input_data.cargo_state, context);
+});

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

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+export declare const stabilizer_success_response_schema: z.ZodObject<{
+    status: z.ZodLiteral<"success">;
+    data: z.ZodObject<{
+        envs: z.ZodArray<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>>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+    messages: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const stabilizer_error_response_schema: z.ZodObject<{
+    status: z.ZodLiteral<"error">;
+    data: z.ZodString;
+    messages: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const stabilizer_response_schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"success">;
+    data: z.ZodObject<{
+        envs: z.ZodArray<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>>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+    messages: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"error">;
+    data: z.ZodString;
+    messages: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "status">;
+export type StabilizerSuccessResponse = z.infer<typeof stabilizer_success_response_schema>;
+export type StabilizerErrorResponse = z.infer<typeof stabilizer_error_response_schema>;
+export type StabilizerResponse = z.infer<typeof stabilizer_response_schema>;
+//# sourceMappingURL=stabilizer_output_schema.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { stabilizer_cargo_state_schema } from './stabilizer_domain_schema.js';
+export const stabilizer_success_response_schema = z.object({
+    status: z.literal('success'),
+    data: stabilizer_cargo_state_schema,
+    messages: z.array(z.string())
+}).strict();
+export const stabilizer_error_response_schema = z.object({
+    status: z.literal('error'),
+    data: z.string(),
+    messages: z.array(z.string())
+}).strict();
+export const stabilizer_response_schema = z.discriminatedUnion('status', [
+    stabilizer_success_response_schema,
+    stabilizer_error_response_schema
+]);