ballistics-engine 0.13.4 → 0.25.1

package/README.md

@@ -1,294 +1,131 @@
-# Ballistics Engine (WebAssembly)
+# ballistics-engine (WASM)
 
-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.
+WebAssembly build of [`ballistics-engine`](https://github.com/ajokela/ballistics-engine), a
+high-performance ballistics trajectory engine (RK4 integration, wind/Coriolis/spin-drift/Magnus
+effects, custom drag tables, Monte Carlo, and more). This package exposes the same CLI-style
+command surface as the native Rust binary, plus a small object-oriented `Calculator` class, to
+JavaScript/TypeScript.
 
-**Project Website:** [https://ballistics.rs/](https://ballistics.rs/)
+Built with `wasm-pack` and `--no-default-features` — the native crate's default `pdf`/`online`
+features pull in dependencies that don't compile for `wasm32-unknown-unknown`, so the PDF dope-card
+export and the online BC-estimation API are not available from WASM.
 
-## Installation
+> This package is built from `pkg/` (the `wasm-pack --target bundler` output) via
+> `scripts/build-npm.sh` in the source repo. The same script also produces a `pkg-web/` build
+> (`--target web`) for use without a bundler — see "Browser without a bundler" below.
 
-```bash
-npm install ballistics-engine
-```
-
-## Quick Start
-
-### ES Modules (Browser/Bundler)
-
-```javascript
-import init, { Calculator } from 'ballistics-engine';
-
-// Initialize the WASM module first
-await init();
-
-// Create a calculator with default values (.308 Win, 168gr at 2700 fps)
-const calc = new Calculator();
-
-// 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
-
-// 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 }
-
-// Get full trajectory table
-const trajectory = calc.getFullTrajectory();
-console.log(trajectory);
-// Array of trajectory points from 0 to max range
-
-// Clean up when done
-calc.free();
-```
-
-### With TypeScript
-
-```typescript
-import init, { Calculator } from 'ballistics-engine';
-
-async function main() {
-  await init();
-
-  const calc = new Calculator()
-    .setVelocity(3000)
-    .setBC(0.620)
-    .setMass(140)
-    .setDiameter(0.264)
-    .setDragModel('g7')
-    .setZeroRange(100);
-
-  const result = calc.calculateTrajectory(1000);
-  console.log(`Drop at 1000 yards: ${result.drop_inches.toFixed(1)} inches`);
-
-  calc.free();
-}
-
-main();
-```
-
-## API Reference
-
-### Calculator Class
+## Install
 
-A fluent, chainable API for trajectory calculations.
-
-#### Constructor
-
-```javascript
-const calc = new Calculator();
-```
-
-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();
-```
-
-#### Result Object
-
-```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
-}
+```bash
+npm install @SCOPE/ballistics-engine
 ```
 
-### WasmBallistics Class
+`@SCOPE` is a placeholder — see the source repo's `README.md` ("WASM / npm Package" section) for
+the real published name once one exists.
 
-A CLI-style interface for running commands as strings.
+## Quick start (bundler: webpack, Vite, Rollup, Parcel)
 
-```javascript
-import init, { WasmBallistics } from 'ballistics-engine';
+This package's `main` entry imports its `.wasm` file as a native ES module, which is how
+`wasm-pack --target bundler` output is meant to be consumed. It works out of the box with Vite and
+Rollup (`@rollup/plugin-wasm`), and with webpack once `experiments.asyncWebAssembly` (or
+`experiments.syncWebAssembly`) is enabled — check your bundler's WASM docs if the import fails.
 
-await init();
+```js
+import { WasmBallistics } from '@SCOPE/ballistics-engine';
 
-const ballistics = new WasmBallistics();
+const calc = new WasmBallistics();
 
-// 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'
+// The command surface mirrors the native CLI (see CLI_USAGE.md in the source repo for the full
+// flag reference): .308 Winchester, 168gr @ 2700 fps, zeroed at 200 yd, table out to 500 yd.
+const table = calc.runCommand(
+  'trajectory -v 2700 -b 0.475 -m 168 -d 0.308 --max-range 500 --auto-zero 200',
 );
-
-console.log(JSON.parse(output));
-
-ballistics.free();
+console.log(table);
 ```
 
-## Examples
-
-### Long-Range Trajectory
-
-```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);
+### Custom drag tables (`loadDragTable`)
 
-const trajectory = calc.getFullTrajectory();
+Supply a measured or manufacturer-published Mach:Cd drag curve (Hornady CDM data, a Lapua/Doppler
+deck, or your own) instead of a G1/G7 model + BC. Once loaded it's applied automatically to every
+`trajectory`, `zero`, `lead`, and `monte-carlo` run — no extra flag needed.
 
-// 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`);
-```
-
-### Environmental Effects
-
-```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
-```
+```js
+const csv = 'mach,cd\n0.5,0.220\n0.8,0.230\n1.0,0.520\n1.2,0.480\n1.5,0.400\n2.0,0.330\n2.5,0.300\n';
+calc.loadDragTable(new TextEncoder().encode(csv));
+calc.hasDragTable(); // true
 
-### 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)}"`);
+calc.runCommand('trajectory -v 2700 -b 0.475 -m 168 -d 0.308 --max-range 500');
 ```
 
-## Browser Usage
+`loadDragTable` takes raw bytes because WASM has no filesystem access — fetch the CSV yourself
+(`fetch()` in the browser, `fs.readFileSync` in Node) and pass the bytes in. The CSV format is
+documented in the source repo's `CLI_USAGE.md` ("Custom Drag Tables"); a matching
+`loadBc5dTable(bytes)` / `hasBc5dTable()` pair exists for BC5D correction tables.
 
-### With a Bundler (Vite, Webpack, etc.)
-
-```javascript
-import init, { Calculator } from 'ballistics-engine';
-
-async function setupBallistics() {
-  await init();
-  // Ready to use
-}
-```
+## Browser without a bundler
 
-### Without a Bundler (Script Tag)
+For a plain `<script type="module">` page (no build step), use the `pkg-web/` build instead —
+produced by the same `scripts/build-npm.sh`, and the same build already deployed at
+[ballistics.sh](https://ballistics.sh). It ships an explicit async `init()` you call once before
+constructing `WasmBallistics`:
 
 ```html
 <script type="module">
-  import init, { Calculator } from './node_modules/ballistics-engine/ballistics_engine.js';
+  import init, { WasmBallistics } from './ballistics_engine.js';
 
-  init().then(() => {
-    const calc = new Calculator();
-    // ...
-  });
+  await init(); // fetches and instantiates ballistics_engine_bg.wasm relative to this file
+  const calc = new WasmBallistics();
+  console.log(calc.runCommand('trajectory -v 2700 -b 0.475 -m 168 -d 0.308 --max-range 500'));
 </script>
 ```
 
-## Performance
+Serve `ballistics_engine.js` and `ballistics_engine_bg.wasm` from the same directory, and make sure
+your host serves `.wasm` with `Content-Type: application/wasm` (all major static hosts and CDNs do
+this by default).
 
-WebAssembly provides near-native performance:
+This `pkg-web/` build is not published to npm as part of this package in the current release —
+it's built locally alongside `pkg/` for direct use or self-hosting. If you need it from npm, either
+vendor the files from `pkg-web/` yourself or publish it as a second package.
 
-- Single trajectory (1000 yards): ~1ms
-- Full trajectory table (1500 points): ~5ms
-- Zero calculation: ~2ms
+### Node.js without a bundler
 
-## TypeScript Support
+Plain Node `import`/`require` cannot load this package's bundler-target `.wasm` import directly.
+Use the `pkg-web/` build instead, passing the file bytes explicitly (Node's `fetch()` does not
+support `file://` URLs):
 
-Full TypeScript definitions are included. Import types:
+```js
+import { readFileSync } from 'node:fs';
+import init, { WasmBallistics } from './pkg-web/ballistics_engine.js';
 
-```typescript
-import type { Calculator, WasmBallistics } from 'ballistics-engine';
-```
-
-## Memory Management
-
-The Calculator and WasmBallistics classes allocate memory in the WASM heap. Call `.free()` when done to prevent memory leaks:
+const wasmBytes = readFileSync(new URL('./pkg-web/ballistics_engine_bg.wasm', import.meta.url));
+await init({ module_or_path: wasmBytes });
 
-```javascript
-const calc = new Calculator();
-try {
-  // Use calculator
-  const result = calc.calculateTrajectory(500);
-} finally {
-  calc.free();
-}
+const calc = new WasmBallistics();
+console.log(calc.runCommand('trajectory -v 2700 -b 0.475 -m 168 -d 0.308 --max-range 500'));
 ```
 
-Or use the `Symbol.dispose` for automatic cleanup (when supported):
-
-```typescript
-{
-  using calc = new Calculator();
-  const result = calc.calculateTrajectory(500);
-} // Automatically freed
-```
+If you need a CommonJS (`require()`) Node build, generate one yourself:
+`wasm-pack build --target nodejs --no-default-features`.
 
-## Related Packages
+## Caveats
 
-- **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/)
+- **Size**: the `.wasm` binary is roughly 430 KB (about 175 KB gzipped). It is not code-split or
+  lazily loaded — the whole engine loads up front.
+- **Single-threaded**: no SIMD/threads assumptions; no `SharedArrayBuffer` or
+  cross-origin-isolation (COOP/COEP) headers required.
+- **No filesystem/network**: table loaders (`loadDragTable`, `loadBc5dTable`) and any file-based
+  CLI flags (e.g. native `--drag-table <FILE>`) need the host to fetch bytes and hand them in; see
+  `loadDragTable` above.
+- **`pdf`/`online` features are unavailable**: this build excludes them (see above), so
+  PDF dope-card export and the online BC-estimation API are not part of the WASM surface.
+- Full API surface (including the `Calculator` builder class) is documented in the bundled
+  `.d.ts`; the full CLI flag reference `runCommand` accepts is documented in the source repo's
+  `CLI_USAGE.md`.
 
 ## License
 
-MIT OR Apache-2.0
+MIT OR Apache-2.0 — see `LICENSE` and `LICENSE-APACHE` in this package.
 
-## Links
+## Source
 
-- [Documentation](https://docs.ballistics.rs/)
-- [GitHub Repository](https://github.com/ajokela/ballistics-engine)
-- [Live Demo](https://ballistics.sh/)
+https://github.com/ajokela/ballistics-engine

package/ballistics_engine.d.ts

@@ -1,113 +1,123 @@
 /* tslint:disable */
 /* eslint-disable */
+
 /**
  * Object-oriented calculator for programmatic use
  * Provides a type-safe, fluent API alternative to the CLI interface
  */
 export class Calculator {
-  free(): void;
-  [Symbol.dispose](): void;
-  setAltitude(altitude_ft: number): Calculator;
-  setDiameter(diameter_inches: number): Calculator;
-  setHumidity(humidity: number): Calculator;
-  setPressure(pressure_inhg: number): Calculator;
-  setVelocity(velocity_fps: number): Calculator;
-  setMaxRange(range_yards: number): Calculator;
-  setDragModel(model: string): Calculator;
-  setZeroRange(range_yards: number): Calculator;
-  setTemperature(temp_f: number): Calculator;
-  setSightHeight(height_inches: number): Calculator;
-  enableCoriolis(enabled: boolean, latitude?: number | null): Calculator;
-  /**
-   * Get full trajectory table as array of points
-   * Returns array of: [{ range_yards, drop_inches, windage_inches, velocity_fps, energy_ftlb, time_sec }, ...]
-   */
-  getFullTrajectory(): any;
-  /**
-   * Calculate trajectory and return result as JavaScript object
-   * Returns: { range_yards, drop_inches, windage_inches, velocity_fps, energy_ftlb, time_sec }
-   */
-  calculateTrajectory(range_yards: number): any;
-  enableSpinDrift(enabled: boolean, twist_rate?: number | null): Calculator;
-  /**
-   * Create a new calculator with default values
-   * Defaults: .308 Winchester 168gr at 2700 fps, standard atmosphere
-   */
-  constructor();
-  setBC(bc: number): Calculator;
-  setMass(mass_grains: number): Calculator;
-  setWind(speed_mph: number, direction_deg: number): Calculator;
-}
-export class WasmBallistics {
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Run a command and return the output
-   */
-  runCommand(command: string): string;
-  constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add a downrange wind segment: `speed_mph` from `direction_deg`
+     * (wind-FROM: 0 = headwind, 90 = from the right) out to `until_yards`.
+     * Each segment applies from the previous boundary to `until_yards`; wind is
+     * zero beyond the last segment. When any segment is added it overrides the
+     * scalar `setWind` value. Repeatable.
+     */
+    addWindSegment(speed_mph: number, direction_deg: number, until_yards: number): Calculator;
+    /**
+     * Calculate trajectory and return result as JavaScript object
+     * Returns: { range_yards, drop_inches, windage_inches, velocity_fps, energy_ftlb, time_sec }
+     */
+    calculateTrajectory(range_yards: number): any;
+    /**
+     * Remove all downrange wind segments (reverts to the scalar `setWind`).
+     */
+    clearWindSegments(): Calculator;
+    enableCoriolis(enabled: boolean, latitude?: number | null): Calculator;
+    enableSpinDrift(enabled: boolean, twist_rate?: number | null): Calculator;
+    /**
+     * Get full trajectory table as array of points
+     * Returns array of: [{ range_yards, drop_inches, windage_inches, velocity_fps, energy_ftlb, time_sec }, ...]
+     */
+    getFullTrajectory(): any;
+    /**
+     * Create a new calculator with default values
+     * Defaults: .308 Winchester 168gr at 2700 fps, standard atmosphere
+     */
+    constructor();
+    setAltitude(altitude_ft: number): Calculator;
+    setBC(bc: number): Calculator;
+    setDiameter(diameter_inches: number): Calculator;
+    setDragModel(model: string): Calculator;
+    setHumidity(humidity: number): Calculator;
+    setMass(mass_grains: number): Calculator;
+    setMaxRange(range_yards: number): Calculator;
+    setPressure(pressure_inhg: number): Calculator;
+    setSightHeight(height_inches: number): Calculator;
+    setTemperature(temp_f: number): Calculator;
+    setVelocity(velocity_fps: number): Calculator;
+    setWind(speed_mph: number, direction_deg: number): Calculator;
+    setZeroRange(range_yards: number): Calculator;
 }
 
-export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
-
-export interface InitOutput {
-  readonly memory: WebAssembly.Memory;
-  readonly __wbg_calculator_free: (a: number, b: number) => void;
-  readonly __wbg_wasmballistics_free: (a: number, b: number) => void;
-  readonly ballistics_calculate_trajectory: (a: number, b: number, c: number, d: number, e: number) => number;
-  readonly ballistics_calculate_zero_angle: (a: number, b: number, c: number, d: number) => number;
-  readonly ballistics_free_monte_carlo_results: (a: number) => void;
-  readonly ballistics_free_trajectory_result: (a: number) => void;
-  readonly ballistics_get_version: () => number;
-  readonly ballistics_monte_carlo: (a: number, b: number, c: number) => number;
-  readonly ballistics_quick_trajectory: (a: number, b: number, c: number, d: number, e: number) => number;
-  readonly calculator_calculateTrajectory: (a: number, b: number) => [number, number, number];
-  readonly calculator_enableCoriolis: (a: number, b: number, c: number, d: number) => number;
-  readonly calculator_enableSpinDrift: (a: number, b: number, c: number, d: number) => number;
-  readonly calculator_getFullTrajectory: (a: number) => [number, number, number];
-  readonly calculator_new: () => number;
-  readonly calculator_setAltitude: (a: number, b: number) => number;
-  readonly calculator_setBC: (a: number, b: number) => number;
-  readonly calculator_setDiameter: (a: number, b: number) => number;
-  readonly calculator_setDragModel: (a: number, b: number, c: number) => number;
-  readonly calculator_setHumidity: (a: number, b: number) => number;
-  readonly calculator_setMass: (a: number, b: number) => number;
-  readonly calculator_setMaxRange: (a: number, b: number) => number;
-  readonly calculator_setPressure: (a: number, b: number) => number;
-  readonly calculator_setSightHeight: (a: number, b: number) => number;
-  readonly calculator_setTemperature: (a: number, b: number) => number;
-  readonly calculator_setVelocity: (a: number, b: number) => number;
-  readonly calculator_setWind: (a: number, b: number, c: number) => number;
-  readonly calculator_setZeroRange: (a: number, b: number) => number;
-  readonly wasmballistics_runCommand: (a: number, b: number, c: number) => [number, number, number, number];
-  readonly wasmballistics_new: () => number;
-  readonly __wbindgen_exn_store: (a: number) => void;
-  readonly __externref_table_alloc: () => number;
-  readonly __wbindgen_externrefs: WebAssembly.Table;
-  readonly __wbindgen_malloc: (a: number, b: number) => number;
-  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-  readonly __externref_table_dealloc: (a: number) => void;
-  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
-  readonly __wbindgen_start: () => void;
+export class WasmBallistics {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Unload any custom drag table previously installed via [`Self::load_drag_table`],
+     * reverting every subsequent `trajectory`, `zero`, `lead`, and `monte-carlo` run to the
+     * standard G-model + BC drag (the `-b`/`--bc` value with the selected G1/G7 curve).
+     *
+     * The inverse of `loadDragTable`. It lets a single engine instance alternate between a
+     * measured-curve (CDM) solve and a plain G7-BC solve without constructing a second
+     * instance: `load → solve CDM → clear → solve G7`, with the G7 half uncontaminated —
+     * the same load/clear pattern `clearWindSegments` provides for segmented wind.
+     *
+     * Returns `true` if a table was loaded (and is now cleared), `false` if none was loaded
+     * (a harmless no-op). Idempotent.
+     */
+    clearDragTable(): boolean;
+    /**
+     * Report whether a BC5D table is currently loaded.
+     */
+    hasBc5dTable(): boolean;
+    /**
+     * Report whether a custom drag table is currently loaded.
+     */
+    hasDragTable(): boolean;
+    /**
+     * Load a BC5D correction table from the raw bytes of a `bc5d_<caliber>.bin`
+     * file. The host (browser `fetch()` or Node `fs`/`fetch`) is responsible
+     * for retrieving the file — WASM has no filesystem or network — and passes
+     * the bytes here.
+     *
+     * Once loaded, any `trajectory` run that includes `--use-bc-segments` will
+     * apply velocity-dependent BC segments synthesized from this table. Load a
+     * table matching the bullet's caliber (e.g. `bc5d_308.bin` for a .308).
+     *
+     * Returns a short human-readable summary of the loaded table. Replaces any
+     * previously loaded table.
+     */
+    loadBc5dTable(bytes: Uint8Array): string;
+    /**
+     * Load a custom Mach:Cd drag table (MBA-1328) — a measured or manufacturer-published
+     * drag curve (Hornady CDM data, a Lapua/Doppler-radar-derived deck, or your own) — from
+     * the raw bytes of a CSV file. The host (browser `fetch()` or Node `fs`/`fetch`) is
+     * responsible for retrieving the file — WASM has no filesystem or network — and passes
+     * the bytes here, mirroring [`Self::load_bc5d_table`].
+     *
+     * The bytes must be valid UTF-8 CSV text; parsing is delegated to
+     * [`crate::drag::DragTable::from_csv_str`] — the SAME parser native `--drag-table`
+     * uses — so the accepted format is identical: two columns `mach,cd` per line, blank
+     * lines and `#` comments ignored, a single leading textual header row tolerated, Mach
+     * strictly ascending with at least 2 points, Cd finite and > 0.
+     *
+     * Once loaded, EVERY subsequent `trajectory`, `zero`, `lead`, and `monte-carlo` run
+     * applies the table automatically — no `--use-*` gate flag is needed (unlike a loaded
+     * BC5D table, which only takes effect with `--use-bc-segments`). A loaded table is a
+     * full physical substitute for the G-model + BC (see `calculate_drag_coefficient`):
+     * `-b`/`--bc` may still be supplied but is ignored for drag once a table is active
+     * (matching the native `--drag-table` CLI semantics documented in CLI_USAGE.md).
+     *
+     * Returns a short human-readable summary of the loaded table (point count + Mach
+     * range). Replaces any previously loaded table.
+     */
+    loadDragTable(bytes: Uint8Array): string;
+    constructor();
+    /**
+     * Run a command and return the output
+     */
+    runCommand(command: string): string;
 }
-
-export type SyncInitInput = BufferSource | WebAssembly.Module;
-/**
-* Instantiates the given `module`, which can either be bytes or
-* a precompiled `WebAssembly.Module`.
-*
-* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
-*
-* @returns {InitOutput}
-*/
-export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
-
-/**
-* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
-* for everything else, calls `WebAssembly.instantiate` directly.
-*
-* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
-*
-* @returns {Promise<InitOutput>}
-*/
-export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;