@mearman/doppler 0.0.0 → 1.0.0

package/dist/index-TOQF-n8K.d.ts

@@ -0,0 +1,1577 @@
+import { z } from "zod";
+/**
+ * Geodetic 3D coordinate on or above the WGS84 reference ellipsoid.
+ */
+declare const GeoPoint3DSchema: z.ZodObject<{
+  lat: z.ZodNumber;
+  lon: z.ZodNumber;
+  altMeters: z.ZodNumber;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    lat: number;
+    lon: number;
+    altMeters: number;
+  };
+};
+type GeoPoint3D = z.infer<typeof GeoPoint3DSchema>;
+/**
+ * 3D Cartesian vector in Earth-Centered, Earth-Fixed (ECEF) or local East-North-Up (ENU) coordinates.
+ */
+declare const Vector3DSchema: z.ZodObject<{
+  x: z.ZodNumber;
+  y: z.ZodNumber;
+  z: z.ZodNumber;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    x: number;
+    y: number;
+    z: number;
+  };
+};
+type Vector3D = z.infer<typeof Vector3DSchema>;
+/**
+ * Aircraft propulsion category used to filter acoustic candidates.
+ */
+declare const AircraftCategorySchema: z.ZodEnum<{
+  unknown: "unknown";
+  piston: "piston";
+  turboprop: "turboprop";
+  helicopter: "helicopter";
+  jet: "jet";
+}> & {
+  readonly is: (value: unknown) => value is "unknown" | "piston" | "turboprop" | "helicopter" | "jet";
+};
+type AircraftCategory = z.infer<typeof AircraftCategorySchema>;
+/**
+ * Raw 1 Hz ADS-B state vector prior to 4D Ramer-Douglas-Peucker simplification.
+ */
+declare const AdsbPingSchema: z.ZodObject<{
+  epochSec: z.ZodNumber;
+  lat: z.ZodNumber;
+  lon: z.ZodNumber;
+  altMeters: z.ZodNumber;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    epochSec: number;
+    lat: number;
+    lon: number;
+    altMeters: number;
+  };
+};
+type AdsbPing = z.infer<typeof AdsbPingSchema>;
+/**
+ * Piecewise-linear 4D aircraft trajectory segment produced by Ramer-Douglas-Peucker compression.
+ */
+declare const LinearFlightSegmentSchema: z.ZodObject<{
+  id: z.ZodString;
+  flightId: z.ZodString;
+  icao24: z.ZodString;
+  typeCode: z.ZodString;
+  category: z.ZodEnum<{
+    unknown: "unknown";
+    piston: "piston";
+    turboprop: "turboprop";
+    helicopter: "helicopter";
+    jet: "jet";
+  }> & {
+    readonly is: (value: unknown) => value is "unknown" | "piston" | "turboprop" | "helicopter" | "jet";
+  };
+  dateIso: z.ZodString;
+  startEpochSec: z.ZodNumber;
+  endEpochSec: z.ZodNumber;
+  startGeo: z.ZodObject<{
+    lat: z.ZodNumber;
+    lon: z.ZodNumber;
+    altMeters: z.ZodNumber;
+  }, z.core.$strip> & {
+    readonly is: (value: unknown) => value is {
+      lat: number;
+      lon: number;
+      altMeters: number;
+    };
+  };
+  endGeo: z.ZodObject<{
+    lat: z.ZodNumber;
+    lon: z.ZodNumber;
+    altMeters: z.ZodNumber;
+  }, z.core.$strip> & {
+    readonly is: (value: unknown) => value is {
+      lat: number;
+      lon: number;
+      altMeters: number;
+    };
+  };
+  groundspeedMps: z.ZodNumber;
+  h3Cell: z.ZodString;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    id: string;
+    flightId: string;
+    icao24: string;
+    typeCode: string;
+    category: "unknown" | "piston" | "turboprop" | "helicopter" | "jet";
+    dateIso: string;
+    startEpochSec: number;
+    endEpochSec: number;
+    startGeo: {
+      lat: number;
+      lon: number;
+      altMeters: number;
+    };
+    endGeo: {
+      lat: number;
+      lon: number;
+      altMeters: number;
+    };
+    groundspeedMps: number;
+    h3Cell: string;
+  };
+};
+type LinearFlightSegment = z.infer<typeof LinearFlightSegmentSchema>;
+/**
+ * Single time-frequency point along an extracted spectrogram Doppler ridge.
+ */
+declare const DopplerRidgePointSchema: z.ZodObject<{
+  timeSec: z.ZodNumber;
+  freqHz: z.ZodNumber;
+  snrDb: z.ZodNumber;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    timeSec: number;
+    freqHz: number;
+    snrDb: number;
+  };
+};
+type DopplerRidgePoint = z.infer<typeof DopplerRidgePointSchema>;
+/**
+ * Closed-form kinematic parameters extracted algebraically from a single Doppler S-curve.
+ */
+declare const AsymptoticKinematicsSchema: z.ZodObject<{
+  asymptoticHighHz: z.ZodNumber;
+  asymptoticLowHz: z.ZodNumber;
+  baseFreqHz: z.ZodNumber;
+  inflectionSlopeHzPerSec: z.ZodNumber;
+  inferredSpeedMps: z.ZodNumber;
+  inferredSlantMeters: z.ZodNumber;
+  speedStdMps: z.ZodNumber;
+  slantStdMeters: z.ZodNumber;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    asymptoticHighHz: number;
+    asymptoticLowHz: number;
+    baseFreqHz: number;
+    inflectionSlopeHzPerSec: number;
+    inferredSpeedMps: number;
+    inferredSlantMeters: number;
+    speedStdMps: number;
+    slantStdMeters: number;
+  };
+};
+type AsymptoticKinematics = z.infer<typeof AsymptoticKinematicsSchema>;
+/**
+ * Complete acoustic observation of an aircraft flyover extracted from an audio stream or file.
+ */
+declare const DopplerObservationSchema: z.ZodObject<{
+  id: z.ZodString;
+  episodeId: z.ZodString;
+  cpaTimeSec: z.ZodNumber;
+  kinematics: z.ZodObject<{
+    asymptoticHighHz: z.ZodNumber;
+    asymptoticLowHz: z.ZodNumber;
+    baseFreqHz: z.ZodNumber;
+    inflectionSlopeHzPerSec: z.ZodNumber;
+    inferredSpeedMps: z.ZodNumber;
+    inferredSlantMeters: z.ZodNumber;
+    speedStdMps: z.ZodNumber;
+    slantStdMeters: z.ZodNumber;
+  }, z.core.$strip> & {
+    readonly is: (value: unknown) => value is {
+      asymptoticHighHz: number;
+      asymptoticLowHz: number;
+      baseFreqHz: number;
+      inflectionSlopeHzPerSec: number;
+      inferredSpeedMps: number;
+      inferredSlantMeters: number;
+      speedStdMps: number;
+      slantStdMeters: number;
+    };
+  };
+  snrDb: z.ZodNumber;
+  harmonicCount: z.ZodNumber;
+  ridgePoints: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    timeSec: z.ZodNumber;
+    freqHz: z.ZodNumber;
+    snrDb: z.ZodNumber;
+  }, z.core.$strip> & {
+    readonly is: (value: unknown) => value is {
+      timeSec: number;
+      freqHz: number;
+      snrDb: number;
+    };
+  }>>;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    id: string;
+    episodeId: string;
+    cpaTimeSec: number;
+    kinematics: {
+      asymptoticHighHz: number;
+      asymptoticLowHz: number;
+      baseFreqHz: number;
+      inflectionSlopeHzPerSec: number;
+      inferredSpeedMps: number;
+      inferredSlantMeters: number;
+      speedStdMps: number;
+      slantStdMeters: number;
+    };
+    snrDb: number;
+    harmonicCount: number;
+    ridgePoints: readonly {
+      timeSec: number;
+      freqHz: number;
+      snrDb: number;
+    }[];
+  };
+};
+type DopplerObservation = z.infer<typeof DopplerObservationSchema>;
+/**
+ * Quantized Shazam-style constellation hash entry linking two flyovers at a shared H3 cell.
+ */
+declare const ConstellationEntrySchema: z.ZodObject<{
+  hashKey: z.ZodString;
+  dateIso: z.ZodString;
+  h3Cell: z.ZodString;
+  centerLat: z.ZodNumber;
+  centerLon: z.ZodNumber;
+  segmentIdA: z.ZodString;
+  segmentIdB: z.ZodString;
+  speedAMps: z.ZodNumber;
+  speedBMps: z.ZodNumber;
+  cpaDelayedEpochSecA: z.ZodNumber;
+  cpaDelayedEpochSecB: z.ZodNumber;
+  deltaSec: z.ZodNumber;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    hashKey: string;
+    dateIso: string;
+    h3Cell: string;
+    centerLat: number;
+    centerLon: number;
+    segmentIdA: string;
+    segmentIdB: string;
+    speedAMps: number;
+    speedBMps: number;
+    cpaDelayedEpochSecA: number;
+    cpaDelayedEpochSecB: number;
+    deltaSec: number;
+  };
+};
+type ConstellationEntry = z.infer<typeof ConstellationEntrySchema>;
+/**
+ * Time interval within a listening episode where ambient noise was below the silence-gating threshold.
+ */
+declare const QuietIntervalSchema: z.ZodObject<{
+  startSec: z.ZodNumber;
+  endSec: z.ZodNumber;
+  medianNoiseFloorDb: z.ZodNumber;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    startSec: number;
+    endSec: number;
+    medianNoiseFloorDb: number;
+  };
+};
+type QuietInterval = z.infer<typeof QuietIntervalSchema>;
+/**
+ * Continuous listening window within a multi-episode pause/resume geolocation session.
+ */
+declare const ListeningEpisodeSchema: z.ZodObject<{
+  id: z.ZodString;
+  startedAtSec: z.ZodNumber;
+  endedAtSec: z.ZodNumber;
+  status: z.ZodEnum<{
+    active: "active";
+    paused: "paused";
+    completed: "completed";
+  }>;
+  currentNoiseFloorDb: z.ZodNumber;
+  noisePolluted: z.ZodBoolean;
+  quietIntervals: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    startSec: z.ZodNumber;
+    endSec: z.ZodNumber;
+    medianNoiseFloorDb: z.ZodNumber;
+  }, z.core.$strip> & {
+    readonly is: (value: unknown) => value is {
+      startSec: number;
+      endSec: number;
+      medianNoiseFloorDb: number;
+    };
+  }>>;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    id: string;
+    startedAtSec: number;
+    endedAtSec: number;
+    status: "active" | "paused" | "completed";
+    currentNoiseFloorDb: number;
+    noisePolluted: boolean;
+    quietIntervals: readonly {
+      startSec: number;
+      endSec: number;
+      medianNoiseFloorDb: number;
+    }[];
+  };
+};
+type ListeningEpisode = z.infer<typeof ListeningEpisodeSchema>;
+/**
+ * Passive Electrical Network Frequency (ENF) side-channel signature (50 Hz vs 60 Hz power grid).
+ */
+declare const EnfSignatureSchema: z.ZodObject<{
+  detected: z.ZodBoolean;
+  nominalHz: z.ZodEnum<{
+    unknown: "unknown";
+    50: "50";
+    60: "60";
+  }>;
+  measuredFreqHz: z.ZodNumber;
+  snrDb: z.ZodNumber;
+  regionHint: z.ZodString;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    detected: boolean;
+    nominalHz: "unknown" | "50" | "60";
+    measuredFreqHz: number;
+    snrDb: number;
+    regionHint: string;
+  };
+};
+type EnfSignature = z.infer<typeof EnfSignatureSchema>;
+/**
+ * Optional user or side-channel constraints over Space, Date, Time of Day, and Power Grid.
+ */
+declare const SearchConstraintsSchema: z.ZodObject<{
+  minLat: z.ZodOptional<z.ZodNumber>;
+  maxLat: z.ZodOptional<z.ZodNumber>;
+  minLon: z.ZodOptional<z.ZodNumber>;
+  maxLon: z.ZodOptional<z.ZodNumber>;
+  dateFromIso: z.ZodOptional<z.ZodString>;
+  dateToIso: z.ZodOptional<z.ZodString>;
+  utcHourStart: z.ZodOptional<z.ZodNumber>;
+  utcHourEnd: z.ZodOptional<z.ZodNumber>;
+  enfNominalHz: z.ZodOptional<z.ZodEnum<{
+    50: "50";
+    60: "60";
+  }>>;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    minLat?: number | undefined;
+    maxLat?: number | undefined;
+    minLon?: number | undefined;
+    maxLon?: number | undefined;
+    dateFromIso?: string | undefined;
+    dateToIso?: string | undefined;
+    utcHourStart?: number | undefined;
+    utcHourEnd?: number | undefined;
+    enfNominalHz?: "50" | "60" | undefined;
+  };
+};
+type SearchConstraints = z.infer<typeof SearchConstraintsSchema>;
+/**
+ * A flyover observation attributed to a flight segment under a location hypothesis. Matches are keyed by observation id, never by position, because an observation that fits no segment is absent from a hypothesis and would shift every later index.
+ */
+declare const HypothesisMatchSchema: z.ZodObject<{
+  observationId: z.ZodString;
+  segmentId: z.ZodString;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    observationId: string;
+    segmentId: string;
+  };
+};
+type HypothesisMatch = z.infer<typeof HypothesisMatchSchema>;
+/**
+ * Candidate observer location hypothesis with cumulative Bayesian log-posterior and 95% confidence ellipse.
+ */
+declare const LocationHypothesisSchema: z.ZodObject<{
+  id: z.ZodString;
+  h3Cell: z.ZodString;
+  dateIso: z.ZodString;
+  lat: z.ZodNumber;
+  lon: z.ZodNumber;
+  altMeters: z.ZodNumber;
+  estimatedStartEpochSec: z.ZodNumber;
+  logPosterior: z.ZodNumber;
+  probability: z.ZodNumber;
+  rmsFreqResidualHz: z.ZodNumber;
+  fisherInfo: z.ZodReadonly<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+  ellipseSemiMajorMeters: z.ZodNumber;
+  ellipseSemiMinorMeters: z.ZodNumber;
+  ellipseBearingDeg: z.ZodNumber;
+  matches: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    observationId: z.ZodString;
+    segmentId: z.ZodString;
+  }, z.core.$strip> & {
+    readonly is: (value: unknown) => value is {
+      observationId: string;
+      segmentId: string;
+    };
+  }>>;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    id: string;
+    h3Cell: string;
+    dateIso: string;
+    lat: number;
+    lon: number;
+    altMeters: number;
+    estimatedStartEpochSec: number;
+    logPosterior: number;
+    probability: number;
+    rmsFreqResidualHz: number;
+    fisherInfo: readonly [number, number, number, number];
+    ellipseSemiMajorMeters: number;
+    ellipseSemiMinorMeters: number;
+    ellipseBearingDeg: number;
+    matches: readonly {
+      observationId: string;
+      segmentId: string;
+    }[];
+  };
+};
+type LocationHypothesis = z.infer<typeof LocationHypothesisSchema>;
+/**
+ * Persistent, serializable geolocation session supporting continuous and episodic pause/resume refinement.
+ */
+declare const LocationSessionSchema: z.ZodObject<{
+  id: z.ZodString;
+  createdAtEpochSec: z.ZodNumber;
+  updatedAtEpochSec: z.ZodNumber;
+  ambientTempCelsius: z.ZodNumber;
+  constraints: z.ZodObject<{
+    minLat: z.ZodOptional<z.ZodNumber>;
+    maxLat: z.ZodOptional<z.ZodNumber>;
+    minLon: z.ZodOptional<z.ZodNumber>;
+    maxLon: z.ZodOptional<z.ZodNumber>;
+    dateFromIso: z.ZodOptional<z.ZodString>;
+    dateToIso: z.ZodOptional<z.ZodString>;
+    utcHourStart: z.ZodOptional<z.ZodNumber>;
+    utcHourEnd: z.ZodOptional<z.ZodNumber>;
+    enfNominalHz: z.ZodOptional<z.ZodEnum<{
+      50: "50";
+      60: "60";
+    }>>;
+  }, z.core.$strip> & {
+    readonly is: (value: unknown) => value is {
+      minLat?: number | undefined;
+      maxLat?: number | undefined;
+      minLon?: number | undefined;
+      maxLon?: number | undefined;
+      dateFromIso?: string | undefined;
+      dateToIso?: string | undefined;
+      utcHourStart?: number | undefined;
+      utcHourEnd?: number | undefined;
+      enfNominalHz?: "50" | "60" | undefined;
+    };
+  };
+  enfSignature: z.ZodObject<{
+    detected: z.ZodBoolean;
+    nominalHz: z.ZodEnum<{
+      unknown: "unknown";
+      50: "50";
+      60: "60";
+    }>;
+    measuredFreqHz: z.ZodNumber;
+    snrDb: z.ZodNumber;
+    regionHint: z.ZodString;
+  }, z.core.$strip> & {
+    readonly is: (value: unknown) => value is {
+      detected: boolean;
+      nominalHz: "unknown" | "50" | "60";
+      measuredFreqHz: number;
+      snrDb: number;
+      regionHint: string;
+    };
+  };
+  episodes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    startedAtSec: z.ZodNumber;
+    endedAtSec: z.ZodNumber;
+    status: z.ZodEnum<{
+      active: "active";
+      paused: "paused";
+      completed: "completed";
+    }>;
+    currentNoiseFloorDb: z.ZodNumber;
+    noisePolluted: z.ZodBoolean;
+    quietIntervals: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+      startSec: z.ZodNumber;
+      endSec: z.ZodNumber;
+      medianNoiseFloorDb: z.ZodNumber;
+    }, z.core.$strip> & {
+      readonly is: (value: unknown) => value is {
+        startSec: number;
+        endSec: number;
+        medianNoiseFloorDb: number;
+      };
+    }>>;
+  }, z.core.$strip> & {
+    readonly is: (value: unknown) => value is {
+      id: string;
+      startedAtSec: number;
+      endedAtSec: number;
+      status: "active" | "paused" | "completed";
+      currentNoiseFloorDb: number;
+      noisePolluted: boolean;
+      quietIntervals: readonly {
+        startSec: number;
+        endSec: number;
+        medianNoiseFloorDb: number;
+      }[];
+    };
+  }>>;
+  observations: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    episodeId: z.ZodString;
+    cpaTimeSec: z.ZodNumber;
+    kinematics: z.ZodObject<{
+      asymptoticHighHz: z.ZodNumber;
+      asymptoticLowHz: z.ZodNumber;
+      baseFreqHz: z.ZodNumber;
+      inflectionSlopeHzPerSec: z.ZodNumber;
+      inferredSpeedMps: z.ZodNumber;
+      inferredSlantMeters: z.ZodNumber;
+      speedStdMps: z.ZodNumber;
+      slantStdMeters: z.ZodNumber;
+    }, z.core.$strip> & {
+      readonly is: (value: unknown) => value is {
+        asymptoticHighHz: number;
+        asymptoticLowHz: number;
+        baseFreqHz: number;
+        inflectionSlopeHzPerSec: number;
+        inferredSpeedMps: number;
+        inferredSlantMeters: number;
+        speedStdMps: number;
+        slantStdMeters: number;
+      };
+    };
+    snrDb: z.ZodNumber;
+    harmonicCount: z.ZodNumber;
+    ridgePoints: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+      timeSec: z.ZodNumber;
+      freqHz: z.ZodNumber;
+      snrDb: z.ZodNumber;
+    }, z.core.$strip> & {
+      readonly is: (value: unknown) => value is {
+        timeSec: number;
+        freqHz: number;
+        snrDb: number;
+      };
+    }>>;
+  }, z.core.$strip> & {
+    readonly is: (value: unknown) => value is {
+      id: string;
+      episodeId: string;
+      cpaTimeSec: number;
+      kinematics: {
+        asymptoticHighHz: number;
+        asymptoticLowHz: number;
+        baseFreqHz: number;
+        inflectionSlopeHzPerSec: number;
+        inferredSpeedMps: number;
+        inferredSlantMeters: number;
+        speedStdMps: number;
+        slantStdMeters: number;
+      };
+      snrDb: number;
+      harmonicCount: number;
+      ridgePoints: readonly {
+        timeSec: number;
+        freqHz: number;
+        snrDb: number;
+      }[];
+    };
+  }>>;
+  hypotheses: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    h3Cell: z.ZodString;
+    dateIso: z.ZodString;
+    lat: z.ZodNumber;
+    lon: z.ZodNumber;
+    altMeters: z.ZodNumber;
+    estimatedStartEpochSec: z.ZodNumber;
+    logPosterior: z.ZodNumber;
+    probability: z.ZodNumber;
+    rmsFreqResidualHz: z.ZodNumber;
+    fisherInfo: z.ZodReadonly<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    ellipseSemiMajorMeters: z.ZodNumber;
+    ellipseSemiMinorMeters: z.ZodNumber;
+    ellipseBearingDeg: z.ZodNumber;
+    matches: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+      observationId: z.ZodString;
+      segmentId: z.ZodString;
+    }, z.core.$strip> & {
+      readonly is: (value: unknown) => value is {
+        observationId: string;
+        segmentId: string;
+      };
+    }>>;
+  }, z.core.$strip> & {
+    readonly is: (value: unknown) => value is {
+      id: string;
+      h3Cell: string;
+      dateIso: string;
+      lat: number;
+      lon: number;
+      altMeters: number;
+      estimatedStartEpochSec: number;
+      logPosterior: number;
+      probability: number;
+      rmsFreqResidualHz: number;
+      fisherInfo: readonly [number, number, number, number];
+      ellipseSemiMajorMeters: number;
+      ellipseSemiMinorMeters: number;
+      ellipseBearingDeg: number;
+      matches: readonly {
+        observationId: string;
+        segmentId: string;
+      }[];
+    };
+  }>>;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    id: string;
+    createdAtEpochSec: number;
+    updatedAtEpochSec: number;
+    ambientTempCelsius: number;
+    constraints: {
+      minLat?: number | undefined;
+      maxLat?: number | undefined;
+      minLon?: number | undefined;
+      maxLon?: number | undefined;
+      dateFromIso?: string | undefined;
+      dateToIso?: string | undefined;
+      utcHourStart?: number | undefined;
+      utcHourEnd?: number | undefined;
+      enfNominalHz?: "50" | "60" | undefined;
+    };
+    enfSignature: {
+      detected: boolean;
+      nominalHz: "unknown" | "50" | "60";
+      measuredFreqHz: number;
+      snrDb: number;
+      regionHint: string;
+    };
+    episodes: readonly {
+      id: string;
+      startedAtSec: number;
+      endedAtSec: number;
+      status: "active" | "paused" | "completed";
+      currentNoiseFloorDb: number;
+      noisePolluted: boolean;
+      quietIntervals: readonly {
+        startSec: number;
+        endSec: number;
+        medianNoiseFloorDb: number;
+      }[];
+    }[];
+    observations: readonly {
+      id: string;
+      episodeId: string;
+      cpaTimeSec: number;
+      kinematics: {
+        asymptoticHighHz: number;
+        asymptoticLowHz: number;
+        baseFreqHz: number;
+        inflectionSlopeHzPerSec: number;
+        inferredSpeedMps: number;
+        inferredSlantMeters: number;
+        speedStdMps: number;
+        slantStdMeters: number;
+      };
+      snrDb: number;
+      harmonicCount: number;
+      ridgePoints: readonly {
+        timeSec: number;
+        freqHz: number;
+        snrDb: number;
+      }[];
+    }[];
+    hypotheses: readonly {
+      id: string;
+      h3Cell: string;
+      dateIso: string;
+      lat: number;
+      lon: number;
+      altMeters: number;
+      estimatedStartEpochSec: number;
+      logPosterior: number;
+      probability: number;
+      rmsFreqResidualHz: number;
+      fisherInfo: readonly [number, number, number, number];
+      ellipseSemiMajorMeters: number;
+      ellipseSemiMinorMeters: number;
+      ellipseBearingDeg: number;
+      matches: readonly {
+        observationId: string;
+        segmentId: string;
+      }[];
+    }[];
+  };
+};
+type LocationSession = z.infer<typeof LocationSessionSchema>;
+/**
+ * Portable dataset bundle containing 4D-RDP trajectory segments, constellation hash index, and elevation tiles.
+ */
+declare const DopplerDatasetSchema: z.ZodObject<{
+  version: z.ZodString;
+  generatedAtIso: z.ZodString;
+  segments: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    flightId: z.ZodString;
+    icao24: z.ZodString;
+    typeCode: z.ZodString;
+    category: z.ZodEnum<{
+      unknown: "unknown";
+      piston: "piston";
+      turboprop: "turboprop";
+      helicopter: "helicopter";
+      jet: "jet";
+    }> & {
+      readonly is: (value: unknown) => value is "unknown" | "piston" | "turboprop" | "helicopter" | "jet";
+    };
+    dateIso: z.ZodString;
+    startEpochSec: z.ZodNumber;
+    endEpochSec: z.ZodNumber;
+    startGeo: z.ZodObject<{
+      lat: z.ZodNumber;
+      lon: z.ZodNumber;
+      altMeters: z.ZodNumber;
+    }, z.core.$strip> & {
+      readonly is: (value: unknown) => value is {
+        lat: number;
+        lon: number;
+        altMeters: number;
+      };
+    };
+    endGeo: z.ZodObject<{
+      lat: z.ZodNumber;
+      lon: z.ZodNumber;
+      altMeters: z.ZodNumber;
+    }, z.core.$strip> & {
+      readonly is: (value: unknown) => value is {
+        lat: number;
+        lon: number;
+        altMeters: number;
+      };
+    };
+    groundspeedMps: z.ZodNumber;
+    h3Cell: z.ZodString;
+  }, z.core.$strip> & {
+    readonly is: (value: unknown) => value is {
+      id: string;
+      flightId: string;
+      icao24: string;
+      typeCode: string;
+      category: "unknown" | "piston" | "turboprop" | "helicopter" | "jet";
+      dateIso: string;
+      startEpochSec: number;
+      endEpochSec: number;
+      startGeo: {
+        lat: number;
+        lon: number;
+        altMeters: number;
+      };
+      endGeo: {
+        lat: number;
+        lon: number;
+        altMeters: number;
+      };
+      groundspeedMps: number;
+      h3Cell: string;
+    };
+  }>>;
+  constellations: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    hashKey: z.ZodString;
+    dateIso: z.ZodString;
+    h3Cell: z.ZodString;
+    centerLat: z.ZodNumber;
+    centerLon: z.ZodNumber;
+    segmentIdA: z.ZodString;
+    segmentIdB: z.ZodString;
+    speedAMps: z.ZodNumber;
+    speedBMps: z.ZodNumber;
+    cpaDelayedEpochSecA: z.ZodNumber;
+    cpaDelayedEpochSecB: z.ZodNumber;
+    deltaSec: z.ZodNumber;
+  }, z.core.$strip> & {
+    readonly is: (value: unknown) => value is {
+      hashKey: string;
+      dateIso: string;
+      h3Cell: string;
+      centerLat: number;
+      centerLon: number;
+      segmentIdA: string;
+      segmentIdB: string;
+      speedAMps: number;
+      speedBMps: number;
+      cpaDelayedEpochSecA: number;
+      cpaDelayedEpochSecB: number;
+      deltaSec: number;
+    };
+  }>>;
+  elevationGrid: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    lat: z.ZodNumber;
+    lon: z.ZodNumber;
+    altMeters: z.ZodNumber;
+  }, z.core.$strip> & {
+    readonly is: (value: unknown) => value is {
+      lat: number;
+      lon: number;
+      altMeters: number;
+    };
+  }>>;
+}, z.core.$strip> & {
+  readonly is: (value: unknown) => value is {
+    version: string;
+    generatedAtIso: string;
+    segments: readonly {
+      id: string;
+      flightId: string;
+      icao24: string;
+      typeCode: string;
+      category: "unknown" | "piston" | "turboprop" | "helicopter" | "jet";
+      dateIso: string;
+      startEpochSec: number;
+      endEpochSec: number;
+      startGeo: {
+        lat: number;
+        lon: number;
+        altMeters: number;
+      };
+      endGeo: {
+        lat: number;
+        lon: number;
+        altMeters: number;
+      };
+      groundspeedMps: number;
+      h3Cell: string;
+    }[];
+    constellations: readonly {
+      hashKey: string;
+      dateIso: string;
+      h3Cell: string;
+      centerLat: number;
+      centerLon: number;
+      segmentIdA: string;
+      segmentIdB: string;
+      speedAMps: number;
+      speedBMps: number;
+      cpaDelayedEpochSecA: number;
+      cpaDelayedEpochSecB: number;
+      deltaSec: number;
+    }[];
+    elevationGrid: readonly {
+      lat: number;
+      lon: number;
+      altMeters: number;
+    }[];
+  };
+};
+type DopplerDataset = z.infer<typeof DopplerDatasetSchema>;
+/**
+ * A Zod schema that also carries the schema-attached type guard `is`.
+ */
+type Guarded<T extends z.ZodType> = T & {
+  readonly is: (value: unknown) => value is z.infer<T>;
+};
+/**
+ * Attaches a type guard to a Zod schema (the schema-attached guard pattern: validation, inference and narrowing share one definition, so the three cannot drift). The guard is defined on the schema object itself, because a Zod 4 schema keeps its methods on its prototype and its parse state on `_zod`: a spread copy loses the methods, so it could no longer be parsed or nested in another schema.
+ * @param schema - The schema to augment.
+ * @returns The same schema object, now also carrying `is`.
+ * @throws When the schema is non-extensible, so the guard cannot be attached, or when the property was not installed.
+ */
+declare function define<T extends z.ZodType>(schema: T): Guarded<T>;
+/**
+ * Reads an own property of a record keyed by strings that come from data. A plain `record[key]` read follows the prototype chain, so a key such as `constructor` would find an inherited function instead of reporting absence.
+ * @param record - The record to read.
+ * @param key - Any string.
+ * @returns The own property's value, or `undefined` when the record has no such own property.
+ */
+declare function getOwn<Value>(record: Readonly<Record<string, Value>>, key: string): Value | undefined;
+/**
+ * A record whose every key must satisfy `key`. Zod's own record silently drops an own `__proto__` key (which `JSON.parse` creates as an ordinary property) before the key schema sees it, so this checks the raw input first and rejects such a key loudly instead of losing the value.
+ * @param key - The key schema.
+ * @param value - The value schema.
+ * @returns The record schema.
+ */
+declare function recordOf<Value extends z.ZodType>(key: z.ZodString, value: Value): z.ZodPreprocess<z.ZodRecord<z.ZodString, Value>>;
+/** Half a turn in degrees: the span from the prime meridian to the antimeridian, and the divisor of the degrees-to-radians factor (a half turn is pi radians). */
+declare const HALF_TURN_DEG = 180;
+/** A full turn in degrees, the period of longitude. */
+declare const FULL_TURN_DEG: number;
+/**
+ * Converts a geodetic coordinate (latitude, longitude, altitude) to Earth-Centered, Earth-Fixed (ECEF) Cartesian coordinates in meters.
+ * @param point - Geodetic coordinate on or above WGS84.
+ * @returns ECEF vector in meters.
+ */
+declare function geoToEcef(point: Readonly<GeoPoint3D>): Vector3D;
+/**
+ * Converts a global displacement between two geodetic points into local East-North-Up (ENU) meters relative to the origin point.
+ * @param origin - Reference observer coordinate.
+ * @param target - Target aircraft or ground coordinate.
+ * @returns Local tangent-plane ENU vector in meters (x = East, y = North, z = Up).
+ */
+declare function geoToLocalEnu(origin: Readonly<GeoPoint3D>, target: Readonly<GeoPoint3D>): Vector3D;
+/**
+ * Projects a local East-North-Up (ENU) offset in meters from a reference geodetic origin back to geodetic coordinates.
+ * @param origin - Reference coordinate.
+ * @param enuOffset - Offset in local meters (x = East, y = North, z = Up).
+ * @returns Resulting geodetic coordinate.
+ */
+declare function localEnuToGeo(origin: Readonly<GeoPoint3D>, enuOffset: Readonly<Vector3D>): GeoPoint3D;
+/** Grid resolution tier that `encodeSpatialCell` uses when the caller does not choose one (about 3.5 km cells). */
+declare const DEFAULT_SPATIAL_RESOLUTION = 6;
+/** Boundary vertices used to approximate an ellipse outline when the caller does not choose a count. */
+declare const DEFAULT_ELLIPSE_SEGMENTS = 72;
+/** A horizontal ellipse on the ground: semi-axes in metres and the compass bearing of the major axis. */
+interface HorizontalEllipse {
+  readonly ellipseSemiMajorMeters: number;
+  readonly ellipseSemiMinorMeters: number;
+  readonly ellipseBearingDeg: number;
+}
+/**
+ * Samples the outline of a horizontal confidence ellipse as geodetic points. The axes are metric distances on the local tangent plane, so the outline keeps its true shape at any latitude, where a degree of longitude is shorter than a degree of latitude.
+ * @param center - Ellipse centre; every returned point keeps its altitude.
+ * @param ellipse - Semi-axes in metres and the compass bearing of the semi-major axis in degrees clockwise from north, as `fisherToConfidenceEllipse95` returns them.
+ * @param segments - Number of boundary segments. The returned ring repeats its first point, so it holds `segments + 1` points.
+ * @returns Closed ring of boundary points, starting due along the major axis.
+ */
+declare function ellipseOutline(center: Readonly<GeoPoint3D>, ellipse: Readonly<HorizontalEllipse>, segments?: number): readonly GeoPoint3D[];
+/**
+ * Computes the 3D Euclidean slant distance in meters between two geodetic coordinates.
+ * @param a - First 3D point.
+ * @param b - Second 3D point.
+ * @returns Slant distance in meters.
+ */
+declare function slantDistanceMeters(a: Readonly<GeoPoint3D>, b: Readonly<GeoPoint3D>): number;
+/**
+ * Encodes a latitude/longitude coordinate into a deterministic hierarchical spatial cell identifier at a given resolution step.
+ * @param lat - Latitude in degrees.
+ * @param lon - Longitude in degrees.
+ * @param resolution - Grid resolution tier (4 = ~20km, 6 = ~3.5km, 8 = ~500m).
+ * @returns Deterministic cell string identifier.
+ */
+declare function encodeSpatialCell(lat: number, lon: number, resolution?: number): string;
+/**
+ * Decodes a spatial cell identifier back to its center latitude and longitude in degrees.
+ * @param cellId - Spatial cell identifier produced by `encodeSpatialCell`.
+ * @returns Center latitude and longitude in degrees.
+ */
+declare function decodeSpatialCellCenter(cellId: string): {
+  readonly lat: number;
+  readonly lon: number;
+};
+/**
+ * Evaluates terrain elevation at a target coordinate via inverse-distance-weighted interpolation over a DEM grid.
+ * @param lat - Target latitude in degrees.
+ * @param lon - Target longitude in degrees.
+ * @param demGrid - Sparse or regular grid of elevation samples.
+ * @returns Interpolated terrain elevation in meters above sea level.
+ */
+declare function interpolateTerrainElevationMeters(lat: number, lon: number, demGrid: readonly GeoPoint3D[]): number;
+/** Speed of sound in dry air at 20 degrees Celsius in m/s, rounded to the nearest metre per second (`sqrt(GAMMA_DRY_AIR * R_DRY_AIR * 293.15)` is about 343.2). The default wherever a caller gives no temperature. */
+declare const DEFAULT_SOUND_SPEED_MPS = 343;
+/**
+ * Atmospheric state for acoustic wave propagation.
+ */
+interface AtmosphereState {
+  readonly groundTempCelsius: number;
+  readonly groundAltitudeMeters: number;
+  readonly windEnuMps?: Readonly<Vector3D>;
+}
+/**
+ * Computes the local phase speed of sound in meters per second at a given temperature in Celsius.
+ * @param tempCelsius - Ambient air temperature in degrees Celsius.
+ * @returns Speed of sound in m/s.
+ */
+declare function speedOfSoundAtTempMps(tempCelsius: number): number;
+/**
+ * Computes the effective path-integrated speed of sound between an aircraft at altitude and a ground observer, accounting for the tropospheric temperature lapse rate and wind advection along the line of sight.
+ * @param atmosphere - Ground temperature, elevation, and optional wind vector.
+ * @param aircraftAltMeters - Aircraft altitude above sea level in meters.
+ * @param unitPropagationDirEnu - Unit vector pointing from the aircraft to the observer in local ENU coordinates.
+ * @returns Effective acoustic propagation speed in m/s along the ray path.
+ */
+declare function effectiveRaySoundSpeedMps(atmosphere: Readonly<AtmosphereState>, aircraftAltMeters: number, unitPropagationDirEnu?: Readonly<Vector3D>): number;
+/**
+ * Input measurements from a spectrogram Doppler S-curve.
+ */
+interface DopplerCurveMeasurement {
+  readonly asymptoticHighHz: number;
+  readonly asymptoticLowHz: number;
+  readonly inflectionSlopeHzPerSec: number;
+  readonly soundSpeedMps?: number;
+  readonly freqMeasurementStdHz?: number;
+  readonly slopeMeasurementRelStd?: number;
+}
+/**
+ * Separates aircraft groundspeed `v`, unshifted engine fundamental `f0`, and 3D Closest Point of Approach (CPA) slant distance `d_slant` in O(1) closed-form algebra directly from a Doppler curve's asymptotes and inflection slope.
+ *
+ * Because `f+ / f- = (1 + v/c) / (1 - v/c)`, the unknown engine base pitch `f0` cancels out identically:
+ * - `v = c * (f+ - f-) / (f+ + f-)`
+ * - `f0 = 2 * f+ * f- / (f+ + f-)` (the harmonic mean)
+ * - `d_slant = - (f0 * v^2) / (c * df/dt|_CPA)`
+ * @param measurement - Measured approaching/receding frequencies and inflection slope.
+ * @returns Closed-form kinematic parameters and propagated standard deviations.
+ */
+declare function extractAsymptoticKinematics(measurement: Readonly<DopplerCurveMeasurement>): AsymptoticKinematics;
+/**
+ * Evaluated acoustic state of an aircraft at a specific observer reception timestamp.
+ */
+interface RetardedAcousticPoint {
+  readonly obsTimeSec: number;
+  readonly emitTimeSec: number;
+  readonly delaySec: number;
+  readonly slantDistanceMeters: number;
+  readonly radialVelocityMps: number;
+  readonly observedFreqHz: number;
+}
+/**
+ * Solves the exact subsonic Liénard-Wiechert retarded-time propagation delay `Δt = t_obs - t_emit` in closed form for a uniform linear trajectory segment.
+ *
+ * Given an aircraft position `r(t_emit) = r(t_obs) - v * Δt`, the acoustic propagation condition
+ * `c^2 * Δt^2 = || r(t_obs) - x_obs - v * Δt ||^2` is a quadratic equation in `Δt`:
+ * `(c^2 - v^2) * Δt^2 + 2 * (Δr · v) * Δt - ||Δr||^2 = 0`
+ * @param deltaPosEnu - Displacement vector `r(t_obs) - x_obs` in local ENU meters at reception time `t_obs`.
+ * @param velocityEnu - Aircraft velocity vector in local ENU meters per second.
+ * @param soundSpeedMps - Local speed of sound in meters per second.
+ * @returns Exact retarded propagation delay `Δt >= 0` in seconds.
+ */
+declare function solveRetardedDelaySec(deltaPosEnu: Readonly<{
+  readonly x: number;
+  readonly y: number;
+  readonly z: number;
+}>, velocityEnu: Readonly<{
+  readonly x: number;
+  readonly y: number;
+  readonly z: number;
+}>, soundSpeedMps: number): number;
+/**
+ * Computes the analytical Closest Point of Approach (CPA) emission time, delayed reception time, and 3D slant distance for an observer relative to a linear flight segment.
+ * @param observer - Candidate ground observer 3D coordinate.
+ * @param segment - Linear flight segment.
+ * @param soundSpeedMps - Effective speed of sound in m/s.
+ * @returns Emission CPA timestamp, delayed observer CPA timestamp, and minimum 3D slant distance in meters.
+ */
+declare function computeSegmentCpa(observer: Readonly<GeoPoint3D>, segment: Readonly<LinearFlightSegment>, soundSpeedMps?: number): {
+  readonly cpaEmitEpochSec: number;
+  readonly cpaDelayedEpochSec: number;
+  readonly cpaSlantMeters: number;
+};
+/**
+ * Options for synthesizing retarded-time Doppler curves.
+ */
+interface SynthesizeCurveOptions {
+  readonly baseFreqHz: number;
+  readonly obsEpochTimesSec: readonly number[];
+  readonly soundSpeedMps?: number;
+}
+/**
+ * Synthesizes the exact retarded-time Doppler curve observed on the ground for a linear flight segment at specified reception timestamps.
+ * @param observer - Ground observer 3D coordinate.
+ * @param segment - Linear flight segment.
+ * @param options - Base frequency, observation timestamps, and optional sound speed.
+ * @returns Evaluated retarded acoustic trajectory at each reception timestamp.
+ */
+declare function synthesizeRetardedDopplerCurve(observer: Readonly<GeoPoint3D>, segment: Readonly<LinearFlightSegment>, options: Readonly<SynthesizeCurveOptions>): RetardedAcousticPoint[];
+/**
+ * Metadata describing an aircraft trace being compressed into 4D linear segments.
+ */
+interface TraceMetadata {
+  readonly flightId: string;
+  readonly icao24: string;
+  readonly typeCode: string;
+  readonly category: AircraftCategory;
+  readonly dateIso: string;
+}
+/**
+ * Compresses a sequence of raw 1 Hz ADS-B pings into piecewise-linear 4D segments (`LinearFlightSegment`) with bounded spatiotemporal error.
+ * @param pings - Chronologically ordered raw ADS-B pings.
+ * @param meta - Flight and aircraft metadata.
+ * @param toleranceMeters - Maximum allowed 3D interpolation error in meters (default 5 m).
+ * @returns Array of compressed linear trajectory segments.
+ */
+declare function simplifyTrajectory4D(pings: readonly AdsbPing[], meta: Readonly<TraceMetadata>, toleranceMeters?: number): LinearFlightSegment[];
+/**
+ * A complex sequence stored as separate real and imaginary component arrays of equal length.
+ */
+interface ComplexSpectrum {
+  readonly real: Float64Array;
+  readonly imag: Float64Array;
+}
+/**
+ * Computes a Radix-2 Cooley-Tukey Complex Fast Fourier Transform without modifying its inputs: the samples are gathered into freshly allocated arrays in bit-reversed order and the butterflies run on those arrays.
+ * @param real - Real components array of power-of-two length N.
+ * @param imag - Imaginary components array of the same length N.
+ * @returns The forward transform (negative-exponent convention, unnormalised) as new arrays.
+ * @throws When N is not a positive power of two or the two arrays differ in length.
+ */
+declare function fft(real: Readonly<Float64Array>, imag: Readonly<Float64Array>): ComplexSpectrum;
+/**
+ * Computes the one-sided Hann-windowed power spectrum in decibels for a real-valued frame.
+ * @param samples - Input time-domain samples.
+ * @param fftSize - Power-of-two FFT size (zero-padded if `samples.length < fftSize`).
+ * @returns One-sided power spectrum in dB (`length = fftSize / 2 + 1`).
+ */
+declare function computeHannPowerSpectrumDb(samples: Readonly<Float32Array>, fftSize: number): Float64Array;
+/**
+ * Averages equal-length audio channels into one mono signal.
+ * @param channels - One sample array per channel; at least one, all of the same length.
+ * @returns The mono signal. A single channel is returned as a copy, never the caller's array.
+ */
+declare function downmixToMono(channels: readonly Readonly<Float32Array>[]): Float32Array;
+/**
+ * Designs a normalized Blackman-windowed sinc low-pass FIR filter kernel.
+ * @param cutoffHz - Low-pass cutoff frequency in Hz.
+ * @param sampleRateHz - Input sample rate in Hz.
+ * @param numTaps - Odd number of FIR filter taps.
+ * @returns Normalized FIR filter coefficients.
+ */
+declare function designLowPassFirKernel(cutoffHz: number, sampleRateHz: number, numTaps?: number): Float64Array;
+/**
+ * Decimates a high-sample-rate audio buffer (e.g. 48,000 Hz) down to a target sub-kilohertz/low-kilohertz rate (e.g. 2,000 Hz) after applying an anti-aliasing FIR low-pass filter.
+ * @param input - Input mono audio samples.
+ * @param inputRateHz - Original sample rate in Hz (e.g. 48000).
+ * @param targetRateHz - Decimated sample rate in Hz (default `ANALYSIS_SAMPLE_RATE_HZ`).
+ * @returns Decimated mono audio samples and actual output sample rate.
+ */
+declare function decimateAudioStream(input: Readonly<Float32Array>, inputRateHz: number, targetRateHz?: number): {
+  readonly samples: Float32Array;
+  readonly sampleRateHz: number;
+};
+/**
+ * Single Short-Time Fourier Transform (STFT) frame in the aircraft Doppler band (65 to 500 Hz by default).
+ */
+interface SpectrogramFrame {
+  readonly timeSec: number;
+  readonly powerDb: Float64Array;
+  readonly medianNoiseFloorDb: number;
+  readonly peakFreqHz: number;
+  readonly peakPowerDb: number;
+  readonly peakSnrDb: number;
+  readonly noisePolluted: boolean;
+}
+/**
+ * Computed spectrogram grid and continuous noise-floor telemetry over an audio recording or episode window.
+ */
+interface DopplerSpectrogram {
+  readonly sampleRateHz: number;
+  readonly fftSize: number;
+  readonly minFreqHz: number;
+  readonly maxFreqHz: number;
+  readonly minBin: number;
+  readonly maxBin: number;
+  readonly binStepHz: number;
+  readonly frames: readonly SpectrogramFrame[];
+  readonly quietIntervals: readonly QuietInterval[];
+  readonly overallMedianNoiseDb: number;
+}
+/**
+ * Configuration options for computing a Doppler spectrogram.
+ */
+interface SpectrogramOptions {
+  readonly sampleRateHz: number;
+  readonly startTimeSec?: number;
+  readonly fftSize?: number;
+  readonly hopSamples?: number;
+  readonly minFreqHz?: number;
+  readonly maxFreqHz?: number;
+  readonly noisePollutionThresholdDb?: number;
+}
+/**
+ * Options for computing an isolated single STFT frame.
+ */
+interface SingleFrameOptions {
+  readonly sampleRateHz: number;
+  readonly fftSize?: number;
+  readonly minFreqHz?: number;
+  readonly maxFreqHz?: number;
+  readonly timeSec?: number;
+  readonly noisePollutionThresholdDb?: number;
+  readonly baselineNoiseDb?: number;
+}
+/**
+ * Result of computing an isolated single STFT frame, including bin boundaries and frequency step.
+ */
+interface ComputedSingleFrame extends SpectrogramFrame {
+  readonly minBin: number;
+  readonly maxBin: number;
+  readonly binStepHz: number;
+}
+/**
+ * Computes an isolated single STFT spectrogram frame over a single time window.
+ * @param windowSlice - Time-domain audio slice (length must match fftSize).
+ * @param options - Single frame computation options.
+ * @returns Computed STFT frame, peak tracking values, and frequency bin parameters.
+ */
+declare function computeSingleSpectrogramFrame(windowSlice: Readonly<Float32Array>, options: Readonly<SingleFrameOptions>): ComputedSingleFrame;
+/**
+ * Computes a high-resolution spectrogram focused on the aircraft acoustic Doppler band (65 to 500 Hz by default), with parabolic sub-bin peak interpolation and continuous noise-pollution gating.
+ * @param samples - Decimated mono audio samples (typically at 2,000 Hz).
+ * @param options - Spectrogram configuration parameters.
+ * @returns Spectrogram frames, sub-bin peak tracks, and quiet intervals where silence filtering is valid.
+ */
+declare function computeDopplerSpectrogram(samples: Readonly<Float32Array>, options: Readonly<SpectrogramOptions>): DopplerSpectrogram;
+/**
+ * Options for extracting Doppler S-curve observations from a spectrogram.
+ */
+interface RidgeTrackerOptions {
+  readonly episodeId: string;
+  readonly minSnrDb?: number;
+  readonly minDurationSec?: number;
+  readonly minFreqDropHz?: number;
+  readonly soundSpeedMps?: number;
+}
+/**
+ * Extracts Doppler S-curve observations from a spectrogram, down-weighting noise-polluted frames and computing closed-form kinematics for each detected flyover.
+ * @param spectrogram - Computed spectrogram with noise-pollution flags.
+ * @param options - Tracker thresholds and episode context.
+ * @returns Array of detected aircraft Doppler observations.
+ */
+declare function extractDopplerObservations(spectrogram: Readonly<DopplerSpectrogram>, options: Readonly<RidgeTrackerOptions>): DopplerObservation[];
+/**
+ * Result of 1D emission-time de-chirping matched-filter evaluation.
+ */
+interface DechirpScoreResult {
+  readonly coherentSnrDb: number;
+  readonly recoveredBaseFreqHz: number;
+  readonly resampledSamples: Float32Array;
+}
+/**
+ * Options for emission-domain de-chirping analysis.
+ */
+interface DechirpOptions {
+  readonly sampleRateHz: number;
+  readonly bufferStartEpochSec: number;
+  readonly observer: Readonly<GeoPoint3D>;
+  readonly segment: Readonly<LinearFlightSegment>;
+  readonly expectedBaseFreqHz: number;
+  readonly soundSpeedMps?: number;
+}
+/**
+ * Evaluates a candidate observer coordinate and aircraft segment by resampling the raw 1D audio signal onto uniform aircraft emission times `t_emit`.
+ *
+ * Because `t_obs(t_emit) = t_emit + || r(t_emit) - x_obs || / c`, sampling the microphone waveform at `t_obs(t_emit)` undoes the Doppler time-dilation and collapses the curved 2-minute Doppler S-curve into a single stationary sinusoid at `f0`, providing ~20 dB of coherent FFT integration gain.
+ * @param samples - Decimated mono audio buffer.
+ * @param options - Dechirp options including observer, segment, and expected frequency.
+ * @returns Coherent FFT SNR in dB, recovered stationary peak frequency, and de-warped waveform.
+ */
+declare function scoreByEmissionDechirping(samples: Readonly<Float32Array>, options: Readonly<DechirpOptions>): DechirpScoreResult;
+/**
+ * Nominal frequency in Hz of a 50 Hz mains grid (Europe, the UK, Asia, Africa, Australia and eastern Japan).
+ */
+declare const GRID_50_NOMINAL_HZ = 50;
+/**
+ * Nominal frequency in Hz of a 60 Hz mains grid (North America, South Korea, Taiwan and western Japan).
+ */
+declare const GRID_60_NOMINAL_HZ = 60;
+/**
+ * A nominal mains-grid frequency that synthetic audio can carry as electric network hum.
+ */
+type NominalGridHz = typeof GRID_50_NOMINAL_HZ | typeof GRID_60_NOMINAL_HZ;
+/**
+ * Detects passive 50.00 Hz vs 60.00 Hz Electrical Network Frequency (ENF) mains hum in an audio buffer to split the global search space by power-grid hemisphere.
+ * @param samples - Audio samples.
+ * @param sampleRateHz - Sample rate in Hz.
+ * @returns Detected ENF nominal grid (50 Hz, 60 Hz, or unknown), SNR, and geographic region hint.
+ */
+declare function detectEnfSignature(samples: Readonly<Float32Array>, sampleRateHz: number): EnfSignature;
+/**
+ * Estimates ambient air temperature in degrees Celsius from cricket stridulation rate using Dolbear's Law (`T_C = 10 + (N_60 - 40) / 7`).
+ * @param chirpsPerMinute - Measured insect stridulation modulation pulses per minute.
+ * @returns Estimated ambient temperature in degrees Celsius.
+ */
+declare function estimateTempFromCricketChirpsCelsius(chirpsPerMinute: number): number;
+/**
+ * Parameters for synthesizing a realistic acoustic recording containing aircraft Doppler flyovers, optional 50/60 Hz ENF hum, and optional transient noise pollution bursts.
+ */
+interface SyntheticAudioConfig {
+  readonly sampleRateHz: number;
+  readonly startEpochSec: number;
+  readonly durationSec: number;
+  readonly observer: Readonly<GeoPoint3D>;
+  readonly flyovers: readonly {
+    readonly segment: Readonly<LinearFlightSegment>;
+    readonly baseFreqHz: number;
+    readonly amplitude: number;
+  }[];
+  readonly enfNominalHz?: NominalGridHz;
+  readonly enfAmplitude?: number;
+  readonly noiseStd?: number;
+  readonly noisePollutionBursts?: readonly {
+    readonly startOffsetSec: number;
+    readonly endOffsetSec: number;
+    readonly burstNoiseStd: number;
+  }[];
+}
+/**
+ * Synthesizes a realistic time-domain waveform (continuous phase integration of retarded Doppler frequencies + harmonics + ENF hum + deterministic pseudo-random noise) for testing, simulation, and verification.
+ * @param config - Simulation configuration.
+ * @returns Synthesized mono `Float32Array` audio buffer.
+ */
+declare function synthesizeMultiFlyoverAudio(config: Readonly<SyntheticAudioConfig>): Float32Array;
+/**
+ * Decodes a RIFF WAVE byte buffer into mono samples and its sample rate. Chunks are located by walking the chunk list, so metadata chunks (`JUNK`, `bext`, `LIST`) before `fmt ` or `data` are skipped, and an odd-sized chunk's pad byte is honoured. Multi-channel audio is averaged to mono.
+ * @param wavBytes - Raw `.wav` file bytes.
+ * @returns Decoded mono samples in `[-1, 1]` and the sample rate in Hz.
+ * @throws When the buffer is not RIFF/WAVE, has no `fmt ` or `data` chunk, declares no channels, or uses an unsupported tag or bit depth (8, 16, 24 and 32-bit integer PCM and 32 and 64-bit float are supported).
+ */
+declare function decodeWavBytes(wavBytes: Readonly<Uint8Array>): {
+  readonly samples: Float32Array;
+  readonly sampleRateHz: number;
+};
+/**
+ * Encodes a mono `Float32Array` audio buffer into a standard 16-bit PCM RIFF WAVE byte array.
+ * @param samples - Mono audio samples in `[-1, 1]`.
+ * @param sampleRateHz - Sample rate in Hz.
+ * @returns Complete `.wav` file bytes.
+ */
+declare function encodeWavPcm16(samples: Readonly<Float32Array>, sampleRateHz: number): Uint8Array;
+/** Number of buckets each side of the measured one that a query expands to on each key axis, so a measurement near a bucket boundary still finds its pair. */
+declare const QUERY_BUCKET_SPAN = 2;
+/**
+ * Computes a quantized Shazam-style constellation hash key from two aircraft groundspeeds and their delayed CPA time offset.
+ * @param speedAMps - Groundspeed of first flyover in m/s.
+ * @param speedBMps - Groundspeed of second flyover in m/s.
+ * @param deltaSec - Time offset `t_CPA_B - t_CPA_A` in seconds.
+ * @returns Quantized constellation hash key string.
+ */
+declare function formatConstellationKey(speedAMps: number, speedBMps: number, deltaSec: number): string;
+/**
+ * Generates neighbouring constellation hash keys within measurement tolerance (`QUERY_BUCKET_SPAN` buckets either side on each of the speed and time axes) to prevent boundary quantization misses.
+ * @param speedAMps - Inferred speed of first flyover in m/s.
+ * @param speedBMps - Inferred speed of second flyover in m/s.
+ * @param deltaSec - Measured CPA offset in seconds.
+ * @returns Set of candidate constellation hash keys.
+ */
+declare function expandConstellationQueryKeys(speedAMps: number, speedBMps: number, deltaSec: number): Set<string>;
+/**
+ * Options for indexing constellation pairs.
+ */
+interface BuildConstellationOptions {
+  readonly demGrid?: readonly GeoPoint3D[];
+  readonly soundSpeedMps?: number;
+}
+/**
+ * Builds the Shazam-style Constellation Index from a collection of 4D linear flight segments.
+ * Pairs any two non-jet segments passing within acoustic range (`MAX_PAIR_SLANT_METERS`) of the same cell, with closest-approach times between `MIN_PAIR_DELTA_SEC` and `MAX_PAIR_DELTA_SEC` apart, on the same date.
+ * @param segments - Linear flight segments.
+ * @param options - DEM elevation grid samples and speed of sound.
+ * @returns Array of indexed constellation pair entries.
+ */
+declare function buildConstellationIndex(segments: readonly LinearFlightSegment[], options?: Readonly<BuildConstellationOptions>): ConstellationEntry[];
+/**
+ * Candidate observer target coordinates and epoch timestamp tested against search constraints.
+ */
+interface CandidateConstraintTarget {
+  readonly lat: number;
+  readonly lon: number;
+  readonly dateIso: string;
+  readonly epochSec: number;
+}
+/**
+ * Checks whether a geographic coordinate and UTC epoch timestamp satisfy all active multi-axis user and side-channel constraints (Space, Date, Time of Day, and 50/60 Hz ENF power grid).
+ * @param target - Candidate coordinate, date, and epoch timestamp.
+ * @param constraints - Active multi-axis search constraints (any undefined field is treated as unconstrained `*`).
+ * @returns `true` if the candidate satisfies all specified constraints.
+ */
+declare function matchesSearchConstraints(target: Readonly<CandidateConstraintTarget>, constraints: Readonly<SearchConstraints>): boolean;
+/**
+ * Largest speed difference, in m/s, that a segment may have from a measured Doppler speed and still be a candidate: the admission gate applied to the wind spread.
+ */
+declare const MAX_ALONG_TRACK_WIND_MPS: number;
+/**
+ * Log-likelihood cost of leaving an observation unmatched. An observation that no segment explains contributes every residual term it would have had (one slant residual, one speed residual and one frequency residual per ridge point) at the outlier gate, so a hypothesis cannot outscore a rival by ignoring evidence: a poor fit costs at most this much, and an omission costs exactly this much.
+ * @param observation - The observation a hypothesis does not explain.
+ * @returns A non-negative amount to subtract from the hypothesis's log-posterior.
+ */
+declare function unmatchedObservationLogPenalty(observation: Readonly<DopplerObservation>): number;
+/**
+ * Smallest slant-distance standard deviation, in metres, the solver assumes for any observation, however sharp its fit. Positional error in the flight data below this is invisible to the solver.
+ */
+declare const SLANT_SIGMA_FLOOR_METERS = 40;
+/**
+ * Paired observation and flight segment constraint used during Gauss-Newton coordinate refinement.
+ */
+interface ObservationSegmentPair {
+  readonly observation: Readonly<DopplerObservation>;
+  readonly segment: Readonly<LinearFlightSegment>;
+}
+/**
+ * Output of the damped Gauss-Newton / Levenberg-Marquardt coordinate refinement and Fisher Information covariance estimator.
+ */
+interface RefinedLocationResult {
+  readonly lat: number;
+  readonly lon: number;
+  readonly altMeters: number;
+  readonly estimatedStartEpochSec: number;
+  readonly rmsFreqResidualHz: number;
+  readonly logLikelihood: number;
+  readonly fisherInfo: readonly [number, number, number, number];
+  readonly ellipseSemiMajorMeters: number;
+  readonly ellipseSemiMinorMeters: number;
+  readonly ellipseBearingDeg: number;
+}
+/**
+ * Converts a 2x2 Fisher Information matrix `[I_xx, I_xy, I_yx, I_yy]` in inverse-square meters into a 95% confidence ellipse (`chi2_2(0.95) = 5.991`).
+ * @param fisher - 2x2 symmetric Fisher Information matrix entries `[I_xx, I_xy, I_yx, I_yy]`.
+ * @returns Semi-major axis (m), semi-minor axis (m), and compass bearing of semi-major axis (degrees).
+ */
+declare function fisherToConfidenceEllipse95(fisher: readonly [number, number, number, number]): {
+  readonly ellipseSemiMajorMeters: number;
+  readonly ellipseSemiMinorMeters: number;
+  readonly ellipseBearingDeg: number;
+};
+/**
+ * Options for Levenberg-Marquardt coordinate refinement.
+ */
+interface RefineCoordinateOptions {
+  readonly demGrid?: readonly GeoPoint3D[];
+  readonly soundSpeedMps?: number;
+}
+/**
+ * Refines a candidate observer coordinate `(lat, lon)` without spatial grids using damped Levenberg-Marquardt nonlinear least squares and computes the 2x2 Fisher Information matrix and 95% confidence ellipse.
+ * @param seedGeo - Coarse initial coordinate (e.g. H3 cell center or cylinder intersection).
+ * @param pairs - Matched observation-to-segment pairs (1 or more flyovers).
+ * @param options - Terrain elevation grid and sound speed.
+ * @returns Optimized coordinate, log-likelihood, Fisher Information matrix, and 95% error ellipse.
+ */
+declare function refineObserverCoordinateGaussNewton(seedGeo: Readonly<GeoPoint3D>, pairs: readonly ObservationSegmentPair[], options?: Readonly<RefineCoordinateOptions>): RefinedLocationResult;
+/**
+ * Options for configuring or resuming a Doppler geolocation session.
+ */
+interface SessionEngineOptions {
+  readonly initialSession?: Readonly<LocationSession> | undefined;
+  readonly dataset: Readonly<DopplerDataset>;
+  readonly ambientTempCelsius?: number | undefined;
+  readonly constraints?: Readonly<SearchConstraints> | undefined;
+}
+/**
+ * Continuous & Episodic Bayesian Refinement Engine.
+ *
+ * Supports leaving the microphone running continuously, or pausing and resuming across hours, days,
+ * or device reboots. Ingests observations sequentially and computes an accumulating log-posterior
+ * surface and Fisher Information covariance matrix across surviving candidate hypotheses.
+ */
+declare class DopplerSessionEngine {
+  private session;
+  private readonly dataset;
+  private readonly segmentsById;
+  constructor(options: Readonly<SessionEngineOptions>);
+  /**
+   * Returns an immutable snapshot of the current session state.
+   */
+  getSession(): LocationSession;
+  /**
+   * Updates multi-axis user constraints (bounding box, date range, hour window, ENF grid) and prunes incompatible hypotheses.
+   */
+  updateConstraints(constraints: Readonly<SearchConstraints>): LocationSession;
+  /**
+   * Starts a new listening episode (e.g. user clicks "Start Listening" or device boots up).
+   */
+  startEpisode(startedAtEpochSec: number): ListeningEpisode;
+  /**
+   * Updates episode telemetry with real-time in-band noise floor and pollution gating.
+   */
+  updateEpisodeNoise(episodeId: string, currentNoiseFloorDb: number, noisePolluted: boolean, currentEpochSec: number): void;
+  /**
+   * Pauses an active listening episode (e.g. user pauses, device enters sleep, or ambient noise exceeds threshold).
+   */
+  pauseEpisode(episodeId: string, pausedAtEpochSec: number): void;
+  /**
+   * Resumes a paused episode or starts a follow-up active episode within the session.
+   */
+  resumeEpisode(episodeId: string, resumedAtEpochSec: number): ListeningEpisode;
+  /**
+   * Ingests an extracted DopplerObservation and performs sequential Bayesian refinement.
+   *
+   * - First flyover: creates candidate hypotheses along matching flight track cylinders.
+   * - Second flyover: queries constellation hash index or pairs with existing observation to collapse candidates to curve intersections.
+   * - Third+ flyovers: refits each surviving hypothesis on every flyover it explains, so the Fisher Information matrix is that of the joint fit (shrinking O(1/sqrt(N))) and no flyover is counted twice.
+   *
+   * An observation whose id was ingested before replaces it, and the hypotheses are rebuilt from the whole list: a live listener re-reports a growing flyover under one id, and the latest report must not stack on the earlier ones.
+   */
+  ingestObservation(obs: Readonly<DopplerObservation>): LocationSession;
+  private applyObservation;
+  /**
+   * Log-posterior of a hypothesis: the joint fit of the flyovers it explains, less the cost of every flyover it leaves unexplained.
+   */
+  private static scoreHypothesis;
+  /**
+   * Allowed speed difference between a measured Doppler speed and a segment's ground speed, which differ by the along-track wind.
+   */
+  private static speedTolerance;
+  /**
+   * Generates initial candidate hypotheses along flight tracks matching a single flyover.
+   */
+  private spawnInitialHypotheses;
+  /**
+   * Keeps the best-scoring hypotheses. Ranking comes before the cut: dataset order says nothing about fit, so cutting first can discard the true track.
+   */
+  private static keepBest;
+  /**
+   * Matches candidate constellations from the Shazam-style hash table.
+   */
+  private matchConstellations;
+  /**
+   * Sequentially refines existing candidate hypotheses by refitting each on every flyover it explains, the new one included.
+   */
+  private refineExistingHypotheses;
+}
+/**
+ * Reference ground truth observer location used for offline demonstration and regression testing.
+ * Oxford, UK (51.7520° N, 1.2577° W, elevation 64 m).
+ */
+declare const BUNDLED_GROUND_TRUTH: GeoPoint3D;
+/**
+ * Realistic piecewise-linear flight segments crossing the bundled reference region.
+ */
+declare const BUNDLED_SEGMENTS: readonly LinearFlightSegment[];
+/**
+ * Regional DEM grid surrounding the reference location.
+ */
+declare const BUNDLED_DEM_GRID: readonly GeoPoint3D[];
+/**
+ * Pre-indexed constellation entries built from the bundled reference segments.
+ */
+declare const BUNDLED_CONSTELLATIONS: {
+  hashKey: string;
+  dateIso: string;
+  h3Cell: string;
+  centerLat: number;
+  centerLon: number;
+  segmentIdA: string;
+  segmentIdB: string;
+  speedAMps: number;
+  speedBMps: number;
+  cpaDelayedEpochSecA: number;
+  cpaDelayedEpochSecB: number;
+  deltaSec: number;
+}[];
+/**
+ * Complete bundled DopplerDataset object available synchronously without network requests.
+ */
+declare const BUNDLED_DATASET: DopplerDataset;
+/**
+ * Synthesizes a realistic reference audio buffer containing the bundled flyovers and a 50 Hz European ENF mains hum.
+ * @param sampleRateHz - Audio sample rate (default 2000 Hz).
+ * @returns Decimated mono `Float32Array` audio samples.
+ */
+declare function generateBundledReferenceAudio(sampleRateHz?: number): Float32Array;
+/**
+ * Encodes the reference audio into a `.wav` byte array.
+ * @param sampleRateHz - Audio sample rate.
+ * @returns Raw `.wav` file bytes.
+ */
+declare function generateBundledReferenceWavBytes(sampleRateHz?: number): Uint8Array;
+export { computeSegmentCpa as $, QuietIntervalSchema as $t, synthesizeMultiFlyoverAudio as A, ConstellationEntry as At, SpectrogramOptions as B, GeoPoint3D as Bt, formatConstellationKey as C, define as Ct, SyntheticAudioConfig as D, AircraftCategorySchema as Dt, encodeWavPcm16 as E, AircraftCategory as Et, extractDopplerObservations as F, DopplerObservationSchema as Ft, downmixToMono as G, LinearFlightSegmentSchema as Gt, computeSingleSpectrogramFrame as H, HypothesisMatch as Ht, ComputedSingleFrame as I, DopplerRidgePoint as It, fft as J, LocationHypothesis as Jt, ComplexSpectrum as K, ListeningEpisode as Kt, DopplerSpectrogram as L, DopplerRidgePointSchema as Lt, DechirpScoreResult as M, DopplerDataset as Mt, scoreByEmissionDechirping as N, DopplerDatasetSchema as Nt, detectEnfSignature as O, AsymptoticKinematics as Ot, RidgeTrackerOptions as P, DopplerObservation as Pt, SynthesizeCurveOptions as Q, QuietInterval as Qt, SingleFrameOptions as R, EnfSignature as Rt, expandConstellationQueryKeys as S, getOwn as St, decodeWavBytes as T, AdsbPingSchema as Tt, decimateAudioStream as U, HypothesisMatchSchema as Ut, computeDopplerSpectrogram as V, GeoPoint3DSchema as Vt, designLowPassFirKernel as W, LinearFlightSegment as Wt, simplifyTrajectory4D as X, LocationSession as Xt, TraceMetadata as Y, LocationHypothesisSchema as Yt, RetardedAcousticPoint as Z, LocationSessionSchema as Zt, unmatchedObservationLogPenalty as _, geoToLocalEnu as _t, BUNDLED_SEGMENTS as a, DEFAULT_SOUND_SPEED_MPS as at, QUERY_BUCKET_SPAN as b, slantDistanceMeters as bt, DopplerSessionEngine as c, DEFAULT_ELLIPSE_SEGMENTS as ct, ObservationSegmentPair as d, HALF_TURN_DEG as dt, SearchConstraints as en, solveRetardedDelaySec as et, RefineCoordinateOptions as f, HorizontalEllipse as ft, refineObserverCoordinateGaussNewton as g, geoToEcef as gt, fisherToConfidenceEllipse95 as h, encodeSpatialCell as ht, BUNDLED_GROUND_TRUTH as i, AtmosphereState as it, DechirpOptions as j, ConstellationEntrySchema as jt, estimateTempFromCricketChirpsCelsius as k, AsymptoticKinematicsSchema as kt, SessionEngineOptions as l, DEFAULT_SPATIAL_RESOLUTION as lt, SLANT_SIGMA_FLOOR_METERS as m, ellipseOutline as mt, BUNDLED_DATASET as n, Vector3D as nn, DopplerCurveMeasurement as nt, generateBundledReferenceAudio as o, effectiveRaySoundSpeedMps as ot, RefinedLocationResult as p, decodeSpatialCellCenter as pt, computeHannPowerSpectrumDb as q, ListeningEpisodeSchema as qt, BUNDLED_DEM_GRID as r, Vector3DSchema as rn, extractAsymptoticKinematics as rt, generateBundledReferenceWavBytes as s, speedOfSoundAtTempMps as st, BUNDLED_CONSTELLATIONS as t, SearchConstraintsSchema as tn, synthesizeRetardedDopplerCurve as tt, MAX_ALONG_TRACK_WIND_MPS as u, FULL_TURN_DEG as ut, BuildConstellationOptions as v, interpolateTerrainElevationMeters as vt, matchesSearchConstraints as w, AdsbPing as wt, buildConstellationIndex as x, recordOf as xt, CandidateConstraintTarget as y, localEnuToGeo as yt, SpectrogramFrame as z, EnfSignatureSchema as zt };