ballistics-engine 0.13.3 → 0.13.4

package/README.md

@@ -1,614 +1,294 @@
-# Ballistics Engine
+# Ballistics Engine (WebAssembly)
 
-A high-performance ballistics trajectory calculation engine with comprehensive physics modeling, automatic zeroing, and statistical analysis capabilities.
+High-performance ballistics trajectory calculations for JavaScript and TypeScript applications. This package provides WebAssembly bindings for the ballistics-engine library, delivering near-native performance in the browser.
 
 **Project Website:** [https://ballistics.rs/](https://ballistics.rs/)
 
-## Features
-
-- **Full 3D Trajectory Integration** - Six-state ballistic modeling with adaptive RK45 and fixed-step RK4 integration methods
-- **Advanced Drag Models** - Support for G1, G7, and custom drag curves with automatic transonic corrections
-- **Automatic Zeroing** - Calculate sight adjustments and apply zero angles automatically
-- **Unit Conversion** - Seamless switching between Imperial (default) and Metric units
-- **BC Segmentation** - Velocity-dependent ballistic coefficient modeling with automatic estimation
-- **Atmospheric Modeling** - Temperature, pressure, humidity, and altitude effects with ICAO standard atmosphere
-- **Wind Effects** - 3D wind calculations with altitude-dependent wind shear modeling
-- **Monte Carlo Simulations** - Statistical analysis with parameter uncertainties
-- **BC Estimation** - Estimate ballistic coefficients from trajectory data
-- **Advanced Physics**:
-  - **Spin Effects**: Magnus effect, enhanced spin drift with decay modeling
-  - **Earth Effects**: Coriolis effect with latitude-dependent calculations
-  - **Angular Motion**: Gyroscopic precession and nutation physics
-  - **Transonic Analysis**: Pitch damping coefficients and stability warnings
-  - **Trajectory Sampling**: Regular interval data collection for analysis
-  - **Form Factor Corrections**: Bullet-specific drag adjustments
-- **Multiple Output Formats** - JSON, CSV, and formatted tables
-
 ## Installation
 
-### From Source
-
 ```bash
-git clone https://github.com/ajokela/ballistics-engine.git
-cd ballistics-engine
-cargo build --release
+npm install ballistics-engine
 ```
 
-The binary will be at: `target/release/ballistics`
-
 ## Quick Start
 
-### Basic Trajectory (Imperial Units - Default)
+### ES Modules (Browser/Bundler)
 
-```bash
-# .308 Winchester, 168gr bullet at 2700 fps
-./ballistics trajectory -v 2700 -b 0.475 -m 168 -d 0.308 --max-range 1000
+```javascript
+import init, { Calculator } from 'ballistics-engine';
 
-# With automatic zeroing at 200 yards
-./ballistics trajectory -v 2700 -b 0.475 -m 168 -d 0.308 --auto-zero 200 --max-range 500
-```
+// Initialize the WASM module first
+await init();
 
-### Metric Units
+// Create a calculator with default values (.308 Win, 168gr at 2700 fps)
+const calc = new Calculator();
 
-```bash
-# Same bullet in metric units
-./ballistics trajectory --units metric -v 823 -b 0.475 -m 10.9 -d 7.82 --max-range 1000
-```
+// Configure your load
+calc
+  .setVelocity(2700)           // fps
+  .setBC(0.475)                // G1 ballistic coefficient
+  .setMass(168)                // grains
+  .setDiameter(0.308)          // inches
+  .setZeroRange(200)           // zero at 200 yards
+  .setWind(10, 90);            // 10 mph from the right
 
-## Unit Systems
+// Calculate trajectory at a specific range
+const result = calc.calculateTrajectory(500);
+console.log(result);
+// { range_yards: 500, drop_inches: -48.2, windage_inches: 15.3, velocity_fps: 2145, energy_ftlb: 1715, time_sec: 0.62 }
 
-The engine supports two unit systems, selectable with the `--units` flag:
+// Get full trajectory table
+const trajectory = calc.getFullTrajectory();
+console.log(trajectory);
+// Array of trajectory points from 0 to max range
 
-### Imperial (Default)
-- **Velocity**: feet per second (fps)
-- **Mass**: grains
-- **Distance**: yards
-- **Diameter**: inches
-- **Temperature**: Fahrenheit
-- **Pressure**: inHg
-- **Wind**: mph
+// Clean up when done
+calc.free();
+```
 
-### Metric
-- **Velocity**: meters per second (m/s)
-- **Mass**: grams
-- **Distance**: meters
-- **Diameter**: millimeters
-- **Temperature**: Celsius
-- **Pressure**: hPa (millibars)
-- **Wind**: m/s
+### With TypeScript
 
-## Commands
+```typescript
+import init, { Calculator } from 'ballistics-engine';
 
-### Trajectory Calculation
+async function main() {
+  await init();
 
-Calculate ballistic trajectory with environmental conditions:
+  const calc = new Calculator()
+    .setVelocity(3000)
+    .setBC(0.620)
+    .setMass(140)
+    .setDiameter(0.264)
+    .setDragModel('g7')
+    .setZeroRange(100);
 
-```bash
-# Imperial units (default)
-./ballistics trajectory \
-  -v 2700          # Velocity (fps)
-  -b 0.475         # Ballistic coefficient
-  -m 168           # Mass (grains)
-  -d 0.308         # Diameter (inches)
-  --drag-model g7  # G7 drag model
-  --angle 0        # Launch angle (degrees)
-  --max-range 1000 # Maximum range (yards)
-  --wind-speed 10  # Wind speed (mph)
-  --wind-direction 90  # Wind from right (degrees)
-  --temperature 59     # Temperature (Fahrenheit)
-  --pressure 29.92    # Pressure (inHg)
-  --humidity 50       # Relative humidity (%)
-  --altitude 0        # Altitude (feet)
-  --full             # Show all trajectory points
-```
+  const result = calc.calculateTrajectory(1000);
+  console.log(`Drop at 1000 yards: ${result.drop_inches.toFixed(1)} inches`);
 
-#### Auto-Zero Feature
-
-Automatically calculate and apply the zero angle for a specific distance:
+  calc.free();
+}
 
-```bash
-# Zero at 200 yards and show trajectory to 500 yards
-./ballistics trajectory \
-  -v 2700 -b 0.475 -m 168 -d 0.308 \
-  --auto-zero 200 \  # Automatically zero at 200 yards
-  --max-range 500 \
-  --full
-
-# Custom sight height for auto-zero
-./ballistics trajectory \
-  -v 2700 -b 0.475 -m 168 -d 0.308 \
-  --auto-zero 100 \
-  --sight-height 0.055  # 2.2 inches in yards
+main();
 ```
 
-#### Advanced BC Modeling
+## API Reference
 
-Enable velocity-dependent BC modeling for more accurate long-range predictions:
+### Calculator Class
 
-```bash
-# Enable BC segmentation (velocity-based BC changes)
-./ballistics trajectory \
-  -v 2700 -b 0.475 -m 168 -d 0.308 \
-  --use-bc-segments \
-  --auto-zero 600 \
-  --max-range 1000
-```
+A fluent, chainable API for trajectory calculations.
 
-#### Advanced Physics - Magnus and Spin Drift
+#### Constructor
 
-Enable advanced gyroscopic and aerodynamic effects:
-
-```bash
-# Magnus effect and spin drift calculation
-./ballistics trajectory \
-  -v 2700 -b 0.475 -m 168 -d 0.308 \
-  --twist-rate 10      # 1:10" barrel twist
-  --twist-right        # Right-hand twist
-  --enable-magnus      # Enable Magnus effect
-  --enable-spin-drift  # Enable enhanced spin drift
-  --wind-speed 10 \
-  --wind-direction 90 \
-  --max-range 1000
-
-# Coriolis effect for extreme long range
-./ballistics trajectory \
-  -v 3000 -b 0.750 -m 250 -d 0.338 \
-  --enable-coriolis \
-  --latitude 45        # Shooting latitude
-  --shooting-angle 90  # Azimuth (0=N, 90=E)
-  --max-range 2000
+```javascript
+const calc = new Calculator();
 ```
 
-### Zero Calculation
-
-Calculate the sight adjustment needed to zero at a specific distance:
-
-```bash
-# Calculate zero for 200 yards
-./ballistics zero \
-  -v 2700 -b 0.475 -m 168 -d 0.308 \
-  --target-distance 200
-
-# With custom sight height (default is 0.05 yards / 1.8 inches)
-./ballistics zero \
-  -v 2700 -b 0.475 -m 168 -d 0.308 \
-  --target-distance 300 \
-  --sight-height 0.055  # 2.2 inches
-
-# Metric example
-./ballistics zero --units metric \
-  -v 823 -b 0.475 -m 10.9 -d 7.82 \
-  --target-distance 200  # 200 meters
+Creates a calculator with sensible defaults:
+- .308 Winchester 168gr at 2700 fps
+- G1 drag model
+- Standard atmosphere (59°F, 29.92 inHg)
+
+#### Configuration Methods
+
+All methods return `this` for chaining.
+
+| Method | Parameters | Description |
+|--------|------------|-------------|
+| `setVelocity(fps)` | `number` | Muzzle velocity in feet per second |
+| `setBC(bc)` | `number` | Ballistic coefficient (G1 or G7) |
+| `setMass(grains)` | `number` | Bullet weight in grains |
+| `setDiameter(inches)` | `number` | Bullet diameter in inches |
+| `setDragModel(model)` | `'g1'` \| `'g7'` | Drag model to use |
+| `setZeroRange(yards)` | `number` | Zero distance in yards |
+| `setSightHeight(inches)` | `number` | Scope height above bore |
+| `setMaxRange(yards)` | `number` | Maximum calculation range |
+| `setWind(mph, degrees)` | `number, number` | Wind speed and direction (0°=headwind, 90°=from right) |
+| `setTemperature(fahrenheit)` | `number` | Ambient temperature |
+| `setPressure(inHg)` | `number` | Barometric pressure |
+| `setHumidity(percent)` | `number` | Relative humidity (0-100) |
+| `setAltitude(feet)` | `number` | Shooting altitude |
+| `enableSpinDrift(enabled, twistRate?)` | `boolean, number?` | Enable spin drift (twist rate in inches) |
+| `enableCoriolis(enabled, latitude?)` | `boolean, number?` | Enable Coriolis effect |
+
+#### Calculation Methods
+
+```javascript
+// Calculate at specific range
+const point = calc.calculateTrajectory(500);
+
+// Get full trajectory table
+const trajectory = calc.getFullTrajectory();
 ```
 
-Output includes:
-- Zero angle in degrees
-- Adjustment in MOA (Minutes of Angle)
-- Adjustment in mrad (milliradians)
-- Maximum ordinate (highest point of trajectory)
-
-### Monte Carlo Simulation
-
-Run statistical analysis with parameter variations:
+#### Result Object
 
-```bash
-./ballistics monte-carlo \
-  -v 2700         # Base velocity (fps)
-  -b 0.475        # Base BC
-  -m 168          # Mass (grains)
-  -d 0.308        # Diameter (inches)
-  -n 1000         # Number of simulations
-  --velocity-std 10    # Velocity std dev (fps)
-  --angle-std 0.5     # Angle std dev (degrees)
-  --bc-std 0.01       # BC std dev
-  --wind-std 2        # Wind speed std dev (mph)
-  --target-distance 300  # Target distance for hit probability
+```typescript
+interface TrajectoryPoint {
+  range_yards: number;      // Distance from muzzle
+  drop_inches: number;      // Bullet drop (negative = below line of sight)
+  windage_inches: number;   // Wind deflection (positive = right)
+  velocity_fps: number;     // Remaining velocity
+  energy_ftlb: number;      // Remaining energy
+  time_sec: number;         // Time of flight
+}
 ```
 
-### BC Estimation
-
-Estimate ballistic coefficient from observed trajectory data:
-
-```bash
-./ballistics estimate-bc \
-  -v 2700 -m 168 -d 0.308 \
-  --distance1 100 --drop1 0.0   # First data point
-  --distance2 200 --drop2 0.023  # Second data point
-```
+### WasmBallistics Class
 
-## Advanced Features
+A CLI-style interface for running commands as strings.
 
-### Integration Methods
+```javascript
+import init, { WasmBallistics } from 'ballistics-engine';
 
-The engine supports two numerical integration methods:
+await init();
 
-- **RK45 (Dormand-Prince Adaptive)** - Default method, provides best accuracy with adaptive step sizing
-- **RK4 (Runge-Kutta 4th Order Fixed-Step)** - Available with `--use-rk4-fixed` flag for faster computation
+const ballistics = new WasmBallistics();
 
-### Wind Shear Modeling
+// Run trajectory command
+const output = ballistics.runCommand(
+  'trajectory -v 2700 -b 0.475 -m 168 -d 0.308 --auto-zero 200 --max-range 1000 -o json'
+);
 
-Model altitude-dependent wind variations:
+console.log(JSON.parse(output));
 
-```bash
-./ballistics trajectory -v 2700 -b 0.475 -m 168 -d 0.308 \
-  --wind-speed 10 --wind-direction 90 \
-  --enable-wind-shear \
-  --max-range 1000
+ballistics.free();
 ```
 
-### Transonic Stability Analysis
-
-Analyze projectile stability through the transonic regime:
-
-```bash
-./ballistics trajectory -v 3000 -b 0.475 -m 168 -d 0.308 \
-  --enable-pitch-damping \
-  --max-range 2000
-```
+## Examples
 
-Provides warnings about transonic instability and minimum pitch damping coefficients.
+### Long-Range Trajectory
 
-### Trajectory Sampling
+```javascript
+const calc = new Calculator()
+  .setVelocity(2850)
+  .setBC(0.690)              // G7 BC
+  .setMass(230)
+  .setDiameter(0.338)
+  .setDragModel('g7')
+  .setZeroRange(100)
+  .setMaxRange(1500)
+  .setWind(10, 270)          // 10 mph from left
+  .setAltitude(5000)         // High altitude
+  .setTemperature(75);
 
-Collect trajectory data at regular intervals for detailed analysis:
+const trajectory = calc.getFullTrajectory();
 
-```bash
-./ballistics trajectory -v 2700 -b 0.475 -m 168 -d 0.308 \
-  --sample-trajectory \
-  --sample-interval 25  # Sample every 25 yards
-  --max-range 1000 -o json
+// Find data at 1000 yards
+const point1000 = trajectory.find(p => p.range_yards === 1000);
+console.log(`At 1000 yards: ${point1000.drop_inches.toFixed(1)}" drop, ${point1000.windage_inches.toFixed(1)}" wind`);
 ```
 
-### Angular Motion Physics
-
-Model precession and nutation of spinning projectiles:
+### Environmental Effects
 
-```bash
-./ballistics trajectory -v 2700 -b 0.475 -m 168 -d 0.308 \
-  --twist-rate 10 \
-  --enable-precession \
-  --max-range 1000
+```javascript
+// Hot day, high altitude
+const calc = new Calculator()
+  .setVelocity(2700)
+  .setBC(0.475)
+  .setMass(168)
+  .setDiameter(0.308)
+  .setTemperature(95)        // Hot day
+  .setAltitude(8000)         // Mountain shooting
+  .setPressure(24.5)         // Lower pressure at altitude
+  .setHumidity(20);          // Dry air
+
+// Velocity will stay higher due to thinner air
 ```
 
-### Complete Advanced Physics Example
-
-```bash
-./ballistics trajectory \
-  -v 2850 -b 0.690 -m 230 -d 0.338 \
-  --drag-model g7 \
-  --twist-rate 8.5 --twist-right \
-  --enable-magnus \
-  --enable-coriolis \
-  --enable-spin-drift \
-  --enable-wind-shear \
-  --enable-pitch-damping \
-  --enable-precession \
-  --sample-trajectory \
-  --latitude 38.5 \
-  --shooting-angle 45 \
-  --wind-speed 15 --wind-direction 270 \
-  --altitude 6000 \
-  --max-range 2000
+### With Spin Drift
+
+```javascript
+const calc = new Calculator()
+  .setVelocity(2700)
+  .setBC(0.475)
+  .setMass(168)
+  .setDiameter(0.308)
+  .enableSpinDrift(true, 10)  // 1:10" twist, right-hand
+  .setZeroRange(100)
+  .setMaxRange(1000);
+
+// Spin drift adds to windage at long range
+const point = calc.calculateTrajectory(1000);
+console.log(`Spin drift at 1000: ${point.windage_inches.toFixed(1)}"`);
 ```
 
-## Physics Modeling
-
-The ballistics engine implements comprehensive physics modeling for accurate trajectory prediction:
+## Browser Usage
 
-### Aerodynamic Effects
-- **Drag Modeling** - Multiple drag functions (G1-G8, JBM, custom curves) with transonic flow corrections
-- **Form Factor** - Projectile efficiency corrections based on shape and design
-- **Reynolds Number Effects** - Viscosity and flow regime corrections
+### With a Bundler (Vite, Webpack, etc.)
 
-### Gyroscopic Effects  
-- **Spin Drift** - Lateral deviation due to gyroscopic and Magnus effects
-- **Precession** - Gyroscopic precession of spinning projectile
-- **Nutation** - Oscillatory motion superimposed on precession
-- **Spin Decay** - Reduction in spin rate over time due to aerodynamic damping
-- **Pitch Damping** - Aerodynamic moments opposing angular motion
+```javascript
+import init, { Calculator } from 'ballistics-engine';
 
-### Environmental Effects
-- **Coriolis Effect** - Earth's rotation influence on long-range trajectories
-- **Magnus Effect** - Force from spinning projectile in crossflow
-- **Wind Shear** - Altitude-dependent wind variations
-- **Atmospheric Stratification** - Density and sound speed variations with altitude
-
-### Stability Modeling
-- **Dynamic Stability** - Gyroscopic and aerodynamic stability calculations
-- **Yaw of Repose** - Equilibrium yaw angle in crosswind
-- **Limit Cycle Yaw** - Bounded oscillatory motion analysis
-
-## FFI Layer
-
-The library includes a Foreign Function Interface (FFI) layer for integration with iOS, Android, and other platforms. The FFI provides C-compatible bindings for all major functionality.
-
-<img src="ios.png" alt="iOS Integration Example" width="35%">
-
-### FFI Features
-- **C-Compatible Structures** - All data structures use C-compatible layouts
-- **Safe Memory Management** - Proper handling of memory across language boundaries
-- **iOS/Swift Integration** - Ready for use with Swift through bridging headers
-- **Android/JNI Support** - Compatible with Java Native Interface
-- **Monte Carlo Simulation** - Statistical analysis with parameter variations
-- **Error Handling** - Graceful error propagation across FFI boundary
-
-### Example FFI Usage (C/Swift)
-```c
-// Create input parameters
-FFIBallisticInputs inputs = {
-    .muzzle_velocity = 823.0,        // m/s
-    .ballistic_coefficient = 0.475,
-    .mass = 0.0109,                  // kg
-    .diameter = 0.00782,             // meters
-    .drag_model = 0,                 // G1
-    .sight_height = 0.05,            // meters
-    .temperature = 15.0,             // Celsius
-    .altitude = 0.0
-};
-
-// Calculate trajectory
-FFITrajectoryResult* result = ballistics_calculate_trajectory(&inputs, NULL, NULL, 1000.0, 0.1);
-
-// Use results
-printf("Max range: %.2f meters\n", result->max_range);
-
-// Clean up
-ballistics_free_trajectory_result(result);
-```
-
-### Monte Carlo Simulation via FFI
-```c
-// Set up Monte Carlo parameters
-FFIMonteCarloParams params = {
-    .num_simulations = 1000,
-    .velocity_std_dev = 10.0,       // m/s variation
-    .angle_std_dev = 0.001,         // radian variation (elevation)
-    .bc_std_dev = 0.01,             // BC variation
-    .wind_speed_std_dev = 2.0,      // m/s wind variation
-    .target_distance = 600.0,       // Target at 600m
-    .azimuth_std_dev = 0.001        // radian variation (horizontal)
-};
-
-// Run simulation
-FFIMonteCarloResults* results = ballistics_monte_carlo(&inputs, NULL, &params);
-
-// Use statistical results
-printf("Mean range: %.2f m (σ=%.2f)\n", results->mean_range, results->std_dev_range);
-printf("Hit probability at 600m: %.1f%%\n", results->hit_probability * 100);
-
-// Access individual shots
-for (int i = 0; i < results->num_results; i++) {
-    printf("Shot %d: Range %.2f m, Impact velocity %.2f m/s\n", 
-           i, results->ranges[i], results->impact_velocities[i]);
+async function setupBallistics() {
+  await init();
+  // Ready to use
 }
-
-// Clean up
-ballistics_free_monte_carlo_results(results);
 ```
 
-## Output Formats
-
-All commands support three output formats via the `-o` flag:
-
-- **table** (default) - Formatted ASCII table for terminal display
-- **json** - Complete data in JSON format for programmatic use
-- **csv** - Comma-separated values for spreadsheet analysis
+### Without a Bundler (Script Tag)
 
-## Practical Examples
+```html
+<script type="module">
+  import init, { Calculator } from './node_modules/ballistics-engine/ballistics_engine.js';
 
-### Hunting Zero
-
-Zero a hunting rifle at 200 yards with environmental conditions:
-
-```bash
-# Calculate zero angle
-./ballistics zero \
-  -v 2650 -b 0.460 -m 180 -d 0.308 \
-  --target-distance 200
-
-# Verify trajectory with auto-zero
-./ballistics trajectory \
-  -v 2650 -b 0.460 -m 180 -d 0.308 \
-  --auto-zero 200 \
-  --max-range 400 \
-  --wind-speed 15 \
-  --wind-direction 270 \
-  --temperature 32 \
-  --humidity 30 \
-  --altitude 5000 \
-  --full
+  init().then(() => {
+    const calc = new Calculator();
+    // ...
+  });
+</script>
 ```
 
-### Long Range Shooting
+## Performance
 
-Analyze trajectory for 1000-yard shot:
+WebAssembly provides near-native performance:
 
-```bash
-./ballistics trajectory \
-  -v 2850 -b 0.690 -m 230 -d 0.338 \
-  --drag-model g7 \
-  --auto-zero 100 \
-  --max-range 1100 \
-  --wind-speed 10 \
-  --wind-direction 45 \
-  --full \
-  -o json > trajectory.json
-```
+- Single trajectory (1000 yards): ~1ms
+- Full trajectory table (1500 points): ~5ms
+- Zero calculation: ~2ms
 
-### Load Development
+## TypeScript Support
 
-Compare different loads using Monte Carlo:
+Full TypeScript definitions are included. Import types:
 
-```bash
-# Load 1: Higher velocity, more variation
-./ballistics monte-carlo \
-  -v 2750 -b 0.475 -m 168 -d 0.308 \
-  -n 1000 \
-  --velocity-std 15 \
-  --target-distance 600
-
-# Load 2: Lower velocity, more consistent
-./ballistics monte-carlo \
-  -v 2680 -b 0.475 -m 168 -d 0.308 \
-  -n 1000 \
-  --velocity-std 8 \
-  --target-distance 600
+```typescript
+import type { Calculator, WasmBallistics } from 'ballistics-engine';
 ```
 
-## Advanced Features
-
-### BC Segmentation
-
-Velocity-dependent BC modeling accounts for how ballistic coefficient changes as the bullet slows down. Enable with `--use-bc-segments`:
+## Memory Management
 
-- Automatically estimates BC segments based on bullet characteristics
-- No external data required - uses caliber, weight, and BC
-- Identifies bullet type (Match, Hunting, VLD, etc.) from parameters
-- Applies physics-based BC degradation curves
+The Calculator and WasmBallistics classes allocate memory in the WASM heap. Call `.free()` when done to prevent memory leaks:
 
-Example:
-```bash
-./ballistics trajectory -v 2700 -b 0.475 -m 168 -d 0.308 --use-bc-segments --max-range 1000
+```javascript
+const calc = new Calculator();
+try {
+  // Use calculator
+  const result = calc.calculateTrajectory(500);
+} finally {
+  calc.free();
+}
 ```
 
+Or use the `Symbol.dispose` for automatic cleanup (when supported):
 
-### Advanced Physics Modeling
-
-When enabled, the engine calculates:
-- **Magnus Effect** - Side force from spinning projectiles
-- **Spin Drift** - Lateral drift due to gyroscopic effects
-- **Coriolis Effect** - Earth rotation effects (with latitude input)
-- **Transonic Drag** - Enhanced drag modeling in transonic regime
-- **Reynolds Number Corrections** - Viscous effects at low velocities
-
-## Building from Source
-
-### Requirements
-
-- Rust 1.70 or later
-- Cargo build system
-
-### Build Commands
-
-```bash
-# Debug build
-cargo build
-
-# Release build (optimized)
-cargo build --release
-
-# Run tests
-cargo test
-
-# Build documentation
-cargo doc --open
+```typescript
+{
+  using calc = new Calculator();
+  const result = calc.calculateTrajectory(500);
+} // Automatically freed
 ```
 
-## Library Usage
-
-Use as a Rust library in your own projects:
-
-```rust
-use ballistics_engine::{
-    BallisticInputs, TrajectorySolver, 
-    WindConditions, AtmosphericConditions
-};
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let inputs = BallisticInputs {
-        muzzle_velocity: 823.0,  // m/s
-        launch_angle: 0.0,       // radians
-        ballistic_coefficient: 0.475,
-        mass: 0.0109,            // kg
-        diameter: 0.00782,       // meters
-        sight_height: 0.05,      // meters
-        ..Default::default()
-    };
-    
-    let wind = WindConditions {
-        speed: 5.0,              // m/s
-        direction: 1.5708,       // 90 degrees in radians
-        ..Default::default()
-    };
-    
-    let atmosphere = AtmosphericConditions {
-        temperature: 15.0,       // Celsius
-        pressure: 1013.25,       // hPa
-        humidity: 50.0,          // %
-        altitude: 0.0,           // meters
-        ..Default::default()
-    };
-    
-    let solver = TrajectorySolver::new(inputs, wind, atmosphere);
-    let result = solver.solve()?;
-    
-    println!("Max range: {:.2} m", result.max_range);
-    println!("Max height: {:.2} m", result.max_height);
-    println!("Time of flight: {:.3} s", result.time_of_flight);
-    
-    Ok(())
-}
-```
+## Related Packages
 
-## Performance
-
-Optimized Rust implementation provides:
-- Single trajectory (1000m): ~5ms
-- Monte Carlo (1000 runs): ~500ms  
-- BC estimation: ~50ms
-- Zero calculation: ~10ms
-
-## Common Ballistic Coefficients
-
-| Caliber | Weight | BC (G1) | BC (G7) | Description |
-|---------|--------|---------|---------|-------------|
-| .223    | 55gr   | 0.250   | -       | FMJ |
-| .223    | 77gr   | 0.362   | 0.182   | Match |
-| .308    | 168gr  | 0.475   | 0.224   | Match |
-| .308    | 175gr  | 0.505   | 0.253   | Match |
-| .308    | 180gr  | 0.480   | -       | Hunting |
-| .338    | 300gr  | 0.768   | 0.383   | Match |
-| 6.5mm   | 140gr  | 0.620   | 0.310   | Match |
-| .50     | 750gr  | 1.050   | 0.520   | Match |
-
-## Troubleshooting
-
-### Trajectory hits ground early
-- Check if you're using `--auto-zero` or setting `--angle` manually
-- Default angle is 0° (horizontal), which will hit ground quickly
-- Use `--auto-zero <distance>` to automatically calculate proper angle
-
-### Units confusion
-- Default is Imperial (fps, grains, yards)
-- Use `--units metric` for metric system
-- All inputs must match the selected unit system
-
-### Unexpected BC behavior
-- G1 and G7 models have different BC values for same bullet
-- G7 typically better for boat-tail bullets
-- BC segmentation automatically applied based on bullet type
-
-## Contributing
-
-Contributions are welcome! Please:
-1. Fork the repository
-2. Create a feature branch
-3. Add tests for new features
-4. Run `cargo test` and `cargo fmt`
-5. Submit a pull request
+- **Node.js package**: Use `ballistics-engine` from npm (same package, works in Node.js too)
+- **Rust crate**: [crates.io/crates/ballistics-engine](https://crates.io/crates/ballistics-engine)
+- **Python package**: [pypi.org/project/ballistics-engine](https://pypi.org/project/ballistics-engine/)
 
 ## License
 
-This project is licensed under the MIT License - see LICENSE file for details.
-
-## Acknowledgments
-
-- Ballistics physics based on Robert McCoy's "Modern Exterior Ballistics"
-- Drag tables from military ballistics research
-- BC segmentation algorithms from Bryan Litz's research
-- Community contributions and testing
+MIT OR Apache-2.0
 
-## Support
+## Links
 
-For issues, questions, or contributions:
-- GitHub Issues: [github.com/ajokela/ballistics-engine/issues](https://github.com/ajokela/ballistics-engine/issues)
+- [Documentation](https://docs.ballistics.rs/)
+- [GitHub Repository](https://github.com/ajokela/ballistics-engine)
+- [Live Demo](https://ballistics.sh/)