@mearman/doppler 0.0.0-stage → 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { $ as computeSegmentCpa, $t as QuietIntervalSchema, A as synthesizeMultiFlyoverAudio, At as ConstellationEntry, B as SpectrogramOptions, Bt as GeoPoint3D, C as formatConstellationKey, Ct as define, D as SyntheticAudioConfig, Dt as AircraftCategorySchema, E as encodeWavPcm16, Et as AircraftCategory, F as extractDopplerObservations, Ft as DopplerObservationSchema, G as downmixToMono, Gt as LinearFlightSegmentSchema, H as computeSingleSpectrogramFrame, Ht as HypothesisMatch, I as ComputedSingleFrame, It as DopplerRidgePoint, J as fft, Jt as LocationHypothesis, K as ComplexSpectrum, Kt as ListeningEpisode, L as DopplerSpectrogram, Lt as DopplerRidgePointSchema, M as DechirpScoreResult, Mt as DopplerDataset, N as scoreByEmissionDechirping, Nt as DopplerDatasetSchema, O as detectEnfSignature, Ot as AsymptoticKinematics, P as RidgeTrackerOptions, Pt as DopplerObservation, Q as SynthesizeCurveOptions, Qt as QuietInterval, R as SingleFrameOptions, Rt as EnfSignature, S as expandConstellationQueryKeys, St as getOwn, T as decodeWavBytes, Tt as AdsbPingSchema, U as decimateAudioStream, Ut as HypothesisMatchSchema, V as computeDopplerSpectrogram, Vt as GeoPoint3DSchema, W as designLowPassFirKernel, Wt as LinearFlightSegment, X as simplifyTrajectory4D, Xt as LocationSession, Y as TraceMetadata, Yt as LocationHypothesisSchema, Z as RetardedAcousticPoint, Zt as LocationSessionSchema, _ as unmatchedObservationLogPenalty, _t as geoToLocalEnu, a as BUNDLED_SEGMENTS, at as DEFAULT_SOUND_SPEED_MPS, b as QUERY_BUCKET_SPAN, bt as slantDistanceMeters, c as DopplerSessionEngine, ct as DEFAULT_ELLIPSE_SEGMENTS, d as ObservationSegmentPair, dt as HALF_TURN_DEG, en as SearchConstraints, et as solveRetardedDelaySec, f as RefineCoordinateOptions, ft as HorizontalEllipse, g as refineObserverCoordinateGaussNewton, gt as geoToEcef, h as fisherToConfidenceEllipse95, ht as encodeSpatialCell, i as BUNDLED_GROUND_TRUTH, it as AtmosphereState, j as DechirpOptions, jt as ConstellationEntrySchema, k as estimateTempFromCricketChirpsCelsius, kt as AsymptoticKinematicsSchema, l as SessionEngineOptions, lt as DEFAULT_SPATIAL_RESOLUTION, m as SLANT_SIGMA_FLOOR_METERS, mt as ellipseOutline, n as BUNDLED_DATASET, nn as Vector3D, nt as DopplerCurveMeasurement, o as generateBundledReferenceAudio, ot as effectiveRaySoundSpeedMps, p as RefinedLocationResult, pt as decodeSpatialCellCenter, q as computeHannPowerSpectrumDb, qt as ListeningEpisodeSchema, r as BUNDLED_DEM_GRID, rn as Vector3DSchema, rt as extractAsymptoticKinematics, s as generateBundledReferenceWavBytes, st as speedOfSoundAtTempMps, t as BUNDLED_CONSTELLATIONS, tn as SearchConstraintsSchema, tt as synthesizeRetardedDopplerCurve, u as MAX_ALONG_TRACK_WIND_MPS, ut as FULL_TURN_DEG, v as BuildConstellationOptions, vt as interpolateTerrainElevationMeters, w as matchesSearchConstraints, wt as AdsbPing, x as buildConstellationIndex, xt as recordOf, y as CandidateConstraintTarget, yt as localEnuToGeo, z as SpectrogramFrame, zt as EnfSignatureSchema } from "./index-TOQF-n8K.js";
+export { AdsbPing, AdsbPingSchema, AircraftCategory, AircraftCategorySchema, AsymptoticKinematics, AsymptoticKinematicsSchema, AtmosphereState, BUNDLED_CONSTELLATIONS, BUNDLED_DATASET, BUNDLED_DEM_GRID, BUNDLED_GROUND_TRUTH, BUNDLED_SEGMENTS, BuildConstellationOptions, CandidateConstraintTarget, ComplexSpectrum, ComputedSingleFrame, ConstellationEntry, ConstellationEntrySchema, DEFAULT_ELLIPSE_SEGMENTS, DEFAULT_SOUND_SPEED_MPS, DEFAULT_SPATIAL_RESOLUTION, DechirpOptions, DechirpScoreResult, DopplerCurveMeasurement, DopplerDataset, DopplerDatasetSchema, DopplerObservation, DopplerObservationSchema, DopplerRidgePoint, DopplerRidgePointSchema, DopplerSessionEngine, DopplerSpectrogram, EnfSignature, EnfSignatureSchema, FULL_TURN_DEG, GeoPoint3D, GeoPoint3DSchema, HALF_TURN_DEG, HorizontalEllipse, HypothesisMatch, HypothesisMatchSchema, LinearFlightSegment, LinearFlightSegmentSchema, ListeningEpisode, ListeningEpisodeSchema, LocationHypothesis, LocationHypothesisSchema, LocationSession, LocationSessionSchema, MAX_ALONG_TRACK_WIND_MPS, ObservationSegmentPair, QUERY_BUCKET_SPAN, QuietInterval, QuietIntervalSchema, RefineCoordinateOptions, RefinedLocationResult, RetardedAcousticPoint, RidgeTrackerOptions, SLANT_SIGMA_FLOOR_METERS, SearchConstraints, SearchConstraintsSchema, SessionEngineOptions, SingleFrameOptions, SpectrogramFrame, SpectrogramOptions, SynthesizeCurveOptions, SyntheticAudioConfig, TraceMetadata, Vector3D, Vector3DSchema, buildConstellationIndex, computeDopplerSpectrogram, computeHannPowerSpectrumDb, computeSegmentCpa, computeSingleSpectrogramFrame, decimateAudioStream, decodeSpatialCellCenter, decodeWavBytes, define, designLowPassFirKernel, detectEnfSignature, downmixToMono, effectiveRaySoundSpeedMps, ellipseOutline, encodeSpatialCell, encodeWavPcm16, estimateTempFromCricketChirpsCelsius, expandConstellationQueryKeys, extractAsymptoticKinematics, extractDopplerObservations, fft, fisherToConfidenceEllipse95, formatConstellationKey, generateBundledReferenceAudio, generateBundledReferenceWavBytes, geoToEcef, geoToLocalEnu, getOwn, interpolateTerrainElevationMeters, localEnuToGeo, matchesSearchConstraints, recordOf, refineObserverCoordinateGaussNewton, scoreByEmissionDechirping, simplifyTrajectory4D, slantDistanceMeters, solveRetardedDelaySec, speedOfSoundAtTempMps, synthesizeMultiFlyoverAudio, synthesizeRetardedDopplerCurve, unmatchedObservationLogPenalty };

package/dist/index.js

@@ -0,0 +1 @@
+export { tt as AdsbPingSchema, nt as AircraftCategorySchema, rt as AsymptoticKinematicsSchema, t as BUNDLED_CONSTELLATIONS, n as BUNDLED_DATASET, r as BUNDLED_DEM_GRID, i as BUNDLED_GROUND_TRUTH, a as BUNDLED_SEGMENTS, it as ConstellationEntrySchema, V as DEFAULT_ELLIPSE_SEGMENTS, R as DEFAULT_SOUND_SPEED_MPS, H as DEFAULT_SPATIAL_RESOLUTION, at as DopplerDatasetSchema, ot as DopplerObservationSchema, st as DopplerRidgePointSchema, c as DopplerSessionEngine, ct as EnfSignatureSchema, U as FULL_TURN_DEG, lt as GeoPoint3DSchema, W as HALF_TURN_DEG, ut as HypothesisMatchSchema, dt as LinearFlightSegmentSchema, ft as ListeningEpisodeSchema, pt as LocationHypothesisSchema, mt as LocationSessionSchema, l as MAX_ALONG_TRACK_WIND_MPS, m as QUERY_BUCKET_SPAN, ht as QuietIntervalSchema, u as SLANT_SIGMA_FLOOR_METERS, gt as SearchConstraintsSchema, _t as Vector3DSchema, h as buildConstellationIndex, E as computeDopplerSpectrogram, j as computeHannPowerSpectrumDb, P as computeSegmentCpa, D as computeSingleSpectrogramFrame, O as decimateAudioStream, G as decodeSpatialCellCenter, y as decodeWavBytes, vt as define, k as designLowPassFirKernel, x as detectEnfSignature, A as downmixToMono, z as effectiveRaySoundSpeedMps, K as ellipseOutline, q as encodeSpatialCell, b as encodeWavPcm16, S as estimateTempFromCricketChirpsCelsius, g as expandConstellationQueryKeys, L as extractAsymptoticKinematics, T as extractDopplerObservations, M as fft, d as fisherToConfidenceEllipse95, _ as formatConstellationKey, o as generateBundledReferenceAudio, s as generateBundledReferenceWavBytes, J as geoToEcef, Y as geoToLocalEnu, et as getOwn, X as interpolateTerrainElevationMeters, Z as localEnuToGeo, v as matchesSearchConstraints, $ as recordOf, f as refineObserverCoordinateGaussNewton, w as scoreByEmissionDechirping, N as simplifyTrajectory4D, Q as slantDistanceMeters, F as solveRetardedDelaySec, B as speedOfSoundAtTempMps, C as synthesizeMultiFlyoverAudio, I as synthesizeRetardedDopplerCurve, p as unmatchedObservationLogPenalty } from "./src-C4UucgwP.js";

package/dist/mic-capture-protocol-CfYodiRN.js

@@ -0,0 +1,4 @@
+// src/browser/mic-capture-protocol.ts
+/** Name under which the microphone capture processor registers itself in the audio worklet scope, and which the main thread passes to `AudioWorkletNode`. */
+const MIC_CAPTURE_PROCESSOR_NAME = "doppler-mic-capture";
+export { MIC_CAPTURE_PROCESSOR_NAME as t };

package/dist/node/entry.d.ts

@@ -0,0 +1,128 @@
+import { $ as computeSegmentCpa, $t as QuietIntervalSchema, A as synthesizeMultiFlyoverAudio, At as ConstellationEntry, B as SpectrogramOptions, Bt as GeoPoint3D, C as formatConstellationKey, Ct as define, D as SyntheticAudioConfig, Dt as AircraftCategorySchema, E as encodeWavPcm16, Et as AircraftCategory, F as extractDopplerObservations, Ft as DopplerObservationSchema, G as downmixToMono, Gt as LinearFlightSegmentSchema, H as computeSingleSpectrogramFrame, Ht as HypothesisMatch, I as ComputedSingleFrame, It as DopplerRidgePoint, J as fft, Jt as LocationHypothesis, K as ComplexSpectrum, Kt as ListeningEpisode, L as DopplerSpectrogram, Lt as DopplerRidgePointSchema, M as DechirpScoreResult, Mt as DopplerDataset, N as scoreByEmissionDechirping, Nt as DopplerDatasetSchema, O as detectEnfSignature, Ot as AsymptoticKinematics, P as RidgeTrackerOptions, Pt as DopplerObservation, Q as SynthesizeCurveOptions, Qt as QuietInterval, R as SingleFrameOptions, Rt as EnfSignature, S as expandConstellationQueryKeys, St as getOwn, T as decodeWavBytes, Tt as AdsbPingSchema, U as decimateAudioStream, Ut as HypothesisMatchSchema, V as computeDopplerSpectrogram, Vt as GeoPoint3DSchema, W as designLowPassFirKernel, Wt as LinearFlightSegment, X as simplifyTrajectory4D, Xt as LocationSession, Y as TraceMetadata, Yt as LocationHypothesisSchema, Z as RetardedAcousticPoint, Zt as LocationSessionSchema, _ as unmatchedObservationLogPenalty, _t as geoToLocalEnu, a as BUNDLED_SEGMENTS, at as DEFAULT_SOUND_SPEED_MPS, b as QUERY_BUCKET_SPAN, bt as slantDistanceMeters, c as DopplerSessionEngine, ct as DEFAULT_ELLIPSE_SEGMENTS, d as ObservationSegmentPair, dt as HALF_TURN_DEG, en as SearchConstraints, et as solveRetardedDelaySec, f as RefineCoordinateOptions, ft as HorizontalEllipse, g as refineObserverCoordinateGaussNewton, gt as geoToEcef, h as fisherToConfidenceEllipse95, ht as encodeSpatialCell, i as BUNDLED_GROUND_TRUTH, it as AtmosphereState, j as DechirpOptions, jt as ConstellationEntrySchema, k as estimateTempFromCricketChirpsCelsius, kt as AsymptoticKinematicsSchema, l as SessionEngineOptions, lt as DEFAULT_SPATIAL_RESOLUTION, m as SLANT_SIGMA_FLOOR_METERS, mt as ellipseOutline, n as BUNDLED_DATASET, nn as Vector3D, nt as DopplerCurveMeasurement, o as generateBundledReferenceAudio, ot as effectiveRaySoundSpeedMps, p as RefinedLocationResult, pt as decodeSpatialCellCenter, q as computeHannPowerSpectrumDb, qt as ListeningEpisodeSchema, r as BUNDLED_DEM_GRID, rn as Vector3DSchema, rt as extractAsymptoticKinematics, s as generateBundledReferenceWavBytes, st as speedOfSoundAtTempMps, t as BUNDLED_CONSTELLATIONS, tn as SearchConstraintsSchema, tt as synthesizeRetardedDopplerCurve, u as MAX_ALONG_TRACK_WIND_MPS, ut as FULL_TURN_DEG, v as BuildConstellationOptions, vt as interpolateTerrainElevationMeters, w as matchesSearchConstraints, wt as AdsbPing, x as buildConstellationIndex, xt as recordOf, y as CandidateConstraintTarget, yt as localEnuToGeo, z as SpectrogramFrame, zt as EnfSignatureSchema } from "../index-TOQF-n8K.js";
+import { z } from "zod";
+/**
+ * Raw trace format from `adsb.lol` or `tar1090` JSON exports.
+ */
+export declare const RawAdsbTraceFileSchema: z.ZodObject<{
+  icao: z.ZodString;
+  r: z.ZodOptional<z.ZodString>;
+  t: z.ZodOptional<z.ZodString>;
+  desc: z.ZodOptional<z.ZodString>;
+  timestamp: z.ZodOptional<z.ZodNumber>;
+  trace: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"ground">, z.ZodNull]>], z.ZodUnknown>>;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    icao: string;
+    trace: [number, number, number, number | "ground" | null, ...unknown[]][];
+    r?: string | undefined;
+    t?: string | undefined;
+    desc?: string | undefined;
+    timestamp?: number | undefined;
+  };
+};
+export type RawAdsbTraceFile = z.infer<typeof RawAdsbTraceFileSchema>;
+/** A latitude and longitude rectangle. */
+export interface BoundingBox {
+  readonly minLat: number;
+  readonly minLon: number;
+  readonly maxLat: number;
+  readonly maxLon: number;
+}
+/** Options for turning raw traces into segments. */
+export interface AdsbTraceOptions {
+  /** Pings outside the box end the current run and are dropped, so memory and work follow the region rather than the whole archive. A flight audible from inside the box but flying outside it is lost, so the box should include the acoustic range (about 10 km) as margin. */
+  readonly bbox?: Readonly<BoundingBox>;
+  /** Largest 3D deviation, in metres, of a dropped ping from its segment. Defaults to half the solver's slant-distance sigma floor, so compression error cannot dominate the solver's own uncertainty. */
+  readonly toleranceMeters?: number;
+}
+/**
+ * Classifies an ICAO aircraft type code into a propulsion category.
+ * @param typeCode - 4-character ICAO aircraft type designator (e.g. `C172`, `B738`, `DA42`, `EC35`).
+ * @returns Propulsion category.
+ */
+export declare function classifyAircraftCategory(typeCode?: string): AircraftCategory;
+/**
+ * Converts a raw `adsb.lol` / `tar1090` trace object into compressed 4D piecewise-linear segments.
+ * Jet categories are discarded. A ping on the ground, with no altitude, or above 20,000 ft ends the current run, and so does a gap of more than two minutes, so a segment never spans a landing, a climb to cruise or a loss of coverage.
+ * @param trace - Raw ADS-B trace record.
+ * @param dateIso - ISO calendar date (`YYYY-MM-DD`).
+ * @param baseEpochSec - Epoch seconds that the trace's point offsets are counted from.
+ * @param options - Region filter and compression tolerance.
+ * @returns Array of linear flight segments.
+ */
+export declare function processRawAdsbTrace(trace: Readonly<RawAdsbTraceFile>, dateIso: string, baseEpochSec: number, options?: Readonly<AdsbTraceOptions>): LinearFlightSegment[];
+/** Options for reading ADS-B input. */
+export interface AdsbInputOptions extends AdsbTraceOptions {
+  /** Calendar date (`YYYY-MM-DD`) for raw traces that carry no `timestamp`; their offsets count from midnight UTC of this date. */
+  readonly dateIso?: string;
+}
+/**
+ * Converts parsed ADS-B JSON into segments: ready-made segments (an array, or an object with `segments`), a raw trace, or an array of raw traces.
+ * @param parsed - The parsed JSON value.
+ * @param options - Date for raw traces without a `timestamp`.
+ * @returns The segments it holds.
+ * @throws When the value matches none of the accepted shapes, or a raw trace has neither a `timestamp` nor a date option.
+ */
+export declare function segmentsFromAdsbJson(parsed: unknown, options: Readonly<AdsbInputOptions>): LinearFlightSegment[];
+/**
+ * Reads flight segments from ADS-B JSON on disk: a file or every `.json` file of a directory (not recursive). Each file may hold ready-made segments (an array, or an object with `segments`), a raw `adsb.lol` / `tar1090` trace, or an array of raw traces.
+ * @param inputPath - A JSON file or a directory of them.
+ * @param options - Date for raw traces without a `timestamp`.
+ * @returns Segments from every file, in file-name order.
+ * @throws When a file is not valid JSON or matches none of the accepted shapes, naming the file.
+ */
+export declare function readAdsbSegments(inputPath: string, options?: Readonly<AdsbInputOptions>): LinearFlightSegment[];
+/**
+ * Loads and parses a DopplerDataset JSON file from disk.
+ * @param filePath - Path to `.json` dataset file.
+ * @returns Parsed `DopplerDataset`.
+ */
+export declare function loadDatasetFile(filePath: string): DopplerDataset;
+/**
+ * Serializes and saves a DopplerDataset to disk with built constellation index. The file is compact JSON written in batches, because a day of real traffic is hundreds of thousands of segments and one `JSON.stringify` of that overflows the string length limit.
+ * @param filePath - Output path.
+ * @param segments - Array of linear flight segments.
+ * @param demGrid - Optional DEM elevation grid points.
+ * @returns The saved `DopplerDataset`.
+ */
+export declare function saveDatasetBundle(filePath: string, segments: readonly LinearFlightSegment[], demGrid?: readonly GeoPoint3D[]): DopplerDataset;
+/**
+ * Reads flight segments from a tar stream of `adsb.lol` `globe_history` traces, one aircraft at a time so memory holds a single trace and the segments kept.
+ * A day is published as `.tar.aa` and `.tar.ab` parts that concatenate to one tar, so the two parts can be piped in one after the other.
+ * @param source - The tar bytes.
+ * @param options - Region filter and compression tolerance.
+ * @returns Segments from every trace file in the archive.
+ * @throws When a trace file is not valid JSON of the trace shape, naming the file.
+ */
+export declare function readAdsbArchiveSegments(source: Readonly<AsyncIterable<Uint8Array>>, options?: Readonly<AdsbInputOptions>): Promise<LinearFlightSegment[]>;
+/** A regular file read from a tar stream. */
+export interface TarFile {
+  readonly name: string;
+  readonly data: Buffer;
+}
+/**
+ * Reads the regular files of a tar stream one at a time. Entries for which `wanted` is false are skipped without being buffered, which matters for archives that mix small files with very large ones.
+ * Entry data is held in memory, so one entry must fit in memory. GNU long names (`L`) are honoured; other extension headers (`K`, pax `x` and `g`) are skipped, and directories, links and devices are ignored.
+ * @param source - The tar bytes, for example a file or standard input stream.
+ * @param wanted - Chooses by name which entries are read.
+ * @returns A generator of each wanted regular file.
+ * @throws When the stream ends inside a header or an entry.
+ */
+export declare function readTarFiles(source: Readonly<AsyncIterable<Uint8Array>>, wanted: (name: string) => boolean): AsyncGenerator<TarFile>;
+/**
+ * Reads and decodes a WAV audio file from disk into mono `Float32Array` samples and sample rate.
+ * @param filePath - Path to `.wav` file.
+ * @returns Decoded mono audio samples and sample rate in Hz.
+ */
+export declare function readWavFile(filePath: string): {
+  readonly samples: Float32Array;
+  readonly sampleRateHz: number;
+};
+/**
+ * Encodes and writes a mono `Float32Array` audio buffer to disk as a 16-bit PCM WAV file.
+ * @param filePath - Output path.
+ * @param samples - Audio samples in range `[-1, 1]`.
+ * @param sampleRateHz - Audio sample rate in Hz.
+ */
+export declare function writeWavFile(filePath: string, samples: Readonly<Float32Array>, sampleRateHz: number): void;
+export { AdsbPing, AdsbPingSchema, AircraftCategory, AircraftCategorySchema, AsymptoticKinematics, AsymptoticKinematicsSchema, AtmosphereState, BUNDLED_CONSTELLATIONS, BUNDLED_DATASET, BUNDLED_DEM_GRID, BUNDLED_GROUND_TRUTH, BUNDLED_SEGMENTS, BuildConstellationOptions, CandidateConstraintTarget, ComplexSpectrum, ComputedSingleFrame, ConstellationEntry, ConstellationEntrySchema, DEFAULT_ELLIPSE_SEGMENTS, DEFAULT_SOUND_SPEED_MPS, DEFAULT_SPATIAL_RESOLUTION, DechirpOptions, DechirpScoreResult, DopplerCurveMeasurement, DopplerDataset, DopplerDatasetSchema, DopplerObservation, DopplerObservationSchema, DopplerRidgePoint, DopplerRidgePointSchema, DopplerSessionEngine, DopplerSpectrogram, EnfSignature, EnfSignatureSchema, FULL_TURN_DEG, GeoPoint3D, GeoPoint3DSchema, HALF_TURN_DEG, HorizontalEllipse, HypothesisMatch, HypothesisMatchSchema, LinearFlightSegment, LinearFlightSegmentSchema, ListeningEpisode, ListeningEpisodeSchema, LocationHypothesis, LocationHypothesisSchema, LocationSession, LocationSessionSchema, MAX_ALONG_TRACK_WIND_MPS, ObservationSegmentPair, QUERY_BUCKET_SPAN, QuietInterval, QuietIntervalSchema, RefineCoordinateOptions, RefinedLocationResult, RetardedAcousticPoint, RidgeTrackerOptions, SLANT_SIGMA_FLOOR_METERS, SearchConstraints, SearchConstraintsSchema, SessionEngineOptions, SingleFrameOptions, SpectrogramFrame, SpectrogramOptions, SynthesizeCurveOptions, SyntheticAudioConfig, TraceMetadata, Vector3D, Vector3DSchema, buildConstellationIndex, computeDopplerSpectrogram, computeHannPowerSpectrumDb, computeSegmentCpa, computeSingleSpectrogramFrame, decimateAudioStream, decodeSpatialCellCenter, decodeWavBytes, define, designLowPassFirKernel, detectEnfSignature, downmixToMono, effectiveRaySoundSpeedMps, ellipseOutline, encodeSpatialCell, encodeWavPcm16, estimateTempFromCricketChirpsCelsius, expandConstellationQueryKeys, extractAsymptoticKinematics, extractDopplerObservations, fft, fisherToConfidenceEllipse95, formatConstellationKey, generateBundledReferenceAudio, generateBundledReferenceWavBytes, geoToEcef, geoToLocalEnu, getOwn, interpolateTerrainElevationMeters, localEnuToGeo, matchesSearchConstraints, recordOf, refineObserverCoordinateGaussNewton, scoreByEmissionDechirping, simplifyTrajectory4D, slantDistanceMeters, solveRetardedDelaySec, speedOfSoundAtTempMps, synthesizeMultiFlyoverAudio, synthesizeRetardedDopplerCurve, unmatchedObservationLogPenalty };

package/dist/node/entry.js

@@ -0,0 +1,478 @@
+import { $ as recordOf, A as downmixToMono, B as speedOfSoundAtTempMps, C as synthesizeMultiFlyoverAudio, D as computeSingleSpectrogramFrame, E as computeDopplerSpectrogram, F as solveRetardedDelaySec, G as decodeSpatialCellCenter, H as DEFAULT_SPATIAL_RESOLUTION, I as synthesizeRetardedDopplerCurve, J as geoToEcef, K as ellipseOutline, L as extractAsymptoticKinematics, M as fft, N as simplifyTrajectory4D, O as decimateAudioStream, P as computeSegmentCpa, Q as slantDistanceMeters, R as DEFAULT_SOUND_SPEED_MPS, S as estimateTempFromCricketChirpsCelsius, T as extractDopplerObservations, U as FULL_TURN_DEG, V as DEFAULT_ELLIPSE_SEGMENTS, W as HALF_TURN_DEG, X as interpolateTerrainElevationMeters, Y as geoToLocalEnu, Z as localEnuToGeo, _ as formatConstellationKey, _t as Vector3DSchema, a as BUNDLED_SEGMENTS, at as DopplerDatasetSchema, b as encodeWavPcm16, c as DopplerSessionEngine, ct as EnfSignatureSchema, d as fisherToConfidenceEllipse95, dt as LinearFlightSegmentSchema, et as getOwn, f as refineObserverCoordinateGaussNewton, ft as ListeningEpisodeSchema, g as expandConstellationQueryKeys, gt as SearchConstraintsSchema, h as buildConstellationIndex, ht as QuietIntervalSchema, i as BUNDLED_GROUND_TRUTH, it as ConstellationEntrySchema, j as computeHannPowerSpectrumDb, k as designLowPassFirKernel, l as MAX_ALONG_TRACK_WIND_MPS, lt as GeoPoint3DSchema, m as QUERY_BUCKET_SPAN, mt as LocationSessionSchema, n as BUNDLED_DATASET, nt as AircraftCategorySchema, o as generateBundledReferenceAudio, ot as DopplerObservationSchema, p as unmatchedObservationLogPenalty, pt as LocationHypothesisSchema, q as encodeSpatialCell, r as BUNDLED_DEM_GRID, rt as AsymptoticKinematicsSchema, s as generateBundledReferenceWavBytes, st as DopplerRidgePointSchema, t as BUNDLED_CONSTELLATIONS, tt as AdsbPingSchema, u as SLANT_SIGMA_FLOOR_METERS, ut as HypothesisMatchSchema, v as matchesSearchConstraints, vt as define, w as scoreByEmissionDechirping, x as detectEnfSignature, y as decodeWavBytes, z as effectiveRaySoundSpeedMps } from "../src-C4UucgwP.js";
+import { t as MS_PER_SECOND } from "../time-DWqWWgPL.js";
+import { z } from "zod";
+import { gunzipSync } from "node:zlib";
+import { closeSync, openSync, readFileSync, readdirSync, statSync, writeFileSync, writeSync } from "node:fs";
+import { join } from "node:path";
+// src/node/stream-adsb.ts
+/**
+* One trace sample as `adsb.lol` and `tar1090` write it: seconds since the trace's `timestamp`, latitude, longitude and barometric altitude in feet, which is the string `ground` on the ground and null when unreported. Later fields (ground speed, track, flags) are ignored.
+*/
+const RawTracePoint = z.tuple([
+	z.number(),
+	z.number(),
+	z.number(),
+	z.union([
+		z.number(),
+		z.literal("ground"),
+		z.null()
+	])
+]).rest(z.unknown());
+/**
+* Raw trace format from `adsb.lol` or `tar1090` JSON exports.
+*/
+const RawAdsbTraceFileSchema = define(z.object({
+	icao: z.string().min(1),
+	r: z.string().optional(),
+	t: z.string().optional(),
+	desc: z.string().optional(),
+	/** Epoch seconds that each point's offset is counted from. */
+	timestamp: z.number().optional(),
+	trace: z.array(RawTracePoint)
+}));
+/** Altitude above which a ping is cruise traffic that the microphone is not expected to hear: 20,000 ft. */
+const MAX_AUDIBLE_ALTITUDE_METERS = 6096;
+/**
+* Ground speed, in m/s (about 195 knots), above which a segment of an aircraft whose type is not classified is dropped. Light propeller aircraft and helicopters seldom exceed it (about 2 percent of their segments in a sample of real traces), whereas most unclassified types are airliners that fly faster than this below 20,000 ft (about 56 percent of theirs) and have no narrowband propeller tone to match.
+*/
+const MAX_UNCLASSIFIED_SPEED_MPS = 100;
+/** Characters of the ISO 8601 calendar date (`YYYY-MM-DD`) at the start of a `Date.toISOString()` string. */
+const ISO_DATE_LENGTH = 10;
+/** Metres in a foot. */
+const METERS_PER_FOOT = .3048;
+/**
+* Longest gap between pings that is still bridged by a straight line. Across a longer gap the aircraft can have turned, landed or left coverage, and at light-aircraft speeds (about 70 m/s) a two-minute gap is already about 8 km, comparable to the acoustic range, so the run is split instead.
+*/
+const MAX_PING_GAP_SEC = 120;
+function inBox(lat, lon, box) {
+	return lat >= box.minLat && lat <= box.maxLat && lon >= box.minLon && lon <= box.maxLon;
+}
+/**
+* Classifies an ICAO aircraft type code into a propulsion category.
+* @param typeCode - 4-character ICAO aircraft type designator (e.g. `C172`, `B738`, `DA42`, `EC35`).
+* @returns Propulsion category.
+*/
+function classifyAircraftCategory(typeCode) {
+	if (typeCode === void 0 || typeCode === "") return "unknown";
+	const code = typeCode.toUpperCase().trim();
+	if ([
+		"R22",
+		"R44",
+		"R66",
+		"EC20",
+		"EC30",
+		"EC35",
+		"EC45",
+		"B06",
+		"B206",
+		"B407",
+		"AS50",
+		"A109",
+		"S76",
+		"H125",
+		"H135",
+		"H145",
+		"G2CA"
+	].includes(code)) return "helicopter";
+	if ([
+		"C150",
+		"C152",
+		"C172",
+		"C182",
+		"C206",
+		"C210",
+		"PA28",
+		"PA32",
+		"PA34",
+		"PA44",
+		"SR20",
+		"SR22",
+		"DA20",
+		"DA40",
+		"DA42",
+		"P28A",
+		"AA5",
+		"BE36",
+		"BE58",
+		"M20T",
+		"RV7",
+		"RV8",
+		"RV10"
+	].includes(code)) return "piston";
+	if ([
+		"B350",
+		"BE20",
+		"PC12",
+		"TBM7",
+		"TBM8",
+		"TBM9",
+		"DH8D",
+		"AT72",
+		"AT76",
+		"AT45",
+		"C208",
+		"SW4",
+		"D228"
+	].includes(code)) return "turboprop";
+	if ([
+		"A319",
+		"A320",
+		"A321",
+		"A332",
+		"A333",
+		"A359",
+		"B737",
+		"B738",
+		"B739",
+		"B772",
+		"B77W",
+		"B788",
+		"B789",
+		"E190",
+		"E195",
+		"CRJ7",
+		"CRJ9",
+		"C56X",
+		"C680",
+		"GL5T",
+		"GLEX",
+		"FA7X",
+		"CL30"
+	].includes(code)) return "jet";
+	return "unknown";
+}
+/**
+* Converts a raw `adsb.lol` / `tar1090` trace object into compressed 4D piecewise-linear segments.
+* Jet categories are discarded. A ping on the ground, with no altitude, or above 20,000 ft ends the current run, and so does a gap of more than two minutes, so a segment never spans a landing, a climb to cruise or a loss of coverage.
+* @param trace - Raw ADS-B trace record.
+* @param dateIso - ISO calendar date (`YYYY-MM-DD`).
+* @param baseEpochSec - Epoch seconds that the trace's point offsets are counted from.
+* @param options - Region filter and compression tolerance.
+* @returns Array of linear flight segments.
+*/
+function processRawAdsbTrace(trace, dateIso, baseEpochSec, options = {}) {
+	const typeCode = trace.t ?? "unknown";
+	const category = classifyAircraftCategory(typeCode);
+	if (category === "jet") return [];
+	const runs = [];
+	let run = [];
+	const endRun = () => {
+		if (run.length > 0) {
+			runs.push(run);
+			run = [];
+		}
+	};
+	for (const [offsetSec, lat, lon, altFeet] of trace.trace) {
+		const altMeters = typeof altFeet === "number" ? altFeet * METERS_PER_FOOT : void 0;
+		const { bbox } = options;
+		if (altMeters === void 0 || altMeters > MAX_AUDIBLE_ALTITUDE_METERS || bbox !== void 0 && !inBox(lat, lon, bbox)) {
+			endRun();
+			continue;
+		}
+		const epochSec = baseEpochSec + offsetSec;
+		const previous = run[run.length - 1];
+		if (previous !== void 0 && epochSec - previous.epochSec > MAX_PING_GAP_SEC) endRun();
+		run.push({
+			epochSec,
+			lat,
+			lon,
+			altMeters
+		});
+	}
+	endRun();
+	return runs.flatMap((pings) => simplifyTrajectory4D(pings, {
+		flightId: trace.r ?? trace.icao,
+		icao24: trace.icao,
+		typeCode,
+		category,
+		dateIso
+	}, options.toleranceMeters ?? 20)).filter((segment) => category !== "unknown" || segment.groundspeedMps <= MAX_UNCLASSIFIED_SPEED_MPS);
+}
+/**
+* Converts parsed ADS-B JSON into segments: ready-made segments (an array, or an object with `segments`), a raw trace, or an array of raw traces.
+* @param parsed - The parsed JSON value.
+* @param options - Date for raw traces without a `timestamp`.
+* @returns The segments it holds.
+* @throws When the value matches none of the accepted shapes, or a raw trace has neither a `timestamp` nor a date option.
+*/
+function segmentsFromAdsbJson(parsed, options) {
+	if (Array.isArray(parsed)) return parsed.flatMap((element) => segmentsFromAdsbJson(element, options));
+	if (typeof parsed === "object" && parsed !== null && "segments" in parsed) return z.array(LinearFlightSegmentSchema).parse(parsed.segments);
+	if (LinearFlightSegmentSchema.is(parsed)) return [parsed];
+	const trace = RawAdsbTraceFileSchema.parse(parsed);
+	if (trace.timestamp !== void 0) return processRawAdsbTrace(trace, new Date(trace.timestamp * MS_PER_SECOND).toISOString().slice(0, ISO_DATE_LENGTH), trace.timestamp, options);
+	if (options.dateIso === void 0) throw new Error(`trace ${trace.icao} has no timestamp, so its date is unknown; pass the date`);
+	return processRawAdsbTrace(trace, options.dateIso, Date.parse(`${options.dateIso}T00:00:00Z`) / MS_PER_SECOND, options);
+}
+/**
+* Reads flight segments from ADS-B JSON on disk: a file or every `.json` file of a directory (not recursive). Each file may hold ready-made segments (an array, or an object with `segments`), a raw `adsb.lol` / `tar1090` trace, or an array of raw traces.
+* @param inputPath - A JSON file or a directory of them.
+* @param options - Date for raw traces without a `timestamp`.
+* @returns Segments from every file, in file-name order.
+* @throws When a file is not valid JSON or matches none of the accepted shapes, naming the file.
+*/
+function readAdsbSegments(inputPath, options = {}) {
+	return (statSync(inputPath).isDirectory() ? readdirSync(inputPath).filter((name) => name.endsWith(".json")).sort().map((name) => join(inputPath, name)) : [inputPath]).flatMap((file) => {
+		try {
+			return segmentsFromAdsbJson(JSON.parse(readFileSync(file, "utf8")), options);
+		} catch (error) {
+			throw new Error(`${file}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+		}
+	});
+}
+/**
+* Loads and parses a DopplerDataset JSON file from disk.
+* @param filePath - Path to `.json` dataset file.
+* @returns Parsed `DopplerDataset`.
+*/
+function loadDatasetFile(filePath) {
+	const raw = readFileSync(filePath, "utf8");
+	const parsed = JSON.parse(raw);
+	return DopplerDatasetSchema.parse(parsed);
+}
+/** Items serialised per write, so no single string approaches the engine's string length limit however large the dataset. */
+const WRITE_BATCH_ITEMS = 5e3;
+function writeJsonArray(fd, items) {
+	writeSync(fd, "[");
+	for (let start = 0; start < items.length; start += WRITE_BATCH_ITEMS) {
+		const batch = items.slice(start, start + WRITE_BATCH_ITEMS).map((item) => JSON.stringify(item)).join(",");
+		writeSync(fd, start === 0 ? batch : `,${batch}`);
+	}
+	writeSync(fd, "]");
+}
+/**
+* Serializes and saves a DopplerDataset to disk with built constellation index. The file is compact JSON written in batches, because a day of real traffic is hundreds of thousands of segments and one `JSON.stringify` of that overflows the string length limit.
+* @param filePath - Output path.
+* @param segments - Array of linear flight segments.
+* @param demGrid - Optional DEM elevation grid points.
+* @returns The saved `DopplerDataset`.
+*/
+function saveDatasetBundle(filePath, segments, demGrid = []) {
+	const constellations = buildConstellationIndex(segments, { demGrid });
+	const dataset = {
+		version: "1.0.0",
+		generatedAtIso: (/* @__PURE__ */ new Date()).toISOString(),
+		segments,
+		constellations,
+		elevationGrid: demGrid
+	};
+	const fd = openSync(filePath, "w");
+	try {
+		writeSync(fd, `{"version":${JSON.stringify(dataset.version)},"generatedAtIso":${JSON.stringify(dataset.generatedAtIso)},"segments":`);
+		writeJsonArray(fd, segments);
+		writeSync(fd, ",\"constellations\":");
+		writeJsonArray(fd, constellations);
+		writeSync(fd, ",\"elevationGrid\":");
+		writeJsonArray(fd, demGrid);
+		writeSync(fd, "}");
+	} finally {
+		closeSync(fd);
+	}
+	return dataset;
+}
+// src/node/tar-stream.ts
+/** Bytes in a tar block: headers and the padding of entry data are multiples of it. */
+const TAR_BLOCK_BYTES = 512;
+/** Offsets and lengths of the header fields this reader needs (POSIX ustar and GNU tar agree on them). */
+const NAME_FIELD = {
+	offset: 0,
+	length: 100
+};
+const SIZE_FIELD = {
+	offset: 124,
+	length: 12
+};
+const TYPE_FIELD_OFFSET = 156;
+const PREFIX_FIELD = {
+	offset: 345,
+	length: 155
+};
+/** Tar writes sizes as octal text. */
+const OCTAL_RADIX = 8;
+/** Words for the parser state in a truncation error. */
+const STATE_LABELS = {
+	header: "header",
+	longName: "long name",
+	data: "entry",
+	skip: "entry"
+};
+/**
+* A push-driven tar parser: it is fed chunks as they arrive and holds only the bytes of the current header or entry plus the unconsumed remainder of the current chunk.
+* It is a synchronous state machine, so the only suspension point of a reader is the `for await` over the source.
+*/
+var TarParser = class {
+	wanted;
+	state = { kind: "header" };
+	/** Bytes still needed to finish the current state. */
+	need = TAR_BLOCK_BYTES;
+	/** Bytes the current state asked for in total, for the truncation error. */
+	total = TAR_BLOCK_BYTES;
+	/** Collected bytes of the current header, long name or file; skipped bytes are not kept. */
+	collected = [];
+	longName;
+	ended = false;
+	constructor(wanted) {
+		this.wanted = wanted;
+	}
+	/** True once an end-of-archive block has been read: later bytes are ignored. */
+	get isEnded() {
+		return this.ended;
+	}
+	begin(state, length) {
+		this.state = state;
+		this.need = length;
+		this.total = length;
+		this.collected = [];
+	}
+	/**
+	* Feeds one chunk of the stream.
+	* @param chunk - The next bytes of the tar stream.
+	* @returns The files completed by these bytes.
+	* @throws When a header has a size that is not an octal number.
+	*/
+	*push(chunk) {
+		let rest = chunk;
+		while (!this.ended) {
+			if (this.need === 0) {
+				yield* this.complete();
+				continue;
+			}
+			if (rest.length === 0) return;
+			const taken = rest.subarray(0, this.need);
+			if (this.state.kind !== "skip") this.collected.push(taken);
+			this.need -= taken.length;
+			rest = rest.subarray(taken.length);
+		}
+	}
+	/**
+	* Checks that the stream ended on an entry boundary.
+	* @throws When the stream ended inside a header, a long name or an entry.
+	*/
+	finish() {
+		const onBoundary = this.state.kind === "header" && this.need === this.total;
+		if (!this.ended && !onBoundary) throw new Error(`Tar stream ended ${String(this.need)} bytes short of a ${String(this.total)}-byte ${STATE_LABELS[this.state.kind]}`);
+	}
+	*complete() {
+		const state = this.state;
+		const bytes = Buffer.concat(this.collected);
+		switch (state.kind) {
+			case "header":
+				this.readHeader(bytes);
+				break;
+			case "longName":
+				this.longName = field(bytes, {
+					offset: 0,
+					length: bytes.length
+				});
+				this.begin({ kind: "skip" }, state.padding);
+				break;
+			case "data":
+				this.begin({
+					kind: "skip",
+					file: {
+						name: state.name,
+						data: bytes
+					}
+				}, state.padding);
+				break;
+			case "skip":
+				this.begin({ kind: "header" }, TAR_BLOCK_BYTES);
+				if (state.file !== void 0) yield state.file;
+		}
+	}
+	readHeader(header) {
+		if (header.every((byte) => byte === 0)) {
+			this.ended = true;
+			return;
+		}
+		const size = Number.parseInt(field(header, SIZE_FIELD).trim() || "0", OCTAL_RADIX);
+		if (!Number.isFinite(size)) throw new Error("Tar header has a size that is not an octal number");
+		const padding = (TAR_BLOCK_BYTES - size % TAR_BLOCK_BYTES) % TAR_BLOCK_BYTES;
+		const type = String.fromCharCode(header[TYPE_FIELD_OFFSET] ?? 0);
+		if (type === "L") {
+			this.begin({
+				kind: "longName",
+				padding
+			}, size);
+			return;
+		}
+		const prefix = field(header, PREFIX_FIELD);
+		const name = this.longName ?? (prefix === "" ? field(header, NAME_FIELD) : `${prefix}/${field(header, NAME_FIELD)}`);
+		this.longName = void 0;
+		if ((type === "0" || type === "\0") && this.wanted(name)) this.begin({
+			kind: "data",
+			name,
+			padding
+		}, size);
+		else this.begin({ kind: "skip" }, size + padding);
+	}
+};
+function field(header, spec) {
+	const raw = header.subarray(spec.offset, spec.offset + spec.length);
+	const end = raw.indexOf(0);
+	return raw.subarray(0, end === -1 ? raw.length : end).toString("utf8");
+}
+/**
+* Reads the regular files of a tar stream one at a time. Entries for which `wanted` is false are skipped without being buffered, which matters for archives that mix small files with very large ones.
+* Entry data is held in memory, so one entry must fit in memory. GNU long names (`L`) are honoured; other extension headers (`K`, pax `x` and `g`) are skipped, and directories, links and devices are ignored.
+* @param source - The tar bytes, for example a file or standard input stream.
+* @param wanted - Chooses by name which entries are read.
+* @returns A generator of each wanted regular file.
+* @throws When the stream ends inside a header or an entry.
+*/
+async function* readTarFiles(source, wanted) {
+	const parser = new TarParser(wanted);
+	for await (const chunk of source) {
+		yield* parser.push(Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+		if (parser.isEnded) return;
+	}
+	parser.finish();
+}
+// src/node/adsb-archive.ts
+/** First two bytes of a gzip stream. `readsb` history files carry a `.json` name but are usually gzip-compressed. */
+const GZIP_MAGIC = [31, 139];
+/** Matches the per-aircraft trace files of an `adsb.lol` `globe_history` archive, for example `./traces/3a/trace_full_3a1b2c.json`. */
+const TRACE_FILE = /(^|\/)trace_full_[0-9a-f~]+\.json$/;
+/**
+* Reads flight segments from a tar stream of `adsb.lol` `globe_history` traces, one aircraft at a time so memory holds a single trace and the segments kept.
+* A day is published as `.tar.aa` and `.tar.ab` parts that concatenate to one tar, so the two parts can be piped in one after the other.
+* @param source - The tar bytes.
+* @param options - Region filter and compression tolerance.
+* @returns Segments from every trace file in the archive.
+* @throws When a trace file is not valid JSON of the trace shape, naming the file.
+*/
+async function readAdsbArchiveSegments(source, options = {}) {
+	const segments = [];
+	for await (const file of readTarFiles(source, (name) => TRACE_FILE.test(name))) {
+		const text = (GZIP_MAGIC.every((byte, index) => file.data[index] === byte) ? gunzipSync(file.data) : file.data).toString("utf8");
+		let found;
+		try {
+			found = segmentsFromAdsbJson(JSON.parse(text), options);
+		} catch (error) {
+			throw new Error(`${file.name}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+		}
+		segments.push(...found);
+	}
+	return segments;
+}
+// src/node/wav-file.ts
+/**
+* Reads and decodes a WAV audio file from disk into mono `Float32Array` samples and sample rate.
+* @param filePath - Path to `.wav` file.
+* @returns Decoded mono audio samples and sample rate in Hz.
+*/
+function readWavFile(filePath) {
+	const bytes = new Uint8Array(readFileSync(filePath));
+	return decodeWavBytes(bytes);
+}
+/**
+* Encodes and writes a mono `Float32Array` audio buffer to disk as a 16-bit PCM WAV file.
+* @param filePath - Output path.
+* @param samples - Audio samples in range `[-1, 1]`.
+* @param sampleRateHz - Audio sample rate in Hz.
+*/
+function writeWavFile(filePath, samples, sampleRateHz) {
+	const bytes = encodeWavPcm16(samples, sampleRateHz);
+	writeFileSync(filePath, bytes);
+}
+export { AdsbPingSchema, AircraftCategorySchema, AsymptoticKinematicsSchema, BUNDLED_CONSTELLATIONS, BUNDLED_DATASET, BUNDLED_DEM_GRID, BUNDLED_GROUND_TRUTH, BUNDLED_SEGMENTS, ConstellationEntrySchema, DEFAULT_ELLIPSE_SEGMENTS, DEFAULT_SOUND_SPEED_MPS, DEFAULT_SPATIAL_RESOLUTION, DopplerDatasetSchema, DopplerObservationSchema, DopplerRidgePointSchema, DopplerSessionEngine, EnfSignatureSchema, FULL_TURN_DEG, GeoPoint3DSchema, HALF_TURN_DEG, HypothesisMatchSchema, LinearFlightSegmentSchema, ListeningEpisodeSchema, LocationHypothesisSchema, LocationSessionSchema, MAX_ALONG_TRACK_WIND_MPS, QUERY_BUCKET_SPAN, QuietIntervalSchema, RawAdsbTraceFileSchema, SLANT_SIGMA_FLOOR_METERS, SearchConstraintsSchema, Vector3DSchema, buildConstellationIndex, classifyAircraftCategory, computeDopplerSpectrogram, computeHannPowerSpectrumDb, computeSegmentCpa, computeSingleSpectrogramFrame, decimateAudioStream, decodeSpatialCellCenter, decodeWavBytes, define, designLowPassFirKernel, detectEnfSignature, downmixToMono, effectiveRaySoundSpeedMps, ellipseOutline, encodeSpatialCell, encodeWavPcm16, estimateTempFromCricketChirpsCelsius, expandConstellationQueryKeys, extractAsymptoticKinematics, extractDopplerObservations, fft, fisherToConfidenceEllipse95, formatConstellationKey, generateBundledReferenceAudio, generateBundledReferenceWavBytes, geoToEcef, geoToLocalEnu, getOwn, interpolateTerrainElevationMeters, loadDatasetFile, localEnuToGeo, matchesSearchConstraints, processRawAdsbTrace, readAdsbArchiveSegments, readAdsbSegments, readTarFiles, readWavFile, recordOf, refineObserverCoordinateGaussNewton, saveDatasetBundle, scoreByEmissionDechirping, segmentsFromAdsbJson, simplifyTrajectory4D, slantDistanceMeters, solveRetardedDelaySec, speedOfSoundAtTempMps, synthesizeMultiFlyoverAudio, synthesizeRetardedDopplerCurve, unmatchedObservationLogPenalty, writeWavFile };