vehicle-path 1.0.0

package/README.md

@@ -0,0 +1,293 @@
+# VehiclePath
+
+An interactive web-based vehicle motion simulator that visualizes dual-axle vehicle movement along complex paths composed of lines and Bezier curves. The system accurately tracks both rear and front axles with proper wheelbase constraints.
+
+## Features
+
+- **Interactive Canvas Drawing** - Create lines and Bezier curves with mouse controls
+- **Dual-Axle Vehicle Tracking** - Track both front (F) and rear (R) axles with configurable wheelbase
+- **Text-based Scene Definition** - Define scenes using intuitive DSL syntax
+- **Command-based Movement** - Queue goto commands with `--wait` and `--payload` options
+- **Arc-Length Parameterization** - Accurate curve traversal with constant speed
+- **Event System** - Observer pattern for vehicle events (commandComplete, positionUpdate, stateChange)
+- **Playback Controls** - Run, pause, and reset animations
+- **Real-time Visualization** - Canvas rendering with endpoints, curves, and moving vehicles
+
+## Quick Start
+
+```bash
+# Install dependencies
+npm install
+
+# Start development server
+npm run dev
+
+# Run tests
+npm test
+
+# Build for production
+npm run build
+```
+
+## Scene Definition DSL
+
+### Lines
+```
+line001 : (100, 100) -> (500, 100)
+line002 : (500, 100) -> (500, 400)
+```
+
+### Curves (connect lines)
+```
+line001 -> line002
+line001 80% -> line002 30%
+```
+
+### Vehicle Start Positions
+```
+v1 start line001 0%
+v2 start line002 50
+```
+
+### Movement Commands
+```
+v1 goto line002 100%
+v1 goto line001 50% --wait
+v1 goto line002 0% --payload {"orderId":"123"}
+```
+
+## Architecture
+
+```
+src/
+├── components/
+│   ├── Canvas.tsx          # Interactive canvas for drawing
+│   └── Controls.tsx        # Control panel with parameters
+├── hooks/
+│   ├── useCanvasInteraction.ts   # Mouse/drag handling
+│   ├── useSceneDefinition.ts     # Lines/curves state
+│   ├── useInitialMovement.ts     # Vehicle start positions
+│   ├── useMovementSequence.ts    # Goto command queuing
+│   ├── useVehicleMovement.ts     # Animation loop
+│   └── useVehicleEvents.ts       # Event subscription
+├── types/
+│   ├── core.ts             # Point, Line, Curve
+│   ├── vehicle.ts          # Vehicle, AxleState, GotoCommand
+│   ├── movement.ts         # MovementConfig, PathExecutionState
+│   └── ui.ts               # DrawMode, TangentMode
+└── utils/
+    ├── pathFinding.ts      # Graph-based path finding
+    ├── textParser.ts       # DSL parsing
+    ├── VehicleEventEmitter.ts  # Event system
+    └── vehicleMovement/    # Core movement algorithms
+        ├── initialize.ts
+        ├── positionUpdate.ts
+        ├── arcLengthTracking.ts
+        ├── pathPreparation.ts
+        └── segmentTransition.ts
+```
+
+## Core Concepts
+
+### Dual-Axle Tracking
+
+The system tracks two axle positions:
+- **Rear Axle (R)** - The reference point that follows the path exactly
+- **Front Axle (F)** - Maintains constant wheelbase distance from R
+
+```
+R ----[wheelbase]---- F
+      (30-60 pixels)
+```
+
+### Arc-Length Parameterization
+
+Bezier curves are pre-computed with arc-length lookup tables for:
+- Constant speed movement along curves
+- Accurate position calculation at any distance
+- Smooth transitions between segments
+
+### Event System
+
+Subscribe to vehicle events using the observer pattern:
+
+```typescript
+// Using React hook
+useVehicleEvent('positionUpdate', (data) => {
+  console.log(`Center: (${data.center.x}, ${data.center.y})`)
+  console.log(`Angle: ${data.angle} radians`)
+})
+
+// Manual subscription
+const unsubscribe = emitter.on('commandComplete', (info) => {
+  console.log(`Vehicle ${info.vehicleId} arrived`)
+  console.log(`Payload:`, info.payload)
+})
+```
+
+**Available Events:**
+| Event | Data | Description |
+|-------|------|-------------|
+| `commandComplete` | `GotoCompletionInfo` | Fired when vehicle reaches destination |
+| `positionUpdate` | `VehiclePositionUpdate` | Fired each frame with position/angle |
+| `stateChange` | `{vehicleId, from, to}` | Fired when vehicle state changes |
+
+### Manual Control with `--wait`
+
+Pause vehicle after command completion:
+
+```
+v1 goto station-A 100% --wait
+v1 goto station-B 0%
+```
+
+Then resume programmatically:
+
+```typescript
+const { continueVehicle } = useVehicleMovement({...})
+
+// After processing...
+continueVehicle('v1')
+```
+
+### Payload System
+
+Attach custom data to commands:
+
+```
+v1 goto pickup 100% --wait --payload {"orderId":"order-123","priority":1}
+```
+
+Access in callback:
+
+```typescript
+emitter.on('commandComplete', (info) => {
+  if (info.payload) {
+    const { orderId, priority } = info.payload as OrderPayload
+    // Process order...
+  }
+})
+```
+
+## API Reference
+
+### useVehicleMovement
+
+```typescript
+const {
+  movingVehicles,    // Current vehicle states
+  playbackState,     // 'stopped' | 'running' | 'paused'
+  handleRun,         // Start animation
+  handlePause,       // Pause animation
+  handleReset,       // Reset to initial positions
+  continueVehicle    // Resume waiting vehicle
+} = useVehicleMovement({
+  vehicles,          // Initial vehicle configs
+  lines,             // Line definitions
+  vehicleQueues,     // Map<vehicleId, GotoCommand[]>
+  velocity,          // Pixels per frame
+  wheelbase,         // Distance R to F
+  tangentMode,       // 'smooth' | 'linear'
+  curves,            // Curve definitions
+  eventEmitter       // Optional VehicleEventEmitter
+})
+```
+
+### VehicleEventEmitter
+
+```typescript
+const emitter = new VehicleEventEmitter()
+
+// Subscribe
+const unsubscribe = emitter.on('positionUpdate', callback)
+
+// Emit
+emitter.emit('positionUpdate', data)
+
+// Unsubscribe all
+emitter.off('positionUpdate')  // Specific event
+emitter.off()                   // All events
+
+// Check listeners
+emitter.listenerCount('positionUpdate')
+```
+
+### GotoCommand
+
+```typescript
+interface GotoCommand {
+  vehicleId: string
+  targetLineId: string
+  targetOffset: number
+  isPercentage: boolean
+  awaitConfirmation?: boolean  // --wait flag
+  payload?: unknown            // --payload JSON
+}
+```
+
+### VehiclePositionUpdate
+
+```typescript
+interface VehiclePositionUpdate {
+  vehicleId: string
+  rear: Point           // Rear axle position
+  front: Point          // Front axle position
+  center: Point         // Midpoint between axles
+  angle: number         // Heading in radians
+}
+```
+
+## Testing
+
+```bash
+# Run all tests
+npm test
+
+# Run with UI
+npm run test:ui
+
+# Generate coverage report
+npm run test:coverage
+```
+
+Test files are located in `src/utils/vehicleMovement/__tests__/`:
+- `arcLengthTracking.test.ts` - Arc-length calculations
+- `dualAxleMovement.test.ts` - Dual-axle scenarios
+- `initialize.test.ts` - Initialization logic
+- `pathPreparation.test.ts` - Path preparation
+- `positionUpdate.test.ts` - Position updates
+- `userScenario.test.ts` - End-to-end scenarios
+
+## Configuration
+
+### Tangent Modes
+
+Control curve smoothness:
+- **smooth** - Bezier curves with smooth tangents
+- **linear** - Sharp corners at connection points
+
+### Parameters
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `wheelbase` | 30-60 | Distance between R and F axles |
+| `velocity` | 1-5 | Movement speed (pixels/frame) |
+
+## Tech Stack
+
+- **React 19** - UI framework
+- **TypeScript 5.9** - Type safety
+- **Vite 7** - Build tool
+- **Vitest** - Testing framework
+- **Canvas API** - Rendering
+
+## Documentation
+
+Additional documentation in `/docs`:
+- `DEBUG_GUIDE.md` - Debugging vehicle movement
+- `HOOKS.md` - Custom hooks reference
+- `UI.md` - UI architecture
+
+## License
+
+MIT

package/dist/hooks/useCanvasInteraction.d.ts

@@ -0,0 +1,31 @@
+import type { Point, Line, Curve } from '../types/core';
+import type { DrawMode } from '../types/ui';
+interface UseCanvasInteractionProps {
+    canvasRef: React.RefObject<HTMLCanvasElement | null>;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    drawMode: DrawMode;
+    lines: Line[];
+    curves: Curve[];
+    setLines: (lines: Line[]) => void;
+    setCurves: (curves: Curve[]) => void;
+    lineCounterRef: React.MutableRefObject<number>;
+}
+export declare function useCanvasInteraction({ canvasRef, containerRef, drawMode, lines, curves, setLines, setCurves, lineCounterRef }: UseCanvasInteractionProps): {
+    handleMouseDown: (e: React.MouseEvent<HTMLCanvasElement>) => void;
+    handleMouseMove: (e: React.MouseEvent<HTMLCanvasElement>) => void;
+    handleMouseUp: () => void;
+    tempLine: {
+        start: Point;
+        current: Point;
+    } | null;
+    hoveredEndpoint: {
+        lineId: string;
+        endpoint: "start" | "end";
+    } | null;
+    curveStart: {
+        lineId: string;
+        endpoint: "start" | "end";
+    } | null;
+    mousePos: Point;
+};
+export {};

package/dist/hooks/useInitialMovement.d.ts

@@ -0,0 +1,16 @@
+import type { Line } from '../types/core';
+import type { Vehicle } from '../types/vehicle';
+interface UseInitialMovementProps {
+    lines: Line[];
+    wheelbase: number;
+}
+export declare function useInitialMovement({ lines, wheelbase }: UseInitialMovementProps): {
+    vehicles: Vehicle[];
+    initialMovementText: string;
+    movementError: string | null;
+    isDebouncing: boolean;
+    debounceKey: number;
+    setInitialMovementText: import("react").Dispatch<import("react").SetStateAction<string>>;
+    handleAddStartCommand: () => void;
+};
+export {};

package/dist/hooks/useMovementSequence.d.ts

@@ -0,0 +1,17 @@
+import type { Line } from '../types/core';
+import type { Vehicle, GotoCommand } from '../types/vehicle';
+interface UseMovementSequenceProps {
+    lines: Line[];
+    vehicles: Vehicle[];
+}
+export declare function useMovementSequence({ lines, vehicles }: UseMovementSequenceProps): {
+    movementSequenceText: string;
+    gotoCommands: GotoCommand[];
+    vehicleQueues: Map<string, GotoCommand[]>;
+    sequenceError: string | null;
+    isDebouncing: boolean;
+    debounceKey: number;
+    setMovementSequenceText: import("react").Dispatch<import("react").SetStateAction<string>>;
+    handleAddGotoCommand: () => void;
+};
+export {};

package/dist/hooks/useSceneDefinition.d.ts

@@ -0,0 +1,12 @@
+import type { Line, Curve } from '../types/core';
+export declare function useSceneDefinition(): {
+    lines: Line[];
+    curves: Curve[];
+    sceneDefinitionText: string;
+    sceneError: string | null;
+    isDebouncing: boolean;
+    debounceKey: number;
+    setLines: import("react").Dispatch<import("react").SetStateAction<Line[]>>;
+    setCurves: import("react").Dispatch<import("react").SetStateAction<Curve[]>>;
+    setSceneDefinitionText: import("react").Dispatch<import("react").SetStateAction<string>>;
+};

package/dist/hooks/useVehicleEvents.d.ts

@@ -0,0 +1,31 @@
+import { VehicleEventEmitter, type VehicleEventType, type VehicleEventCallback, type VehicleEventMap, type VehiclePositionUpdate } from '../utils/VehicleEventEmitter';
+/**
+ * React context for VehicleEventEmitter
+ */
+export declare const VehicleEventContext: import("react").Context<VehicleEventEmitter | null>;
+/**
+ * Hook to access the VehicleEventEmitter instance from context
+ * @returns VehicleEventEmitter instance
+ * @throws Error if used outside of VehicleEventProvider
+ */
+export declare function useVehicleEventEmitter(): VehicleEventEmitter;
+/**
+ * Hook to create a new VehicleEventEmitter instance (for provider)
+ * @returns VehicleEventEmitter instance (stable reference)
+ */
+export declare function useCreateVehicleEventEmitter(): VehicleEventEmitter;
+/**
+ * Hook to subscribe to a vehicle event with automatic cleanup
+ *
+ * @example
+ * ```typescript
+ * useVehicleEvent('commandComplete', (info) => {
+ *   console.log(`Vehicle ${info.vehicleId} arrived!`)
+ *   if (info.payload) {
+ *     // Handle payload
+ *   }
+ * })
+ * ```
+ */
+export declare function useVehicleEvent<K extends VehicleEventType>(event: K, callback: VehicleEventCallback<K>, deps?: React.DependencyList): void;
+export type { VehicleEventEmitter, VehicleEventType, VehicleEventCallback, VehicleEventMap, VehiclePositionUpdate };

package/dist/hooks/useVehicleMovement.d.ts

@@ -0,0 +1,24 @@
+import type { Line } from '../types/core';
+import type { Vehicle, GotoCommand } from '../types/vehicle';
+import type { TangentMode } from '../types/ui';
+import type { VehicleEventEmitter } from '../utils/VehicleEventEmitter';
+interface UseVehicleMovementProps {
+    vehicles: Vehicle[];
+    lines: Line[];
+    vehicleQueues: Map<string, GotoCommand[]>;
+    velocity: number;
+    wheelbase: number;
+    tangentMode: TangentMode;
+    curves: import('../types/core').Curve[];
+    eventEmitter?: VehicleEventEmitter;
+}
+type PlaybackState = 'stopped' | 'running' | 'paused';
+export declare function useVehicleMovement({ vehicles, lines, vehicleQueues, velocity, wheelbase, tangentMode, curves, eventEmitter }: UseVehicleMovementProps): {
+    movingVehicles: Vehicle[];
+    playbackState: PlaybackState;
+    handleRun: () => void;
+    handlePause: () => void;
+    handleReset: () => void;
+    continueVehicle: (vehicleId: string) => boolean;
+};
+export {};

package/dist/index.d.cts

@@ -0,0 +1,28 @@
+/**
+ * VehiclePath - Vehicle motion simulator library
+ *
+ * A library for simulating dual-axle vehicle movement along paths
+ * composed of lines and Bezier curves.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   useVehicleMovement,
+ *   VehicleEventEmitter,
+ *   parseSceneDefinition
+ * } from 'vehicle-path'
+ * import type { Point, Line, Vehicle } from 'vehicle-path'
+ * ```
+ */
+export type { Point, Line, BezierCurve, Curve, VehicleState, VehicleStart, Vehicle, AxleState, GotoCommand, GotoCompletionInfo, GotoCompletionCallback, CurveData, PathExecutionState, VehicleMovementState, MovementConfig, SceneDefinition, SceneContext, DrawMode, TangentMode } from './types';
+export { useVehicleMovement } from './hooks/useVehicleMovement';
+export { useVehicleEventEmitter, useCreateVehicleEventEmitter, useVehicleEvent, VehicleEventContext } from './hooks/useVehicleEvents';
+export { useSceneDefinition } from './hooks/useSceneDefinition';
+export { useInitialMovement } from './hooks/useInitialMovement';
+export { useMovementSequence } from './hooks/useMovementSequence';
+export { useCanvasInteraction } from './hooks/useCanvasInteraction';
+export { VehicleEventEmitter, type VehicleEventMap, type VehicleEventType, type VehicleEventCallback, type VehiclePositionUpdate, type Unsubscribe } from './utils/VehicleEventEmitter';
+export { parseSceneDefinition, generateSceneDefinition, parseVehicleStarts, generateVehicleStarts, parseGotoCommands, generateGotoCommands } from './utils/textParser';
+export { buildGraph, findPath, canReachTarget, getReachableCurves, calculateBezierArcLength, resolveOffset, resolveFromLineOffset, resolveToLineOffset, type Graph, type GraphEdge, type PathSegment, type PathResult, type VehiclePosition } from './utils/pathFinding';
+export { initializeMovingVehicle, createInitialMovementState, initializeAllVehicles, calculateInitialFrontPosition, type InitializationResult, updateAxlePosition, calculatePositionOnLine, calculatePositionOnCurve, calculateFrontAxlePosition, getCumulativeArcLength, arcLengthToSegmentPosition, prepareCommandPath, type PreparedPath, checkRearCompletion, handleArrival, type SegmentCompletionContext, type SegmentCompletionResult, type SegmentVehicleState, getPositionFromOffset, getLineLength } from './utils/vehicleMovement';
+export { distance, normalize, getPointOnLine, getPointOnLineByOffset, getPointOnBezier, createBezierCurve, buildArcLengthTable, distanceToT, getArcLength, type ArcLengthEntry, type CurveOffsetOptions } from './utils/math';

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * VehiclePath - Vehicle motion simulator library
+ *
+ * A library for simulating dual-axle vehicle movement along paths
+ * composed of lines and Bezier curves.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   useVehicleMovement,
+ *   VehicleEventEmitter,
+ *   parseSceneDefinition
+ * } from 'vehicle-path'
+ * import type { Point, Line, Vehicle } from 'vehicle-path'
+ * ```
+ */
+export type { Point, Line, BezierCurve, Curve, VehicleState, VehicleStart, Vehicle, AxleState, GotoCommand, GotoCompletionInfo, GotoCompletionCallback, CurveData, PathExecutionState, VehicleMovementState, MovementConfig, SceneDefinition, SceneContext, DrawMode, TangentMode } from './types';
+export { useVehicleMovement } from './hooks/useVehicleMovement';
+export { useVehicleEventEmitter, useCreateVehicleEventEmitter, useVehicleEvent, VehicleEventContext } from './hooks/useVehicleEvents';
+export { useSceneDefinition } from './hooks/useSceneDefinition';
+export { useInitialMovement } from './hooks/useInitialMovement';
+export { useMovementSequence } from './hooks/useMovementSequence';
+export { useCanvasInteraction } from './hooks/useCanvasInteraction';
+export { VehicleEventEmitter, type VehicleEventMap, type VehicleEventType, type VehicleEventCallback, type VehiclePositionUpdate, type Unsubscribe } from './utils/VehicleEventEmitter';
+export { parseSceneDefinition, generateSceneDefinition, parseVehicleStarts, generateVehicleStarts, parseGotoCommands, generateGotoCommands } from './utils/textParser';
+export { buildGraph, findPath, canReachTarget, getReachableCurves, calculateBezierArcLength, resolveOffset, resolveFromLineOffset, resolveToLineOffset, type Graph, type GraphEdge, type PathSegment, type PathResult, type VehiclePosition } from './utils/pathFinding';
+export { initializeMovingVehicle, createInitialMovementState, initializeAllVehicles, calculateInitialFrontPosition, type InitializationResult, updateAxlePosition, calculatePositionOnLine, calculatePositionOnCurve, calculateFrontAxlePosition, getCumulativeArcLength, arcLengthToSegmentPosition, prepareCommandPath, type PreparedPath, checkRearCompletion, handleArrival, type SegmentCompletionContext, type SegmentCompletionResult, type SegmentVehicleState, getPositionFromOffset, getLineLength } from './utils/vehicleMovement';
+export { distance, normalize, getPointOnLine, getPointOnLineByOffset, getPointOnBezier, createBezierCurve, buildArcLengthTable, distanceToT, getArcLength, type ArcLengthEntry, type CurveOffsetOptions } from './utils/math';

package/dist/types/core.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Core geometry types for the bezier-path system
+ */
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Line {
+    id: string;
+    start: Point;
+    end: Point;
+}
+export interface BezierCurve {
+    p0: Point;
+    p1: Point;
+    p2: Point;
+    p3: Point;
+}
+export interface Curve {
+    fromLineId: string;
+    toLineId: string;
+    fromOffset?: number;
+    fromIsPercentage?: boolean;
+    toOffset?: number;
+    toIsPercentage?: boolean;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Re-export all types from a single entry point
+ *
+ * Usage:
+ *   import type { Point, Line, Vehicle } from '../types'
+ *   // or
+ *   import type { Point } from '../types/core'
+ */
+export type { Point, Line, BezierCurve, Curve } from './core';
+export type { VehicleState, VehicleStart, Vehicle, AxleState, GotoCommand, GotoCompletionInfo, GotoCompletionCallback } from './vehicle';
+export type { CurveData, PathExecutionState, VehicleMovementState, MovementConfig, SceneDefinition, SceneContext } from './movement';
+export type { DrawMode, TangentMode } from './ui';

package/dist/types/movement.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Movement and animation state types
+ */
+import type { Line, Curve, BezierCurve } from './core';
+import type { Vehicle, VehicleStart } from './vehicle';
+import type { TangentMode } from './ui';
+export type { PathResult } from '../utils/pathFinding';
+export type { ArcLengthEntry } from '../utils/math';
+/**
+ * Bezier curve data with arc-length lookup table for animation
+ */
+export interface CurveData {
+    bezier: BezierCurve;
+    arcLengthTable: import('../utils/math').ArcLengthEntry[];
+}
+/**
+ * Execution state for a single axle (Front or Rear)
+ */
+export interface AxleExecutionState {
+    currentSegmentIndex: number;
+    segmentDistance: number;
+}
+/**
+ * State for path execution during animation
+ */
+export interface PathExecutionState {
+    path: import('../utils/pathFinding').PathResult;
+    curveDataMap: Map<number, CurveData>;
+    currentCommandIndex: number;
+    rear: AxleExecutionState;
+    front: AxleExecutionState;
+}
+/**
+ * Movement state container for a vehicle
+ */
+export interface VehicleMovementState {
+    vehicle: Vehicle;
+    execution: PathExecutionState | null;
+}
+/**
+ * Configuration for vehicle movement
+ */
+export interface MovementConfig {
+    wheelbase: number;
+    tangentMode: TangentMode;
+}
+/**
+ * Scene definition (parsed from text input)
+ */
+export interface SceneDefinition {
+    lines: Line[];
+    curves: Curve[];
+    vehicles: VehicleStart[];
+}
+/**
+ * Scene context for path preparation and movement calculations
+ * Bundles commonly-passed together dependencies
+ */
+export interface SceneContext {
+    config: MovementConfig;
+    graph: import('../utils/pathFinding').Graph;
+    linesMap: Map<string, Line>;
+    curves: Curve[];
+}

package/dist/types/ui.d.ts

@@ -0,0 +1,13 @@
+/**
+ * UI-related types for canvas and controls
+ */
+/**
+ * Drawing mode for canvas interaction
+ */
+export type DrawMode = 'line' | 'curve' | 'drag';
+/**
+ * Tangent calculation mode for bezier curves
+ * - proportional-40: 40% of distance for tangent length
+ * - magic-55: 55.22% of distance (approximates circular arc)
+ */
+export type TangentMode = 'proportional-40' | 'magic-55';

package/dist/types/vehicle.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Vehicle-related types
+ */
+import type { Point } from './core';
+/**
+ * Animation state for a vehicle
+ */
+export type VehicleState = 'idle' | 'moving' | 'waiting';
+/**
+ * Vehicle start position (input from text parsing)
+ */
+export interface VehicleStart {
+    vehicleId: string;
+    lineId: string;
+    offset: number;
+    isPercentage: boolean;
+}
+/**
+ * State for a single axle (Front or Rear)
+ */
+export interface AxleState {
+    lineId: string;
+    position: Point;
+    absoluteOffset: number;
+}
+/**
+ * Vehicle with runtime state (used during animation)
+ */
+export interface Vehicle {
+    id: string;
+    lineId: string;
+    offset: number;
+    isPercentage: boolean;
+    state: VehicleState;
+    rear: AxleState;
+    front: AxleState;
+}
+/**
+ * Command to move a vehicle to a target position
+ */
+export interface GotoCommand {
+    vehicleId: string;
+    targetLineId: string;
+    targetOffset: number;
+    isPercentage: boolean;
+    awaitConfirmation?: boolean;
+    payload?: unknown;
+}
+/**
+ * Information provided when a goto command completes
+ */
+export interface GotoCompletionInfo {
+    vehicleId: string;
+    command: GotoCommand;
+    finalPosition: {
+        lineId: string;
+        absoluteOffset: number;
+        position: Point;
+    };
+    payload?: unknown;
+}
+/**
+ * Callback type for goto command completion
+ */
+export type GotoCompletionCallback = (info: GotoCompletionInfo) => void;