vehicle-path2 1.0.15 → 2.1.0

package/dist/core/algorithms/pathFinding.d.ts

@@ -41,7 +41,7 @@ export declare function calculateBezierArcLength(bezier: BezierCurve, segments?:
  *
  * Effective range: [wheelbase, lineLength]
  */
-export declare function resolveFromLineOffset(line: Line, offset: number | undefined, isPercentage: boolean | undefined, defaultPercentage: number, wheelbase: number): number;
+export declare function resolveFromLineOffset(line: Line, offset: number | undefined, isPercentage: boolean | undefined, defaultPercentage: number, maxWheelbase: number): number;
 /**
  * Resolve offset untuk TO line (garis tujuan kurva)
  * - 0% → 0 (awal garis)
@@ -49,7 +49,7 @@ export declare function resolveFromLineOffset(line: Line, offset: number | undef
  *
  * Effective range: [0, lineLength - wheelbase]
  */
-export declare function resolveToLineOffset(line: Line, offset: number | undefined, isPercentage: boolean | undefined, defaultPercentage: number, wheelbase: number): number;
+export declare function resolveToLineOffset(line: Line, offset: number | undefined, isPercentage: boolean | undefined, defaultPercentage: number, maxWheelbase: number): number;
 /**
  * Membangun graph dari lines dan curves
  */

package/dist/core/algorithms/vehicleMovement.d.ts

@@ -55,6 +55,16 @@ export declare function calculateFrontAxlePosition(path: PathResult, rearSegment
     segmentIndex: number;
     segmentDistance: number;
 } | null;
+/**
+ * Hitung posisi awal semua axle dari posisi rearmost axle.
+ *
+ * @param lineId - Line ID tempat vehicle diinisialisasi
+ * @param rearOffset - Absolute offset axle paling belakang (axles[N-1])
+ * @param axleSpacings - Jarak antar axle berurutan (N-1 nilai untuk N axle)
+ * @param line - Line object untuk kalkulasi posisi
+ * @returns Array AxleState, axles[0] = terdepan, axles[N-1] = paling belakang
+ */
+export declare function calculateInitialAxlePositions(lineId: string, rearOffset: number, axleSpacings: number[], line: Line): AxleState[];
 /**
  * Calculate initial front axle position from rear position
  *
@@ -173,26 +183,21 @@ export interface SegmentCompletionResult {
 export declare function handleArrival(state: VehicleMovementState, ctx: SegmentCompletionContext): SegmentCompletionResult;
 export type { VehicleMovementState as SegmentVehicleState };
 /**
- * Advance both axles of a vehicle by `distance` along a prepared path.
+ * Advance semua axle vehicle oleh `distance` sepanjang path.
  *
- * This is the low-level tick primitive. It updates both rear and front axles
- * using arc-length parameterization and returns whether the rear axle has
- * reached the end of the path (arrived).
+ * Ini adalah low-level tick primitive. Update semua axle menggunakan
+ * arc-length parameterization. Arrival = axles[0] (terdepan) mencapai ujung path.
  *
- * @param rear - Current rear axle state
- * @param front - Current front axle state
- * @param rearExecution - Current rear axle execution position in path
- * @param frontExecution - Current front axle execution position in path
- * @param path - The path to follow
- * @param distance - Distance to advance this tick
- * @param linesMap - Scene lines map for position calculation
- * @param curveDataMap - Pre-built bezier curve data for the path's curve segments
- * @returns Updated axle states, execution states, and arrival flag
- */
-export declare function moveVehicle(rear: AxleState, front: AxleState, rearExecution: AxleExecutionState, frontExecution: AxleExecutionState, path: PathResult, distance: number, linesMap: Map<string, Line>, curveDataMap: Map<number, CurveData>): {
-    rear: AxleState;
-    front: AxleState;
-    rearExecution: AxleExecutionState;
-    frontExecution: AxleExecutionState;
+ * @param axleStates - Array AxleState saat ini, axles[0] = terdepan
+ * @param axleExecutions - Array AxleExecutionState sesuai urutan axleStates
+ * @param path - Path yang diikuti
+ * @param distance - Jarak yang dimaju per tick
+ * @param linesMap - Map line ID ke Line object
+ * @param curveDataMap - Pre-built bezier curve data
+ * @returns Updated axles, axleExecutions, dan arrival flag
+ */
+export declare function moveVehicle(axleStates: AxleState[], axleExecutions: AxleExecutionState[], path: PathResult, distance: number, linesMap: Map<string, Line>, curveDataMap: Map<number, CurveData>): {
+    axles: AxleState[];
+    axleExecutions: AxleExecutionState[];
     arrived: boolean;
 };

package/dist/core/engine.d.ts

@@ -30,24 +30,21 @@ import type { MovementConfig, CurveData } from './types/movement';
 import type { PathResult } from './algorithms/pathFinding';
 import type { TangentMode } from './types/config';
 export interface PathEngineConfig {
-    wheelbase: number;
+    maxWheelbase: number;
     tangentMode: TangentMode;
 }
 /**
- * Simplified dual-axle position state for use with PathEngine.
- * A flatter alternative to the internal Vehicle type.
+ * Multi-axle position state for use with PathEngine.
+ * axles[0] = terdepan, axles[N-1] = paling belakang.
  */
 export interface VehiclePathState {
-    rear: {
+    axles: Array<{
         lineId: string;
         offset: number;
         position: Point;
-    };
-    front: {
-        lineId: string;
-        offset: number;
-        position: Point;
-    };
+    }>;
+    /** N-1 jarak arc-length antar axle berurutan */
+    axleSpacings: number[];
 }
 /**
  * Active path execution state for a vehicle in motion.
@@ -56,11 +53,11 @@ export interface VehiclePathState {
 export interface PathExecution {
     path: PathResult;
     curveDataMap: Map<number, CurveData>;
-    rearSegmentIndex: number;
-    rearSegmentDistance: number;
-    frontSegmentIndex: number;
-    frontSegmentDistance: number;
-    /** Resolved absolute target offset for rear axle arrival detection */
+    /** Execution state per axle, sesuai urutan VehiclePathState.axles */
+    axleExecutions: Array<{
+        segmentIndex: number;
+        segmentDistance: number;
+    }>;
     targetLineId: string;
     targetOffset: number;
 }
@@ -126,13 +123,14 @@ export declare class PathEngine {
      */
     removeCurve(index: number): boolean;
     /**
-     * Initialize a vehicle's dual-axle position on a line.
+     * Initialize a vehicle's N-axle position on a line.
      *
      * @param lineId - The line to place the vehicle on
-     * @param offset - Absolute distance offset along the line
+     * @param rearOffset - Absolute distance offset untuk axle paling belakang
+     * @param axleSpacings - Jarak antar axle berurutan (N-1 nilai untuk N axle)
      * @returns Initial VehiclePathState, or null if lineId does not exist
      */
-    initializeVehicle(lineId: string, offset: number): VehiclePathState | null;
+    initializeVehicle(lineId: string, rearOffset: number, axleSpacings: number[]): VehiclePathState | null;
     /**
      * Prepare a path from the vehicle's current position to a target.
      *

package/dist/core/index.d.ts

@@ -16,6 +16,7 @@ export type { CurveData, AxleExecutionState, PathExecutionState, VehicleMovement
 export type { TangentMode } from './types/config';
 export type { CoordinateInput, SceneLineInput, SceneConnectionInput, SceneConfig, VehicleInput, VehicleUpdateInput, ConnectionUpdateInput, GotoCommandInput } from './types/api';
 export { buildGraph, findPath, calculateBezierArcLength, resolveFromLineOffset, resolveToLineOffset, type Graph, type GraphEdge, type PathSegment, type PathResult, type VehiclePosition } from './algorithms/pathFinding';
-export { initializeMovingVehicle, createInitialMovementState, initializeAllVehicles, calculateInitialFrontPosition, type InitializationResult, updateAxlePosition, calculatePositionOnLine, calculatePositionOnCurve, calculateFrontAxlePosition, getCumulativeArcLength, arcLengthToSegmentPosition, prepareCommandPath, type PreparedPath, handleArrival, type SegmentCompletionContext, type SegmentCompletionResult, type SegmentVehicleState, moveVehicle, getPositionFromOffset, getLineLength } from './algorithms/vehicleMovement';
+export { initializeMovingVehicle, createInitialMovementState, initializeAllVehicles, calculateInitialAxlePositions, type InitializationResult, updateAxlePosition, calculatePositionOnLine, calculatePositionOnCurve, calculateFrontAxlePosition, getCumulativeArcLength, arcLengthToSegmentPosition, prepareCommandPath, type PreparedPath, handleArrival, type SegmentCompletionContext, type SegmentCompletionResult, type SegmentVehicleState, moveVehicle, getPositionFromOffset, getLineLength } from './algorithms/vehicleMovement';
 export { PathEngine, type PathEngineConfig, type VehiclePathState, type PathExecution } from './engine';
 export { distance, normalize, getPointOnLine, getPointOnLineByOffset, getPointOnBezier, createBezierCurve, buildArcLengthTable, distanceToT, getArcLength, calculateTangentLength, isPointNearPoint, type ArcLengthEntry, type CurveOffsetOptions } from './algorithms/math';
+export { serializeScene, type SceneSnapshot } from './snapshot';

package/dist/core/snapshot.d.ts

@@ -0,0 +1,39 @@
+import type { Line } from './types/geometry';
+export interface SceneSnapshot {
+    lines: Line[];
+    curves: Array<{
+        id: string;
+        fromLineId: string;
+        toLineId: string;
+        fromOffset: number;
+        toOffset: number;
+    }>;
+    vehicles: Array<{
+        id: string;
+        axles: Array<{
+            lineId: string;
+            offset: number;
+        }>;
+        axleSpacings: number[];
+    }>;
+}
+/**
+ * Serialize scene state to a JSON string suitable for clipboard or storage.
+ * Strips derived fields (bezier curves, axle positions) — only source-of-truth
+ * data is included.
+ */
+export declare function serializeScene(lines: Line[], curves: Array<{
+    id: string;
+    fromLineId: string;
+    toLineId: string;
+    fromOffset: number;
+    toOffset: number;
+}>, vehicles: Array<{
+    id: string;
+    axles: Array<{
+        lineId: string;
+        offset: number;
+        [key: string]: unknown;
+    }>;
+    axleSpacings: number[];
+}>): string;

package/dist/core/types/api.d.ts

@@ -70,6 +70,15 @@ export interface VehicleInput {
     lineId: string;
     position?: number;
     isPercentage?: boolean;
+    /**
+     * Jarak arc-length antar axle berurutan.
+     * axleSpacings[i] = jarak antara axles[i] dan axles[i+1].
+     * axles[0] = terdepan, axles[N-1] = paling belakang.
+     * Contoh truk biasa: [30]  →  2 axle, jarak 30px
+     * Contoh truck+trailer: [20, 45]  →  3 axle
+     * Total panjang vehicle = sum(axleSpacings) harus ≤ maxWheelbase
+     */
+    axleSpacings: number[];
 }
 /**
  * Vehicle update input for updateVehicle()

package/dist/core/types/movement.d.ts

@@ -27,8 +27,7 @@ export interface PathExecutionState {
     path: import('../algorithms/pathFinding').PathResult;
     curveDataMap: Map<number, CurveData>;
     currentCommandIndex: number;
-    rear: AxleExecutionState;
-    front: AxleExecutionState;
+    axles: AxleExecutionState[];
 }
 /**
  * Movement state container for a vehicle
@@ -41,7 +40,7 @@ export interface VehicleMovementState {
  * Configuration for vehicle movement
  */
 export interface MovementConfig {
-    wheelbase: number;
+    maxWheelbase: number;
     tangentMode: TangentMode;
 }
 /**

package/dist/core/types/vehicle.d.ts

@@ -14,6 +14,8 @@ export interface VehicleStart {
     lineId: string;
     offset: number;
     isPercentage: boolean;
+    /** Optional: defaults to [maxWheelbase] jika tidak disediakan */
+    axleSpacings?: number[];
 }
 /**
  * State for a single axle (Front or Rear)
@@ -32,8 +34,8 @@ export interface Vehicle {
     offset: number;
     isPercentage: boolean;
     state: VehicleState;
-    rear: AxleState;
-    front: AxleState;
+    axles: AxleState[];
+    axleSpacings: number[];
 }
 /**
  * Command to move a vehicle to a target position

package/dist/core.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./vehicleMovement-BiYBE_2a.cjs");class g{graph=null;linesMap=new Map;curves=[];config;constructor(e){this.config={wheelbase:e.wheelbase,tangentMode:e.tangentMode}}get movementConfig(){return this.config}get lines(){return Array.from(this.linesMap.values())}getCurves(){return this.curves}setScene(e,i){this.linesMap.clear();for(const n of e)this.linesMap.set(n.id,n);this.curves=i,this.graph=t.buildGraph(e,i,this.config)}addLine(e){return this.linesMap.has(e.id)?!1:(this.linesMap.set(e.id,e),this.graph=t.buildGraph(Array.from(this.linesMap.values()),this.curves,this.config),!0)}updateLine(e,i){const n=this.linesMap.get(e);return n?(i.start&&(n.start=i.start),i.end&&(n.end=i.end),this.graph=t.buildGraph(Array.from(this.linesMap.values()),this.curves,this.config),!0):!1}updateLineEndpoint(e,i,n){return this.updateLine(e,{[i]:n})}renameLine(e,i){const n=i.trim();if(!n)return{success:!1,error:"Name cannot be empty"};if(n===e)return{success:!0};if(this.linesMap.has(n))return{success:!1,error:`"${n}" already exists`};const a=this.linesMap.get(e);if(!a)return{success:!1,error:`Line "${e}" not found`};a.id=n,this.linesMap.delete(e),this.linesMap.set(n,a);for(const s of this.curves)s.fromLineId===e&&(s.fromLineId=n),s.toLineId===e&&(s.toLineId=n);return this.graph=t.buildGraph(Array.from(this.linesMap.values()),this.curves,this.config),{success:!0}}removeLine(e){return this.linesMap.has(e)?(this.linesMap.delete(e),this.curves=this.curves.filter(i=>i.fromLineId!==e&&i.toLineId!==e),this.graph=t.buildGraph(Array.from(this.linesMap.values()),this.curves,this.config),!0):!1}addCurve(e){this.curves.push(e),this.graph=t.buildGraph(Array.from(this.linesMap.values()),this.curves,this.config)}updateCurve(e,i){return e<0||e>=this.curves.length?!1:(this.curves[e]={...this.curves[e],...i},this.graph=t.buildGraph(Array.from(this.linesMap.values()),this.curves,this.config),!0)}removeCurve(e){return e<0||e>=this.curves.length?!1:(this.curves.splice(e,1),this.graph=t.buildGraph(Array.from(this.linesMap.values()),this.curves,this.config),!0)}initializeVehicle(e,i){const n=this.linesMap.get(e);if(!n)return null;const a=t.getLineLength(n),s=Math.min(i,a-this.config.wheelbase),l=t.getPositionFromOffset(n,s),o=t.calculateInitialFrontPosition(e,s,this.config.wheelbase,n);return{rear:{lineId:e,offset:s,position:l},front:{lineId:o.lineId,offset:o.absoluteOffset,position:o.position}}}preparePath(e,i,n,a=!1){if(!this.graph)return null;const s={lineId:e.rear.lineId,offset:e.rear.offset,rear:{lineId:e.rear.lineId,position:e.rear.position,absoluteOffset:e.rear.offset},front:{lineId:e.front.lineId,position:e.front.position,absoluteOffset:e.front.offset}},l={targetLineId:i,targetOffset:n,isPercentage:a},o={graph:this.graph,linesMap:this.linesMap,curves:this.curves,config:this.config},r=t.prepareCommandPath(s,l,o);if(!r)return null;let c=n;const f=this.linesMap.get(i);if(f){const u=t.getLineLength(f),h=Math.max(0,u-this.config.wheelbase);c=a?n*h:Math.min(n,h)}return{path:r.path,curveDataMap:r.curveDataMap,rearSegmentIndex:0,rearSegmentDistance:0,frontSegmentIndex:0,frontSegmentDistance:this.config.wheelbase,targetLineId:i,targetOffset:c}}moveVehicle(e,i,n){const a={lineId:e.rear.lineId,position:e.rear.position,absoluteOffset:e.rear.offset},s={lineId:e.front.lineId,position:e.front.position,absoluteOffset:e.front.offset},l={currentSegmentIndex:i.rearSegmentIndex,segmentDistance:i.rearSegmentDistance},o={currentSegmentIndex:i.frontSegmentIndex,segmentDistance:i.frontSegmentDistance},r=t.moveVehicle(a,s,l,o,i.path,n,this.linesMap,i.curveDataMap);return{state:{rear:{lineId:r.rear.lineId,offset:r.rear.absoluteOffset,position:r.rear.position},front:{lineId:r.front.lineId,offset:r.front.absoluteOffset,position:r.front.position}},execution:{...i,rearSegmentIndex:r.rearExecution.currentSegmentIndex,rearSegmentDistance:r.rearExecution.segmentDistance,frontSegmentIndex:r.frontExecution.currentSegmentIndex,frontSegmentDistance:r.frontExecution.segmentDistance},arrived:r.arrived}}}exports.arcLengthToSegmentPosition=t.arcLengthToSegmentPosition;exports.buildArcLengthTable=t.buildArcLengthTable;exports.buildGraph=t.buildGraph;exports.calculateBezierArcLength=t.calculateBezierArcLength;exports.calculateFrontAxlePosition=t.calculateFrontAxlePosition;exports.calculateInitialFrontPosition=t.calculateInitialFrontPosition;exports.calculatePositionOnCurve=t.calculatePositionOnCurve;exports.calculatePositionOnLine=t.calculatePositionOnLine;exports.calculateTangentLength=t.calculateTangentLength;exports.createBezierCurve=t.createBezierCurve;exports.createInitialMovementState=t.createInitialMovementState;exports.distance=t.distance;exports.distanceToT=t.distanceToT;exports.findPath=t.findPath;exports.getArcLength=t.getArcLength;exports.getCumulativeArcLength=t.getCumulativeArcLength;exports.getLineLength=t.getLineLength;exports.getPointOnBezier=t.getPointOnBezier;exports.getPointOnLine=t.getPointOnLine;exports.getPointOnLineByOffset=t.getPointOnLineByOffset;exports.getPositionFromOffset=t.getPositionFromOffset;exports.handleArrival=t.handleArrival;exports.initializeAllVehicles=t.initializeAllVehicles;exports.initializeMovingVehicle=t.initializeMovingVehicle;exports.isPointNearPoint=t.isPointNearPoint;exports.moveVehicle=t.moveVehicle;exports.normalize=t.normalize;exports.prepareCommandPath=t.prepareCommandPath;exports.resolveFromLineOffset=t.resolveFromLineOffset;exports.resolveToLineOffset=t.resolveToLineOffset;exports.updateAxlePosition=t.updateAxlePosition;exports.PathEngine=g;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./index-DfPg-M5u.cjs");function r(n,a,o){const l={lines:n,curves:a.map(i=>({id:i.id,fromLineId:i.fromLineId,toLineId:i.toLineId,fromOffset:i.fromOffset,toOffset:i.toOffset})),vehicles:o.map(i=>({id:i.id,axles:i.axles.map(t=>({lineId:t.lineId,offset:t.offset})),axleSpacings:i.axleSpacings}))};return JSON.stringify(l,null,2)}exports.PathEngine=e.PathEngine;exports.arcLengthToSegmentPosition=e.arcLengthToSegmentPosition;exports.buildArcLengthTable=e.buildArcLengthTable;exports.buildGraph=e.buildGraph;exports.calculateBezierArcLength=e.calculateBezierArcLength;exports.calculateFrontAxlePosition=e.calculateFrontAxlePosition;exports.calculateInitialAxlePositions=e.calculateInitialAxlePositions;exports.calculatePositionOnCurve=e.calculatePositionOnCurve;exports.calculatePositionOnLine=e.calculatePositionOnLine;exports.calculateTangentLength=e.calculateTangentLength;exports.createBezierCurve=e.createBezierCurve;exports.createInitialMovementState=e.createInitialMovementState;exports.distance=e.distance;exports.distanceToT=e.distanceToT;exports.findPath=e.findPath;exports.getArcLength=e.getArcLength;exports.getCumulativeArcLength=e.getCumulativeArcLength;exports.getLineLength=e.getLineLength;exports.getPointOnBezier=e.getPointOnBezier;exports.getPointOnLine=e.getPointOnLine;exports.getPointOnLineByOffset=e.getPointOnLineByOffset;exports.getPositionFromOffset=e.getPositionFromOffset;exports.handleArrival=e.handleArrival;exports.initializeAllVehicles=e.initializeAllVehicles;exports.initializeMovingVehicle=e.initializeMovingVehicle;exports.isPointNearPoint=e.isPointNearPoint;exports.moveVehicle=e.moveVehicle;exports.normalize=e.normalize;exports.prepareCommandPath=e.prepareCommandPath;exports.resolveFromLineOffset=e.resolveFromLineOffset;exports.resolveToLineOffset=e.resolveToLineOffset;exports.updateAxlePosition=e.updateAxlePosition;exports.serializeScene=r;

package/dist/core.js

@@ -1,243 +1,54 @@
-import { c as a, p as u, t as p, f as m, z as v, x as d } from "./vehicleMovement-TkCt4q_a.js";
-import { a as O, b as P, d as x, e as D, g as y, h as S, D as C, i as E, j as w, k as z, l as T, m as B, n as V, o as F, q as N, r as $, s as j, u as k, v as q, w as G, E as H, y as J, A as K, B as Q, C as R } from "./vehicleMovement-TkCt4q_a.js";
-class I {
-  graph = null;
-  linesMap = /* @__PURE__ */ new Map();
-  curves = [];
-  config;
-  constructor(e) {
-    this.config = {
-      wheelbase: e.wheelbase,
-      tangentMode: e.tangentMode
-    };
-  }
-  // ---------------------------------------------------------------------------
-  // Accessors
-  // ---------------------------------------------------------------------------
-  get movementConfig() {
-    return this.config;
-  }
-  get lines() {
-    return Array.from(this.linesMap.values());
-  }
-  getCurves() {
-    return this.curves;
-  }
-  // ---------------------------------------------------------------------------
-  // Scene management
-  // ---------------------------------------------------------------------------
-  /**
-   * Replace the entire scene and rebuild the graph.
-   */
-  setScene(e, t) {
-    this.linesMap.clear();
-    for (const s of e)
-      this.linesMap.set(s.id, s);
-    this.curves = t, this.graph = a(e, t, this.config);
-  }
-  /**
-   * Add a single line. Returns false if a line with the same ID already exists.
-   */
-  addLine(e) {
-    return this.linesMap.has(e.id) ? !1 : (this.linesMap.set(e.id, e), this.graph = a(Array.from(this.linesMap.values()), this.curves, this.config), !0);
-  }
-  /**
-   * Update start and/or end coordinates of an existing line.
-   */
-  updateLine(e, t) {
-    const s = this.linesMap.get(e);
-    return s ? (t.start && (s.start = t.start), t.end && (s.end = t.end), this.graph = a(Array.from(this.linesMap.values()), this.curves, this.config), !0) : !1;
-  }
-  /**
-   * Update a single endpoint ('start' or 'end') of a line.
-   */
-  updateLineEndpoint(e, t, s) {
-    return this.updateLine(e, { [t]: s });
-  }
-  /**
-   * Rename a line ID and cascade the change to all connected curves.
-   */
-  renameLine(e, t) {
-    const s = t.trim();
-    if (!s) return { success: !1, error: "Name cannot be empty" };
-    if (s === e) return { success: !0 };
-    if (this.linesMap.has(s)) return { success: !1, error: `"${s}" already exists` };
-    const i = this.linesMap.get(e);
-    if (!i) return { success: !1, error: `Line "${e}" not found` };
-    i.id = s, this.linesMap.delete(e), this.linesMap.set(s, i);
-    for (const r of this.curves)
-      r.fromLineId === e && (r.fromLineId = s), r.toLineId === e && (r.toLineId = s);
-    return this.graph = a(Array.from(this.linesMap.values()), this.curves, this.config), { success: !0 };
-  }
-  /**
-   * Remove a line and all curves connected to it.
-   */
-  removeLine(e) {
-    return this.linesMap.has(e) ? (this.linesMap.delete(e), this.curves = this.curves.filter((t) => t.fromLineId !== e && t.toLineId !== e), this.graph = a(Array.from(this.linesMap.values()), this.curves, this.config), !0) : !1;
-  }
-  /**
-   * Add a directional curve (connection) from one line to another.
-   */
-  addCurve(e) {
-    this.curves.push(e), this.graph = a(Array.from(this.linesMap.values()), this.curves, this.config);
-  }
-  /**
-   * Update a curve by index. Returns false if index is out of bounds.
-   */
-  updateCurve(e, t) {
-    return e < 0 || e >= this.curves.length ? !1 : (this.curves[e] = { ...this.curves[e], ...t }, this.graph = a(Array.from(this.linesMap.values()), this.curves, this.config), !0);
-  }
-  /**
-   * Remove a curve by index. Returns false if index is out of bounds.
-   */
-  removeCurve(e) {
-    return e < 0 || e >= this.curves.length ? !1 : (this.curves.splice(e, 1), this.graph = a(Array.from(this.linesMap.values()), this.curves, this.config), !0);
-  }
-  // ---------------------------------------------------------------------------
-  // Vehicle operations
-  // ---------------------------------------------------------------------------
-  /**
-   * Initialize a vehicle's dual-axle position on a line.
-   *
-   * @param lineId - The line to place the vehicle on
-   * @param offset - Absolute distance offset along the line
-   * @returns Initial VehiclePathState, or null if lineId does not exist
-   */
-  initializeVehicle(e, t) {
-    const s = this.linesMap.get(e);
-    if (!s) return null;
-    const i = u(s), r = Math.min(t, i - this.config.wheelbase), f = p(s, r), o = m(e, r, this.config.wheelbase, s);
-    return {
-      rear: { lineId: e, offset: r, position: f },
-      front: { lineId: o.lineId, offset: o.absoluteOffset, position: o.position }
-    };
-  }
-  /**
-   * Prepare a path from the vehicle's current position to a target.
-   *
-   * Must be called before moveVehicle(). Returns null if no path exists.
-   *
-   * @param vehicleState - Current vehicle state (from initializeVehicle or previous tick)
-   * @param targetLineId - ID of the target line
-   * @param targetOffset - Position on the target line
-   * @param isPercentage - If true, targetOffset is 0-1 fraction; if false, absolute distance
-   */
-  preparePath(e, t, s, i = !1) {
-    if (!this.graph) return null;
-    const r = {
-      lineId: e.rear.lineId,
-      offset: e.rear.offset,
-      rear: {
-        lineId: e.rear.lineId,
-        position: e.rear.position,
-        absoluteOffset: e.rear.offset
-      },
-      front: {
-        lineId: e.front.lineId,
-        position: e.front.position,
-        absoluteOffset: e.front.offset
-      }
-    }, f = {
-      targetLineId: t,
-      targetOffset: s,
-      isPercentage: i
-    }, o = {
-      graph: this.graph,
-      linesMap: this.linesMap,
-      curves: this.curves,
-      config: this.config
-    }, n = v(r, f, o);
-    if (!n) return null;
-    let c = s;
-    const l = this.linesMap.get(t);
-    if (l) {
-      const g = u(l), h = Math.max(0, g - this.config.wheelbase);
-      c = i ? s * h : Math.min(s, h);
-    }
-    return {
-      path: n.path,
-      curveDataMap: n.curveDataMap,
-      rearSegmentIndex: 0,
-      rearSegmentDistance: 0,
-      frontSegmentIndex: 0,
-      frontSegmentDistance: this.config.wheelbase,
-      targetLineId: t,
-      targetOffset: c
-    };
-  }
-  /**
-   * Advance a vehicle by `distance` along its prepared path.
-   *
-   * Call this every tick. The returned `state` and `execution` replace the
-   * previous values. When `arrived` is true, the vehicle has reached the target.
-   *
-   * @param state - Current vehicle state
-   * @param execution - Current path execution (from preparePath or previous tick)
-   * @param distance - Distance to advance this tick (speed × deltaTime)
-   */
-  moveVehicle(e, t, s) {
-    const i = {
-      lineId: e.rear.lineId,
-      position: e.rear.position,
-      absoluteOffset: e.rear.offset
-    }, r = {
-      lineId: e.front.lineId,
-      position: e.front.position,
-      absoluteOffset: e.front.offset
-    }, f = {
-      currentSegmentIndex: t.rearSegmentIndex,
-      segmentDistance: t.rearSegmentDistance
-    }, o = {
-      currentSegmentIndex: t.frontSegmentIndex,
-      segmentDistance: t.frontSegmentDistance
-    }, n = d(i, r, f, o, t.path, s, this.linesMap, t.curveDataMap);
-    return {
-      state: {
-        rear: { lineId: n.rear.lineId, offset: n.rear.absoluteOffset, position: n.rear.position },
-        front: { lineId: n.front.lineId, offset: n.front.absoluteOffset, position: n.front.position }
-      },
-      execution: {
-        ...t,
-        rearSegmentIndex: n.rearExecution.currentSegmentIndex,
-        rearSegmentDistance: n.rearExecution.segmentDistance,
-        frontSegmentIndex: n.frontExecution.currentSegmentIndex,
-        frontSegmentDistance: n.frontExecution.segmentDistance
-      },
-      arrived: n.arrived
-    };
-  }
+import { P as f, a as c, b as g, c as d, d as h, e as m, f as u, g as L, h as P, i as O, j as p, k as v, l as x, m as A, n as z, o as I, p as S, q as T, r as B, s as C, t as b, u as y, v as F, w as V, x as E, y as M, z as N, A as j, B as k, C as q, D as w, E as D } from "./index-D8o0W80x.js";
+function o(i, t, s) {
+  const n = {
+    lines: i,
+    curves: t.map((e) => ({
+      id: e.id,
+      fromLineId: e.fromLineId,
+      toLineId: e.toLineId,
+      fromOffset: e.fromOffset,
+      toOffset: e.toOffset
+    })),
+    vehicles: s.map((e) => ({
+      id: e.id,
+      axles: e.axles.map((a) => ({ lineId: a.lineId, offset: a.offset })),
+      axleSpacings: e.axleSpacings
+    }))
+  };
+  return JSON.stringify(n, null, 2);
 }
 export {
-  I as PathEngine,
-  O as arcLengthToSegmentPosition,
-  P as buildArcLengthTable,
-  a as buildGraph,
-  x as calculateBezierArcLength,
-  D as calculateFrontAxlePosition,
-  m as calculateInitialFrontPosition,
-  y as calculatePositionOnCurve,
-  S as calculatePositionOnLine,
-  C as calculateTangentLength,
-  E as createBezierCurve,
-  w as createInitialMovementState,
-  z as distance,
-  T as distanceToT,
-  B as findPath,
-  V as getArcLength,
-  F as getCumulativeArcLength,
-  u as getLineLength,
-  N as getPointOnBezier,
-  $ as getPointOnLine,
-  j as getPointOnLineByOffset,
-  p as getPositionFromOffset,
-  k as handleArrival,
-  q as initializeAllVehicles,
-  G as initializeMovingVehicle,
-  H as isPointNearPoint,
-  d as moveVehicle,
-  J as normalize,
-  v as prepareCommandPath,
-  K as resolveFromLineOffset,
-  Q as resolveToLineOffset,
-  R as updateAxlePosition
+  f as PathEngine,
+  c as arcLengthToSegmentPosition,
+  g as buildArcLengthTable,
+  d as buildGraph,
+  h as calculateBezierArcLength,
+  m as calculateFrontAxlePosition,
+  u as calculateInitialAxlePositions,
+  L as calculatePositionOnCurve,
+  P as calculatePositionOnLine,
+  O as calculateTangentLength,
+  p as createBezierCurve,
+  v as createInitialMovementState,
+  x as distance,
+  A as distanceToT,
+  z as findPath,
+  I as getArcLength,
+  S as getCumulativeArcLength,
+  T as getLineLength,
+  B as getPointOnBezier,
+  C as getPointOnLine,
+  b as getPointOnLineByOffset,
+  y as getPositionFromOffset,
+  F as handleArrival,
+  V as initializeAllVehicles,
+  E as initializeMovingVehicle,
+  M as isPointNearPoint,
+  N as moveVehicle,
+  j as normalize,
+  k as prepareCommandPath,
+  q as resolveFromLineOffset,
+  w as resolveToLineOffset,
+  o as serializeScene,
+  D as updateAxlePosition
 };