@jetta/axle-load-calculator 0.1.3

package/build/core/physics/transports/tare/bitrem_axle_weight_split.d.ts

@@ -0,0 +1,22 @@
+import type { AxleRecord } from '../axle_record.js';
+export type BitremAxleSplit = {
+    mult: number;
+    on_axle_3: boolean;
+};
+/**
+ * @param first_proportion - First proportion from splitter.
+ * @param second_proportion - Second proportion from splitter.
+ * @returns Multiplier and target axle flag.
+ */
+export declare function compute_bitrem_axle_split(first_proportion: number, second_proportion: number): BitremAxleSplit;
+export type BitremAxleSplitTarget = {
+    old: AxleRecord;
+    axle_3: AxleRecord;
+    axle_4: AxleRecord;
+    split: BitremAxleSplit;
+};
+/**
+ * @param target - Axles and split multipliers.
+ */
+export declare function apply_bitrem_axle_split(target: BitremAxleSplitTarget): void;
+//# sourceMappingURL=bitrem_axle_weight_split.d.ts.map

package/build/core/physics/transports/tare/bitrem_axle_weight_split.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitrem_axle_weight_split.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/tare/bitrem_axle_weight_split.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAEnD,MAAM,MAAM,eAAe,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,OAAO,CAAA;CACrB,CAAA;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACrC,gBAAgB,EAAE,MAAM,EACxB,iBAAiB,EAAE,MAAM,GAC1B,eAAe,CAYjB;AAED,MAAM,MAAM,qBAAqB,GAAG;IAChC,GAAG,EAAE,UAAU,CAAA;IACf,MAAM,EAAE,UAAU,CAAA;IAClB,MAAM,EAAE,UAAU,CAAA;IAClB,KAAK,EAAE,eAAe,CAAA;CACzB,CAAA;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,qBAAqB,GAAG,IAAI,CAe3E"}

package/build/core/physics/transports/tare/bitrem_axle_weight_split.js

@@ -0,0 +1,32 @@
+/**
+ * @param first_proportion - First proportion from splitter.
+ * @param second_proportion - Second proportion from splitter.
+ * @returns Multiplier and target axle flag.
+ */
+export function compute_bitrem_axle_split(first_proportion, second_proportion) {
+    const diff = first_proportion - second_proportion;
+    if (diff > 0) {
+        return { mult: 0.17 + 1 / (Math.abs(diff) + 2), on_axle_3: true };
+    }
+    if (diff < 0) {
+        return { mult: -0.17 + 1 / (Math.abs(diff) + 2), on_axle_3: false };
+    }
+    return { mult: 0.5, on_axle_3: true };
+}
+/**
+ * @param target - Axles and split multipliers.
+ */
+export function apply_bitrem_axle_split(target) {
+    const { old, axle_3, axle_4, split } = target;
+    if (split.on_axle_3) {
+        axle_3.max_supported_weight = old.max_supported_weight * split.mult;
+        axle_4.max_supported_weight = old.max_supported_weight - axle_3.max_supported_weight;
+        axle_3.tare = old.tare * split.mult;
+        axle_4.tare = old.tare - axle_3.tare;
+        return;
+    }
+    axle_4.max_supported_weight = old.max_supported_weight * split.mult;
+    axle_3.max_supported_weight = old.max_supported_weight - axle_4.max_supported_weight;
+    axle_4.tare = old.tare * split.mult;
+    axle_3.tare = old.tare - axle_4.tare;
+}

package/build/core/physics/transports/transport.d.ts

@@ -0,0 +1,33 @@
+import { type VehicleTypeCode } from '../../contracts/vehicle_type.js';
+import type { TransportRecord } from '../../contracts/transport_record.js';
+import { AxleManager } from './axle_manager.js';
+import { ContainerRecord } from './container_record.js';
+/**
+ * Parsed transport matching jettainterface.Transport behavior used by axleweight.
+ */
+export declare class Transport {
+    id: string;
+    containers: Map<number, ContainerRecord>;
+    amount: number;
+    supported_weight: number;
+    tare: number;
+    axle_manager: AxleManager;
+    first_axle_distance: number;
+    vehicle_type: VehicleTypeCode;
+    vehicle_version: number;
+    suspension_type: string | null;
+    /**
+     * @param transport_data - Raw transport dict.
+     */
+    constructor(transport_data: TransportRecord);
+    /**
+     * @returns Sorted container sequence indexes.
+     */
+    list_containers_sequence_indexes(): number[];
+    /**
+     * @param sequence_index - Container sequence.
+     * @returns Container record.
+     */
+    get_container_by_sequence_index(sequence_index: number): ContainerRecord;
+}
+//# sourceMappingURL=transport.d.ts.map

package/build/core/physics/transports/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/transports/transport.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,eAAe,EAAE,MAAM,iCAAiC,CAAA;AAEpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAA;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAEvD;;GAEG;AACH,qBAAa,SAAS;IAElB,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IACxC,MAAM,EAAE,MAAM,CAAA;IACd,gBAAgB,EAAE,MAAM,CAAA;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,WAAW,CAAA;IACzB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,YAAY,EAAE,eAAe,CAAA;IAC7B,eAAe,EAAE,MAAM,CAAA;IACvB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAE9B;;OAEG;gBACS,cAAc,EAAE,eAAe;IAe3C;;OAEG;IACH,gCAAgC,IAAI,MAAM,EAAE;IAK5C;;;OAGG;IACH,+BAA+B,CAAC,cAAc,EAAE,MAAM,GAAG,eAAe;CAS3E"}

package/build/core/physics/transports/transport.js

@@ -0,0 +1,110 @@
+import { WIRE_FLAGS } from '../../contracts/wire_flags.js';
+import { VEHICLE_TYPE } from '../../contracts/vehicle_type.js';
+import { VEHICLE_VERSION } from '../../contracts/vehicle_version.js';
+import { AxleManager } from './axle_manager.js';
+import { ContainerRecord } from './container_record.js';
+/**
+ * Parsed transport matching jettainterface.Transport behavior used by axleweight.
+ */
+export class Transport {
+    id;
+    containers;
+    amount;
+    supported_weight;
+    tare;
+    axle_manager;
+    first_axle_distance;
+    vehicle_type;
+    vehicle_version;
+    suspension_type;
+    /**
+     * @param transport_data - Raw transport dict.
+     */
+    constructor(transport_data) {
+        this.id = String(transport_data[WIRE_FLAGS.TRANSPORT_ID]);
+        this.containers = read_containers(transport_data);
+        this.amount = Number(transport_data[WIRE_FLAGS.AMOUNT] ?? 0);
+        this.supported_weight = Number(transport_data[WIRE_FLAGS.SUPPORTED_WEIGHT]);
+        this.tare = Number(transport_data.tara ?? 0);
+        this.axle_manager = new AxleManager(transport_data);
+        this.first_axle_distance = Number(transport_data[WIRE_FLAGS.FIRST_AXLE_DISTANCE] ?? 0);
+        this.vehicle_type = read_vehicle_type(transport_data);
+        this.vehicle_version = read_vehicle_version(transport_data);
+        this.suspension_type = read_suspension_type(transport_data);
+    }
+    /**
+     * @returns Sorted container sequence indexes.
+     */
+    list_containers_sequence_indexes() {
+        return [...this.containers.keys()].sort((left, right) => left - right);
+    }
+    /**
+     * @param sequence_index - Container sequence.
+     * @returns Container record.
+     */
+    get_container_by_sequence_index(sequence_index) {
+        const container = this.containers.get(sequence_index);
+        if (!container) {
+            throw new Error(`Container sequence ${sequence_index} not found`);
+        }
+        return container;
+    }
+}
+/**
+ * @param transport_data - Raw transport dict.
+ * @returns Containers keyed by sequence.
+ */
+function read_containers(transport_data) {
+    const map = new Map();
+    const list = transport_data[WIRE_FLAGS.CONTAINERS];
+    if (!Array.isArray(list)) {
+        return map;
+    }
+    for (const entry of list) {
+        const container = new ContainerRecord(entry);
+        map.set(container.sequence_index, container);
+    }
+    return map;
+}
+/**
+ * @param transport_data - Raw transport dict.
+ * @returns Vehicle type code.
+ */
+function read_vehicle_type(transport_data) {
+    const raw = transport_data[WIRE_FLAGS.VEHICLE_TYPE];
+    if (raw === undefined || raw === null) {
+        return VEHICLE_TYPE.CONTAINER;
+    }
+    return Number(raw);
+}
+/**
+ * @param transport_data - Raw transport dict.
+ * @returns Resolved vehicle version code.
+ */
+function read_vehicle_version(transport_data) {
+    const vehicle_type = read_vehicle_type(transport_data);
+    const version_code = Number(transport_data[WIRE_FLAGS.VEHICLE_VERSION] ?? 0);
+    if (vehicle_type === VEHICLE_TYPE.CAMINHAO && version_code === 4) {
+        return VEHICLE_VERSION.CAMINHAO_BITRUCK;
+    }
+    if (vehicle_type === VEHICLE_TYPE.SEMIREBOQUE) {
+        if (version_code === 5 || version_code === 7) {
+            return VEHICLE_VERSION.SEMIREBOQUE_QUAD;
+        }
+        if (version_code === 6) {
+            return VEHICLE_VERSION.SEMIREBOQUE_BITRUCK;
+        }
+    }
+    return VEHICLE_VERSION.DEFAULT;
+}
+/**
+ * @param transport_data - Raw transport dict.
+ * @returns Suspension wire string or null.
+ */
+function read_suspension_type(transport_data) {
+    const raw = transport_data[WIRE_FLAGS.SUSPENSION_TYPE];
+    if (raw === undefined || raw === null) {
+        return null;
+    }
+    return String(raw);
+}

package/build/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Calculates loaded cargo weight per axle for each transport in the payload.
+ * Same contract as WeightByAxisTask.run() in ms-faixas-porcentuais.
+ * @param json_data - Raw JSON string with `{ envs, config? }`.
+ * @returns JSON string with `envs` and axle weights, or error payload.
+ */
+export declare function calculate_weight_on_axles_physics(json_data: string): string;
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAG3E"}

package/build/index.js

@@ -0,0 +1,10 @@
+import { run_weight_by_axis_task } from './core/orchestration/weight_by_axis_task.js';
+/**
+ * Calculates loaded cargo weight per axle for each transport in the payload.
+ * Same contract as WeightByAxisTask.run() in ms-faixas-porcentuais.
+ * @param json_data - Raw JSON string with `{ envs, config? }`.
+ * @returns JSON string with `envs` and axle weights, or error payload.
+ */
+export function calculate_weight_on_axles_physics(json_data) {
+    return run_weight_by_axis_task(json_data);
+}

package/eslint.config.js

@@ -0,0 +1,51 @@
+import eslintPluginTs from '@typescript-eslint/eslint-plugin'
+import parserTs from '@typescript-eslint/parser'
+
+const shared_parser = {
+    parser: parserTs,
+    parserOptions: {
+        project: './tsconfig.eslint.json',
+        sourceType: 'module',
+        ecmaVersion: 2020
+    }
+}
+
+const production_rules = {
+    indent: ['error', 4, { SwitchCase: 1 }],
+    semi: ['error', 'never'],
+    curly: ['error', 'all'],
+    quotes: ['error', 'single', { allowTemplateLiterals: true }],
+    'no-unused-vars': 'off',
+    'no-trailing-spaces': ['error'],
+    'brace-style': ['error', 'allman'],
+    'keyword-spacing': ['error', { before: true, after: true }],
+    'max-lines': ['error', { max: 125, skipBlankLines: true, skipComments: true }],
+    'max-lines-per-function': ['error', { max: 25, skipBlankLines: true, skipComments: true }],
+    'max-params': ['error', 3],
+    'space-infix-ops': ['error', { int32Hint: false }],
+    'max-statements-per-line': ['error', { max: 2 }],
+    '@typescript-eslint/no-unused-vars': [
+        'error',
+        { argsIgnorePattern: '^_', varsIgnorePattern: '^_' }
+    ],
+    '@typescript-eslint/naming-convention': [
+        'error',
+        { selector: 'class', format: ['PascalCase'] },
+        { selector: 'function', format: ['snake_case'] },
+        { selector: 'variable', format: ['snake_case'] },
+        {
+            selector: 'variable',
+            modifiers: ['const'],
+            format: ['snake_case', 'UPPER_CASE']
+        }
+    ]
+}
+
+export default [
+    {
+        files: ['src/**/*.ts'],
+        languageOptions: shared_parser,
+        plugins: { '@typescript-eslint': eslintPluginTs },
+        rules: production_rules
+    }
+]

package/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "@jetta/axle-load-calculator",
+    "version": "0.1.3",
+    "description": "Merged weight_by_axis physics and orchestration library",
+    "main": "build/index.js",
+    "types": "build/index.d.ts",
+    "type": "module",
+    "private": false,
+    "scripts": {
+        "prebuild": "rm -rf build/* && npm ci",
+        "test": "tsx ./node_modules/mocha/bin/mocha \"test/**/*.ts\"",
+        "build": "tsc",
+        "lint": "eslint src --ext .ts",
+        "lint:fix": "eslint src --fix",
+        "audit": "npm audit --omit=dev",
+        "preversion": "git fetch --prune --tags",
+        "version": "npm run build",
+        "postversion": "git push origin HEAD --follow-tags",
+        "publish:alpha": "npm version --tag-version-prefix=alpha-v",
+        "publish:stable": "npm version",
+        "prerelease:alpha": "npm version prerelease --tag-version-prefix=alpha-v",
+        "coverage": "c8 --reporter=html --reporter=text npm run test"
+    },
+    "dependencies": {
+        "zod": "^3.24.0"
+    },
+    "devDependencies": {
+        "@types/chai": "^5.2.3",
+        "@types/mocha": "^10.0.10",
+        "@types/node": "^25.9.1",
+        "@typescript-eslint/eslint-plugin": "^8.59.4",
+        "@typescript-eslint/parser": "^8.59.4",
+        "chai": "^6.2.2",
+        "mocha": "^11.7.6",
+        "tsx": "^4.22.3",
+        "typescript": "^6.0.3"
+    }
+}

package/src/core/contracts/chassi_reference.ts

@@ -0,0 +1,7 @@
+export const CHASSI_REFERENCE = Object.freeze({
+    GROUPER_1: 'GROUPER_1',
+    GROUPER_2: 'GROUPER_2',
+    TRACTOR: 'TRACTOR'
+})
+
+export type ChassiReference = typeof CHASSI_REFERENCE[keyof typeof CHASSI_REFERENCE]

package/src/core/contracts/ms_faixas_contract.ts

@@ -0,0 +1,114 @@
+import { AllocatedItem } from '../physics/items/allocated_item.js'
+import { AllocatedItemManager } from '../physics/items/allocated_item_manager.js'
+import { ItemTemplates } from '../physics/items/item_templates.js'
+
+const TRANSPORT_LIST_FLAG = 'envs'
+const CONTAINERS_FLAG = 'containers'
+const ITEM_LIST_FLAG = 'items'
+
+/**
+ * Parses ms-faixas `{ envs: [...] }` payloads for axleweight services.
+ */
+export class MsFaixasContract
+{
+    transport_data: Record<string, unknown>
+    allocated_items_by_sequence_id: Record<number, AllocatedItemManager>
+
+    /**
+     * @param ms_faixas_input - Request with envs array.
+     */
+    constructor(ms_faixas_input: Record<string, unknown>)
+    {
+        const envs = ms_faixas_input[TRANSPORT_LIST_FLAG] as Record<string, unknown>[]
+        this.transport_data = { ...envs[0] }
+        this.allocated_items_by_sequence_id = build_allocated_items(this.transport_data)
+        strip_items_from_transport(this.transport_data)
+    }
+}
+
+/**
+ * @param transport_data - Env vehicle data.
+ * @returns Allocated items keyed by sequence index.
+ */
+function build_allocated_items(
+    transport_data: Record<string, unknown>
+): Record<number, AllocatedItemManager>
+{
+    const templates = build_item_templates(transport_data)
+    const result: Record<number, AllocatedItemManager> = {}
+    const containers = transport_data[CONTAINERS_FLAG] as Record<string, unknown>[]
+    for (let index = 0; index < containers.length; index++)
+    {
+        const container = containers[index]
+        const sequence = Number(container.sequencia ?? index + 1)
+        result[sequence] = build_container_items(templates, container)
+    }
+    return result
+}
+
+/**
+ * @param transport_data - Env vehicle.
+ * @returns Item templates from all container items.
+ */
+function build_item_templates(transport_data: Record<string, unknown>): ItemTemplates
+{
+    const templates = new ItemTemplates()
+    const containers = transport_data[CONTAINERS_FLAG] as Record<string, unknown>[]
+    for (const container of containers)
+    {
+        const items = container[ITEM_LIST_FLAG] as Record<string, unknown>[] | undefined
+        if (!items)
+        {
+            continue
+        }
+        for (const item of items)
+        {
+            templates.add_template_from_item_data(item)
+        }
+    }
+    return templates
+}
+
+/**
+ * @param templates - Shared templates.
+ * @param container - Container JSON.
+ * @returns Allocated item manager for container.
+ */
+function build_container_items(
+    templates: ItemTemplates,
+    container: Record<string, unknown>
+): AllocatedItemManager
+{
+    const manager = new AllocatedItemManager(templates)
+    const items = container[ITEM_LIST_FLAG] as Record<string, unknown>[] | undefined
+    if (!items)
+    {
+        return manager
+    }
+    const allocated: AllocatedItem[] = []
+    for (const item_data of items)
+    {
+        const item_id = String(item_data.id ?? item_data._id)
+        const template_index = templates.index_of(item_id)
+        const item = new AllocatedItem(templates, template_index)
+        item.xi = Number(item_data.x ?? 0)
+        item.yi = Number(item_data.y ?? 0)
+        // Ms-faixas stores longitudinal position in `y` (jettainterface maps y→chassis z).
+        item.zi = Number(item_data.y ?? item_data.z ?? 0)
+        allocated.push(item)
+    }
+    manager.add_allocated_items(allocated)
+    return manager
+}
+
+/**
+ * @param transport_data - Env vehicle to strip item lists from.
+ */
+function strip_items_from_transport(transport_data: Record<string, unknown>): void
+{
+    const containers = transport_data[CONTAINERS_FLAG] as Record<string, unknown>[]
+    for (const container of containers)
+    {
+        delete container[ITEM_LIST_FLAG]
+    }
+}

package/src/core/contracts/rotation_enum.ts

@@ -0,0 +1,11 @@
+/** Cargo rotation positions (carrierinterface RotationEnum). */
+export const ROTATION = Object.freeze({
+    POS1: 1,
+    POS2: 2,
+    POS3: 3,
+    POS4: 4,
+    POS5: 5,
+    POS6: 6
+})
+
+export type RotationCode = typeof ROTATION[keyof typeof ROTATION]

package/src/core/contracts/suspension_type.ts

@@ -0,0 +1,4 @@
+export const SUSPENSION_TYPE = Object.freeze({
+    PNEUMATICA: 'Pneumatica',
+    MECANICA: 'Mecanica'
+})

package/src/core/contracts/transport_record.ts

@@ -0,0 +1,4 @@
+/**
+ * Raw transport dict as received by axle-weight services (jettainterface wire format).
+ */
+export type TransportRecord = Record<string, unknown>

package/src/core/contracts/vehicle_type.ts

@@ -0,0 +1,12 @@
+export const VEHICLE_TYPE = Object.freeze({
+    CONTAINER: 0,
+    SEMIREBOQUE: 1,
+    BITREM: 2,
+    RODOTREM: 3,
+    VANDERLEIA: 5,
+    REBAIXADO: 6,
+    CAMINHAO: 7,
+    VUC: 8
+})
+
+export type VehicleTypeCode = typeof VEHICLE_TYPE[keyof typeof VEHICLE_TYPE]

package/src/core/contracts/vehicle_version.ts

@@ -0,0 +1,7 @@
+export const VEHICLE_VERSION = Object.freeze({
+    DEFAULT: 0,
+    CAMINHAO_BITRUCK: 4,
+    SEMIREBOQUE_QUAD: 5,
+    SEMIREBOQUE_BITRUCK: 6,
+    SEMIREBOQUE_QUAD_ALT: 7
+})

package/src/core/contracts/wire_flags.ts

@@ -0,0 +1,26 @@
+export const WIRE_FLAGS = Object.freeze({
+    TRANSPORT_ID: '_id',
+    CONTAINERS: 'containers',
+    AXLE_LIST: 'eixos',
+    MAIN_PIN_DISTANCE: 'distPinoRei',
+    CONTAINER_DISTANCE_AHEAD: 'containerDistanceAhead',
+    FIRST_AXLE_DISTANCE: 'primeiroEixo',
+    VEHICLE_TYPE: 'tipoVeiculo',
+    VEHICLE_VERSION: 'tipoVersao',
+    SUSPENSION_TYPE: 'tipoSuspensao',
+    SUPPORTED_WEIGHT: 'pesoDeCarga',
+    AMOUNT: 'qtd',
+    LENGTH: 'comprimento',
+    WIDTH: 'largura',
+    HEIGHT: 'altura',
+    SEQUENCE: 'sequencia',
+    GROUPER: 'grouper',
+    DISTANCE_FROM_ORIGIN: 'distanciaOrigem',
+    MAX_SUPPORTED_WEIGHT: 'pesoMaxSuportado',
+    SEQUENCE_CONTAINER: 'sequenciaContainer',
+    DNIT_WEIGHT: 'pesoDnit',
+    TARE: 'tara',
+    CM_SERVICE_CENTER_OF_MASS: 'center_of_mass',
+    CM_SERVICE_Z: 'z_position',
+    CM_SERVICE_MASS: 'mass'
+})

package/src/core/math/float_tools.ts

@@ -0,0 +1,17 @@
+/**
+ * Converts nested float lists to a plain number matrix (NumPy float_list_to_np_array equivalent).
+ * @param float_list - Nested numeric list.
+ * @returns Plain number matrix or vector.
+ */
+export function float_list_to_matrix(float_list: number[] | number[][]): number[] | number[][]
+{
+    if (float_list.length === 0)
+    {
+        return []
+    }
+    if (typeof float_list[0] === 'number')
+    {
+        return float_list as number[]
+    }
+    return (float_list as number[][]).map((row) => row.map((value) => Number(value)))
+}

package/src/core/math/gaussian_elimination.ts

@@ -0,0 +1,104 @@
+/**
+ * Solves Ax = b for square matrix A using Gaussian elimination (NumPy-compatible order).
+ * @param matrix - Coefficient matrix row-major n×n.
+ * @param independent - Right-hand side vector length n.
+ * @returns Solution vector length n.
+ */
+export function solve_linear_system(matrix: number[][], independent: number[]): number[]
+{
+    const size = independent.length
+    const augmented = matrix.map((row, row_index) => [...row, independent[row_index]])
+    for (let pivot_column = 0; pivot_column < size; pivot_column++)
+    {
+        forward_eliminate(augmented, pivot_column, size)
+    }
+    return back_substitute(augmented, size)
+}
+
+/**
+ * @param augmented - Augmented matrix.
+ * @param pivot_column - Current pivot column index.
+ * @param size - System size.
+ */
+function forward_eliminate(augmented: number[][], pivot_column: number, size: number): void
+{
+    const pivot_row = find_pivot_row(augmented, pivot_column, size)
+    swap_rows(augmented, pivot_row, pivot_column)
+    eliminate_below(augmented, pivot_column, size)
+}
+
+/**
+ * @param augmented - Augmented matrix.
+ * @param pivot_column - Pivot column.
+ * @param size - System size.
+ * @returns Row index with largest absolute pivot.
+ */
+function find_pivot_row(augmented: number[][], pivot_column: number, size: number): number
+{
+    let pivot_row = pivot_column
+    let max_abs = Math.abs(augmented[pivot_column][pivot_column])
+    for (let row = pivot_column + 1; row < size; row++)
+    {
+        const candidate = Math.abs(augmented[row][pivot_column])
+        if (candidate > max_abs)
+        {
+            max_abs = candidate
+            pivot_row = row
+        }
+    }
+    return pivot_row
+}
+
+/**
+ * @param augmented - Augmented matrix.
+ * @param pivot_row - Row to swap to pivot position.
+ * @param pivot_column - Pivot column index.
+ */
+function swap_rows(augmented: number[][], pivot_row: number, pivot_column: number): void
+{
+    if (pivot_row === pivot_column)
+    {
+        return
+    }
+    const temp = augmented[pivot_column]
+    augmented[pivot_column] = augmented[pivot_row]
+    augmented[pivot_row] = temp
+}
+
+/**
+ * @param augmented - Augmented matrix.
+ * @param pivot_column - Pivot column index.
+ * @param size - System size.
+ */
+function eliminate_below(augmented: number[][], pivot_column: number, size: number): void
+{
+    const pivot_value = augmented[pivot_column][pivot_column]
+    for (let row = pivot_column + 1; row < size; row++)
+    {
+        const factor = augmented[row][pivot_column] / pivot_value
+        for (let column = pivot_column; column <= size; column++)
+        {
+            augmented[row][column] -= factor * augmented[pivot_column][column]
+        }
+    }
+}
+
+/**
+ * @param augmented - Row-echelon augmented matrix.
+ * @param size - System size.
+ * @returns Solution vector.
+ */
+function back_substitute(augmented: number[][], size: number): number[]
+{
+    const solution = new Array<number>(size).fill(0)
+    for (let row = size - 1; row >= 0; row--)
+    {
+        let sum = augmented[row][size]
+        for (let column = row + 1; column < size; column++)
+        {
+            sum -= augmented[row][column] * solution[column]
+        }
+        solution[row] = sum / augmented[row][row]
+    }
+    return solution
+}