space-data-module-sdk 0.8.14 → 0.8.16

package/src/conformance/selfTest.js

@@ -0,0 +1,275 @@
+/**
+ * `space-data-module conformance propagator --self-test` — must exit 0 BY
+ * failing (finding §5). A gate never observed to fail is indistinguishable
+ * from one that cannot fail, so the runner ships with a battery of mock
+ * propagators, each carrying ONE planted defect drawn from a real defect this
+ * program found in the wild, and requires the suite to catch every one of
+ * them — plus a conformant baseline it must NOT flag.
+ *
+ * The mocks implement the same driver interface the WASM ABI driver exposes,
+ * so the suite under test is byte-for-byte the suite that adjudicates real
+ * artifacts. No toolchain, no artifact, no network.
+ */
+
+import { ORBPRO_STATE_VECTOR, ReferenceFrame, StateFlags, ErrorCode, REQUIRED_ABI_EXPORTS } from "./abiDriver.js";
+import { computeVerdict, runPropagatorSuite } from "./propagatorSuite.js";
+import { BANDS_DEFAULT, buildSelfTestCorpus } from "./selfTestCorpus.js";
+import { propagateTwoBody } from "./twoBodyReference.js";
+
+const PAGE = 65536;
+
+/** Encode a state through the GENERATED layout, so byte-identity is honest. */
+function packStateVector(state) {
+  const bytes = new Uint8Array(ORBPRO_STATE_VECTOR.size);
+  const view = new DataView(bytes.buffer);
+  const { offsets } = ORBPRO_STATE_VECTOR;
+  view.setFloat64(offsets.epoch, state.epoch, true);
+  for (const axis of [0, 1, 2]) {
+    view.setFloat64(offsets.position + axis * 8, state.position[axis], true);
+    view.setFloat64(offsets.velocity + axis * 8, state.velocity[axis], true);
+  }
+  view.setUint8(offsets.reference_frame, state.referenceFrame);
+  bytes[offsets.reference_frame + 1] = state.reserved?.[0] ?? 0;
+  bytes[offsets.reference_frame + 2] = state.reserved?.[1] ?? 0;
+  bytes[offsets.reference_frame + 3] = state.reserved?.[2] ?? 0;
+  view.setUint32(offsets.flags, state.flags, true);
+  return bytes;
+}
+
+function decodePacked(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const { offsets } = ORBPRO_STATE_VECTOR;
+  return {
+    epoch: view.getFloat64(offsets.epoch, true),
+    position: [0, 1, 2].map((axis) => view.getFloat64(offsets.position + axis * 8, true)),
+    velocity: [0, 1, 2].map((axis) => view.getFloat64(offsets.velocity + axis * 8, true)),
+    referenceFrame: view.getUint8(offsets.reference_frame),
+    reserved: [1, 2, 3].map((i) => view.getUint8(offsets.reference_frame + i)),
+    flags: view.getUint32(offsets.flags, true),
+  };
+}
+
+/**
+ * A mock propagator with a simulated linear memory (never shrinks, grows in
+ * whole pages — WebAssembly semantics, so the leak test measures the same
+ * thing it measures on a real artifact).
+ */
+class MockPropagatorDriver {
+  constructor(defect = null) {
+    this.defect = defect;
+    this.records = null;
+    // One page: tight enough that a per-cycle leak of a few KiB reaches a
+    // page boundary inside the self-test's measurement window.
+    this.capacityBytes = PAGE;
+    this.arenaBytes = 0;
+    this.bumpBytes = 0;
+    this.callSerial = 0;
+  }
+
+  exportNames() {
+    if (this.defect === "missing-exports") {
+      return REQUIRED_ABI_EXPORTS.filter((name) => name !== "plugin_destroy");
+    }
+    return [...REQUIRED_ABI_EXPORTS];
+  }
+
+  memoryBytes() {
+    return this.capacityBytes;
+  }
+
+  #reserve(byteLength) {
+    this.arenaBytes += byteLength;
+    const needed = this.arenaBytes + this.bumpBytes;
+    while (needed > this.capacityBytes) {
+      this.capacityBytes += PAGE;
+    }
+  }
+
+  alloc(byteLength) {
+    this.bumpBytes += byteLength;
+    const needed = this.arenaBytes + this.bumpBytes;
+    while (needed > this.capacityBytes) {
+      this.capacityBytes += PAGE;
+    }
+    return 8; // aligned, non-zero; the mock has no real address space
+  }
+
+  free() {
+    // bump allocator: freed on destroy, like the reference module's arena
+  }
+
+  #validate(record) {
+    if (!(record.eccentricity < 1) || !(record.meanMotionRevPerDay > 0)) {
+      return false;
+    }
+    return true;
+  }
+
+  initFromOmm(records) {
+    if (this.defect !== "confident-nonsense") {
+      for (const record of records) {
+        if (!this.#validate(record)) return ErrorCode.UNPHYSICAL;
+      }
+    }
+    this.records = [...records];
+    this.#reserve(records.length * 88);
+    return this.records.length;
+  }
+
+  ingestOne(record) {
+    if (this.defect !== "confident-nonsense" && !this.#validate(record)) {
+      return ErrorCode.UNPHYSICAL;
+    }
+    if (!this.records) this.records = [];
+    this.records.push(record);
+    this.#reserve(88);
+    if (this.defect === "count-fallback") {
+      // The defect the create-returns-handle primitive exists to kill: the
+      // module "returns success" instead of the handle it assigned.
+      return 0;
+    }
+    return this.records.length - 1;
+  }
+
+  #state(julianDate, record) {
+    const propagated = propagateTwoBody(record, julianDate);
+    let { position, velocity } = propagated;
+    if (this.defect === "units-km") {
+      position = position.map((value) => value / 1000);
+      velocity = velocity.map((value) => value / 1000);
+    }
+    if (this.defect === "nondeterministic") {
+      this.callSerial += 1;
+      position = position.map((value) => value + this.callSerial * 1e-9);
+    }
+    return {
+      epoch: julianDate,
+      position,
+      velocity,
+      referenceFrame:
+        this.defect === "frame-lies" ? ReferenceFrame.TEME : ReferenceFrame.ECEF,
+      reserved: [0, 0, 0],
+      flags: StateFlags.VALID,
+    };
+  }
+
+  propagate(julianDate, entityIndex) {
+    if (!this.records || this.records.length === 0) {
+      return { status: ErrorCode.NOT_INITIALIZED, state: null, bytes: new Uint8Array(64) };
+    }
+    if (!(entityIndex >= 0 && entityIndex < this.records.length)) {
+      return { status: ErrorCode.BAD_ENTITY_INDEX, state: null, bytes: new Uint8Array(64) };
+    }
+    const bytes = packStateVector(this.#state(julianDate, this.records[entityIndex]));
+    return { status: ErrorCode.OK, state: decodePacked(bytes), bytes };
+  }
+
+  propagateBatch(julianDate, count) {
+    if (!this.records || this.records.length === 0) {
+      return { status: ErrorCode.NOT_INITIALIZED, states: [] };
+    }
+    if (!(count >= 0 && count <= this.records.length)) {
+      return { status: ErrorCode.BAD_ENTITY_INDEX, states: [] };
+    }
+    const states = [];
+    for (let index = 0; index < count; index += 1) {
+      const state = this.#state(julianDate, this.records[index]);
+      if (this.defect === "batch-divergence") {
+        state.position = [state.position[0] + 1e-3, state.position[1], state.position[2]];
+      }
+      states.push(decodePacked(packStateVector(state)));
+    }
+    return { status: ErrorCode.OK, states };
+  }
+
+  entityCount() {
+    return this.records ? this.records.length : 0;
+  }
+
+  destroy() {
+    this.records = null;
+    this.bumpBytes = 0;
+    if (this.defect !== "leaky-destroy") {
+      this.arenaBytes = 0;
+    }
+    // capacityBytes deliberately never shrinks: wasm linear memory semantics.
+  }
+}
+
+/**
+ * Every planted defect names the check that must catch it. Each is a real
+ * defect class this program found live (finding §4): the 1000x units error,
+ * the {} destroy, the silent acceptance of unphysical elements, the count-1
+ * identity race, an undeclared frame, a batch path that is not the same
+ * physics, nondeterminism.
+ */
+export const PLANTED_DEFECTS = Object.freeze([
+  { defect: "units-km", mustFail: "tierB/anchors" },
+  { defect: "leaky-destroy", mustFail: "tier4/lifecycle-leak" },
+  { defect: "confident-nonsense", mustFail: "tierC/typed-refusals" },
+  { defect: "count-fallback", mustFail: "tierC/create-returns-handle" },
+  { defect: "frame-lies", mustFail: "tierC/frame-flags-reserved-declared" },
+  { defect: "batch-divergence", mustFail: "tierC/batch-single-agreement" },
+  { defect: "nondeterministic", mustFail: "tierC/determinism-byte-identity" },
+  { defect: "missing-exports", mustFail: "tier0/instantiation-and-exports" },
+]);
+
+/**
+ * Run the self-test. Returns {ok, results}: ok only when the baseline mock is
+ * clean AND every planted defect is caught by the check that owns it.
+ */
+export async function runPropagatorSelfTest(options = {}) {
+  const corpus = buildSelfTestCorpus();
+  // Small leak windows: the mocks' allocator is deterministic, so the steady
+  // state is reached immediately; what matters is that the LEAKY mock grows.
+  const leak = options.leak ?? { warmupCycles: 6, measureCycles: 40, entities: 128 };
+  const results = [];
+
+  const baselineChecks = await runPropagatorSuite(
+    async () => new MockPropagatorDriver(null),
+    { corpus, leak },
+  );
+  const baselineVerdict = computeVerdict(baselineChecks);
+  const baselineOk = baselineVerdict !== "FAIL";
+  results.push({
+    scenario: "baseline-conformant-mock",
+    expected: "no failures",
+    verdict: baselineVerdict,
+    ok: baselineOk,
+    failed: baselineChecks.filter((check) => check.status === "fail").map((c) => c.id),
+  });
+
+  for (const { defect, mustFail } of PLANTED_DEFECTS) {
+    const checks = await runPropagatorSuite(
+      async () => new MockPropagatorDriver(defect),
+      { corpus, leak },
+    );
+    const verdict = computeVerdict(checks);
+    const failedIds = checks.filter((check) => check.status === "fail").map((c) => c.id);
+    const caught = verdict === "FAIL" && failedIds.includes(mustFail);
+    results.push({
+      scenario: `planted:${defect}`,
+      expected: `FAIL at ${mustFail}`,
+      verdict,
+      ok: caught,
+      failed: failedIds,
+    });
+  }
+
+  return { ok: results.every((entry) => entry.ok), results, bands: BANDS_DEFAULT };
+}
+
+export function formatSelfTestReport(outcome) {
+  const lines = [];
+  lines.push(
+    `conformance self-test — ${outcome.ok ? "OK (the gate has been seen to fail)" : "BROKEN"}`,
+  );
+  for (const entry of outcome.results) {
+    const marker = entry.ok ? "ok  " : "MISS";
+    lines.push(
+      `  [${marker}] ${entry.scenario}: expected ${entry.expected}, verdict ${entry.verdict}` +
+        (entry.failed.length > 0 ? ` (failed: ${entry.failed.join(", ")})` : ""),
+    );
+  }
+  return lines.join("\n");
+}

package/src/conformance/selfTestCorpus.js

@@ -0,0 +1,68 @@
+/**
+ * The self-test's corpus: generated at runtime from the independent two-body
+ * closed form, in exactly the vectors.json format the real kits use
+ * (space-data-network-modules propagator/keplerian-reference/vectors/ is the
+ * committed exemplar). Generating rather than committing keeps the self-test
+ * free of a data file that could drift from the generator — the corpus IS the
+ * generator here, which is admissible only because the self-test's job is to
+ * prove the SUITE can fail, not to conformance-test a real module.
+ */
+
+import { ReferenceFrame, StateFlags } from "./abiDriver.js";
+import { GENERIC_ELEMENTS } from "./propagatorSuite.js";
+import { MU, propagateTwoBody } from "./twoBodyReference.js";
+
+/** The exemplar corpus's tolerance bands, per quantity. */
+export const BANDS_DEFAULT = Object.freeze({
+  position: Object.freeze({ abs: 1e-6, rel: 1e-9 }),
+  velocity: Object.freeze({ abs: 1e-9, rel: 1e-9 }),
+  time: Object.freeze({ abs: 1e-9, rel: 0 }),
+});
+
+export function buildSelfTestCorpus() {
+  const offsetsMinutes = [0, 45, 720];
+  const cases = [];
+  for (const elements of GENERIC_ELEMENTS) {
+    for (const minutes of offsetsMinutes) {
+      const julianDate = elements.epochJd + minutes / 1440;
+      const { position, velocity } = propagateTwoBody(elements, julianDate);
+      cases.push({
+        id: `self-test-${elements.noradCatId}@+${minutes}min`,
+        tier: "B",
+        operation: "plugin_propagate",
+        params: { elements, julianDate },
+        expect: {
+          "position.0": position[0],
+          "position.1": position[1],
+          "position.2": position[2],
+          "velocity.0": velocity[0],
+          "velocity.1": velocity[1],
+          "velocity.2": velocity[2],
+          epoch: julianDate,
+          reference_frame: ReferenceFrame.ECEF,
+          flags: StateFlags.VALID,
+        },
+        band: BANDS_DEFAULT,
+      });
+    }
+  }
+
+  return {
+    schemaVersion: 1,
+    conformance: {
+      model: "two-body point-mass, no drag, no J2, no third bodies",
+      mu: MU,
+      units: "SI throughout: metres, metres/second, Julian days, degrees on input",
+      outputFrame: `ECEF (${ReferenceFrame.ECEF})`,
+    },
+    tolerancePolicy: "fail <=> |observed - expected| > abs + rel * |expected|",
+    invariants: [
+      { id: "vis-viva-closure", tier: "C", applies: "every propagated state" },
+      { id: "period-closure", tier: "C", applies: "every element set" },
+      { id: "determinism", tier: "C", applies: "every case" },
+      { id: "frame-and-flags-declared", tier: "C", applies: "every propagated state" },
+      { id: "refusal-is-typed", tier: "C", applies: "every documented failure" },
+    ],
+    cases,
+  };
+}

package/src/conformance/twoBodyReference.js

@@ -0,0 +1,132 @@
+/**
+ * Independent two-body closed form, for the conformance runner's SELF-TEST.
+ *
+ * This is adjudication scaffolding, not product physics: the finding's Tier B
+ * definition REQUIRES anchors computed independently of any module under test
+ * (graph/findings/official-harness-shapes.md §5), and the self-test needs a
+ * conformant baseline to prove that every planted defect is caught. Written
+ * from the textbook relations; it mirrors — by construction, not by copy-check
+ * — the reference corpus generator in space-data-network-modules
+ * propagator/keplerian-reference/vectors/index.mjs. Where the two agree, they
+ * agree because two-body motion has one answer.
+ */
+
+/// WGS-72 gravitational parameter, m^3/s^2 — the model OMM mean elements are
+/// fitted under.
+export const MU = 398600.8e9;
+
+/// Earth rotation rate, rad/s (IAU 1982).
+export const EARTH_ROTATION_RATE = 7.292115146706979e-5;
+
+export const SECONDS_PER_DAY = 86400.0;
+export const J2000_JD = 2451545.0;
+
+/** `fail <=> |observed - expected| > abs + rel * |expected|` */
+export function withinBand(observed, expected, band) {
+  return Math.abs(observed - expected) <= band.abs + band.rel * Math.abs(expected);
+}
+
+/** Solve Kepler's equation independently of any module under test. */
+export function solveKepler(meanAnomaly, eccentricity) {
+  let M = meanAnomaly % (2 * Math.PI);
+  if (M < 0) M += 2 * Math.PI;
+  let E = eccentricity < 0.8 ? M : Math.PI;
+  for (let i = 0; i < 200; i += 1) {
+    const f = E - eccentricity * Math.sin(E) - M;
+    const fp = 1 - eccentricity * Math.cos(E);
+    const d = f / fp;
+    E -= d;
+    if (Math.abs(d) < 1e-15) return E;
+  }
+  throw new Error("reference Kepler solve did not converge");
+}
+
+/** Greenwich Mean Sidereal Time, radians (IAU 1982). */
+export function gmstRadians(julianDate) {
+  const tut1 = (julianDate - J2000_JD) / 36525.0;
+  const seconds =
+    67310.54841 +
+    (876600.0 * 3600.0 + 8640184.812866) * tut1 +
+    0.093104 * tut1 * tut1 -
+    6.2e-6 * tut1 * tut1 * tut1;
+  let gmst = (seconds * ((2 * Math.PI) / SECONDS_PER_DAY)) % (2 * Math.PI);
+  if (gmst < 0) gmst += 2 * Math.PI;
+  return gmst;
+}
+
+/**
+ * Closed-form two-body propagation from mean elements to an ECEF state, in
+ * METERS (the ABI's normative unit — the km/meters contradiction was W0.1).
+ */
+export function propagateTwoBody(elements, julianDate) {
+  const {
+    epochJd,
+    meanMotionRevPerDay,
+    eccentricity,
+    inclinationDeg,
+    raOfAscNodeDeg,
+    argOfPericenterDeg,
+    meanAnomalyDeg,
+  } = elements;
+
+  const deg = Math.PI / 180;
+  const n = (meanMotionRevPerDay * 2 * Math.PI) / SECONDS_PER_DAY;
+  const a = Math.cbrt(MU / (n * n));
+  const dt = (julianDate - epochJd) * SECONDS_PER_DAY;
+  const M = meanAnomalyDeg * deg + n * dt;
+  const E = solveKepler(M, eccentricity);
+
+  const cosE = Math.cos(E);
+  const sinE = Math.sin(E);
+  const beta = Math.sqrt(1 - eccentricity * eccentricity);
+  const xPqw = a * (cosE - eccentricity);
+  const yPqw = a * beta * sinE;
+  const eDot = n / (1 - eccentricity * cosE);
+  const vxPqw = -a * sinE * eDot;
+  const vyPqw = a * beta * cosE * eDot;
+
+  const O = raOfAscNodeDeg * deg;
+  const i = inclinationDeg * deg;
+  const w = argOfPericenterDeg * deg;
+  const cO = Math.cos(O);
+  const sO = Math.sin(O);
+  const ci = Math.cos(i);
+  const si = Math.sin(i);
+  const cw = Math.cos(w);
+  const sw = Math.sin(w);
+
+  const r11 = cO * cw - sO * sw * ci;
+  const r12 = -cO * sw - sO * cw * ci;
+  const r21 = sO * cw + cO * sw * ci;
+  const r22 = -sO * sw + cO * cw * ci;
+  const r31 = sw * si;
+  const r32 = cw * si;
+
+  const xI = r11 * xPqw + r12 * yPqw;
+  const yI = r21 * xPqw + r22 * yPqw;
+  const zI = r31 * xPqw + r32 * yPqw;
+  const vxI = r11 * vxPqw + r12 * vyPqw;
+  const vyI = r21 * vxPqw + r22 * vyPqw;
+  const vzI = r31 * vxPqw + r32 * vyPqw;
+
+  const theta = gmstRadians(julianDate);
+  const ct = Math.cos(theta);
+  const st = Math.sin(theta);
+
+  const x = ct * xI + st * yI;
+  const y = -st * xI + ct * yI;
+  const z = zI;
+  const vxRot = ct * vxI + st * vyI;
+  const vyRot = -st * vxI + ct * vyI;
+
+  return {
+    position: [x, y, z],
+    velocity: [
+      vxRot + EARTH_ROTATION_RATE * y,
+      vyRot - EARTH_ROTATION_RATE * x,
+      vzI,
+    ],
+    semiMajorAxis: a,
+    meanMotion: n,
+  };
+}

package/src/generated/orbpro/events-abi.js

@@ -0,0 +1,206 @@
+// ===========================================================================
+// GENERATED FILE — DO NOT EDIT.
+//
+// Source of truth : schemas/orbpro/Events.fbs
+// Generator       : scripts/generate-events-abi.mjs
+// Drift gate      : scripts/check-events-abi.mjs  (runs in `npm test`)
+// Contract        : docs/events-abi.md
+//
+// These constants exist so that no JavaScript consumer ever hard-codes a byte
+// offset again. Read a state vector with ORBPRO_STATE_VECTOR.offsets.position,
+// never with the literal 8.
+// ===========================================================================
+
+export { ReferenceFrame } from "./propagator-abi.js";
+
+export const RootMethod = Object.freeze({
+  BRENT: 0,
+  BISECTION: 1,
+  ILLINOIS: 2,
+});
+
+export const CrossingDirection = Object.freeze({
+  FALLING: -1,
+  ANY: 0,
+  RISING: 1,
+});
+
+export const RootStatus = Object.freeze({
+  CONVERGED: 0,
+  MAX_ITERATIONS: 1,
+  FLAT_BRACKET: 2,
+  DISCONTINUOUS: 3,
+  TRUNCATED: 4,
+  EPOCH_RESOLUTION_LIMITED: 5,
+});
+
+export const Sign = Object.freeze({
+  NEGATIVE: -1,
+  ZERO: 0,
+  POSITIVE: 1,
+});
+
+export const EventFlags = Object.freeze({
+  NONE: 0,
+  INTERVAL_OPEN_AT_START: 1,
+  INTERVAL_OPEN_AT_END: 2,
+  TANGENTIAL: 4,
+  ON_SCAN_BOUNDARY: 8,
+  BACKWARD: 16,
+  STOP_CONDITION: 32,
+});
+
+export const EventError = Object.freeze({
+  INTERNAL: -25,
+  SUPPLY_COUNT_MISMATCH: -24,
+  PROTOCOL_ORDER: -23,
+  BUFFER_TOO_SMALL: -22,
+  UNKNOWN_COMPONENT: -21,
+  NOT_STARTED: -20,
+  UNPHYSICAL: -6,
+  NOT_CONVERGED: -5,
+  BAD_INPUT: -4,
+  NULL_OUTPUT: -3,
+  BAD_OBJECT_INDEX: -2,
+  NOT_CONFIGURED: -1,
+  OK: 0,
+});
+
+export const ComponentContinuity = Object.freeze({
+  SMOOTH: 0,
+  PIECEWISE: 1,
+  DISCRETE: 2,
+});
+
+export const ORBPRO_ROOT_POLICY = Object.freeze({
+  name: "RootPolicy",
+  cName: "OrbProRootPolicy",
+  size: 32,
+  alignment: 8,
+  offsets: Object.freeze({
+    scan_step_seconds: 0,
+    epoch_tolerance_seconds: 8,
+    value_tolerance: 16,
+    max_iterations: 24,
+    method: 28,
+  }),
+  fields: Object.freeze({
+    scan_step_seconds: Object.freeze({ offset: 0, size: 8, length: 1, view: "Float64" }),
+    epoch_tolerance_seconds: Object.freeze({ offset: 8, size: 8, length: 1, view: "Float64" }),
+    value_tolerance: Object.freeze({ offset: 16, size: 8, length: 1, view: "Float64" }),
+    max_iterations: Object.freeze({ offset: 24, size: 4, length: 1, view: "Uint32" }),
+    method: Object.freeze({ offset: 28, size: 1, length: 1, view: "Uint8" }),
+  }),
+});
+
+export const ORBPRO_EVENT_INTERVAL = Object.freeze({
+  name: "EventInterval",
+  cName: "OrbProEventInterval",
+  size: 56,
+  alignment: 8,
+  offsets: Object.freeze({
+    start_jd_day: 0,
+    start_seconds: 8,
+    stop_jd_day: 16,
+    stop_seconds: 24,
+    max_events: 32,
+    max_evaluations: 36,
+    occurrence: 40,
+    component: 44,
+    flags: 48,
+    direction: 52,
+  }),
+  fields: Object.freeze({
+    start_jd_day: Object.freeze({ offset: 0, size: 8, length: 1, view: "Float64" }),
+    start_seconds: Object.freeze({ offset: 8, size: 8, length: 1, view: "Float64" }),
+    stop_jd_day: Object.freeze({ offset: 16, size: 8, length: 1, view: "Float64" }),
+    stop_seconds: Object.freeze({ offset: 24, size: 8, length: 1, view: "Float64" }),
+    max_events: Object.freeze({ offset: 32, size: 4, length: 1, view: "Uint32" }),
+    max_evaluations: Object.freeze({ offset: 36, size: 4, length: 1, view: "Uint32" }),
+    occurrence: Object.freeze({ offset: 40, size: 4, length: 1, view: "Uint32" }),
+    component: Object.freeze({ offset: 44, size: 4, length: 1, view: "Uint32" }),
+    flags: Object.freeze({ offset: 48, size: 4, length: 1, view: "Uint32" }),
+    direction: Object.freeze({ offset: 52, size: 1, length: 1, view: "Int8" }),
+  }),
+});
+
+export const ORBPRO_EVENT_HIT = Object.freeze({
+  name: "EventHit",
+  cName: "OrbProEventHit",
+  size: 48,
+  alignment: 8,
+  offsets: Object.freeze({
+    epoch_jd_day: 0,
+    epoch_seconds: 8,
+    value: 16,
+    component: 24,
+    iterations: 28,
+    evaluations: 32,
+    flags: 36,
+    direction: 40,
+    status: 41,
+  }),
+  fields: Object.freeze({
+    epoch_jd_day: Object.freeze({ offset: 0, size: 8, length: 1, view: "Float64" }),
+    epoch_seconds: Object.freeze({ offset: 8, size: 8, length: 1, view: "Float64" }),
+    value: Object.freeze({ offset: 16, size: 8, length: 1, view: "Float64" }),
+    component: Object.freeze({ offset: 24, size: 4, length: 1, view: "Uint32" }),
+    iterations: Object.freeze({ offset: 28, size: 4, length: 1, view: "Uint32" }),
+    evaluations: Object.freeze({ offset: 32, size: 4, length: 1, view: "Uint32" }),
+    flags: Object.freeze({ offset: 36, size: 4, length: 1, view: "Uint32" }),
+    direction: Object.freeze({ offset: 40, size: 1, length: 1, view: "Int8" }),
+    status: Object.freeze({ offset: 41, size: 1, length: 1, view: "Uint8" }),
+  }),
+});
+
+export const ORBPRO_EVENT_SCAN_SUMMARY = Object.freeze({
+  name: "EventScanSummary",
+  cName: "OrbProEventScanSummary",
+  size: 32,
+  alignment: 8,
+  offsets: Object.freeze({
+    initial_value: 0,
+    final_value: 8,
+    component: 16,
+    crossing_count: 20,
+    evaluation_count: 24,
+    initial_sign: 28,
+    final_sign: 29,
+  }),
+  fields: Object.freeze({
+    initial_value: Object.freeze({ offset: 0, size: 8, length: 1, view: "Float64" }),
+    final_value: Object.freeze({ offset: 8, size: 8, length: 1, view: "Float64" }),
+    component: Object.freeze({ offset: 16, size: 4, length: 1, view: "Uint32" }),
+    crossing_count: Object.freeze({ offset: 20, size: 4, length: 1, view: "Uint32" }),
+    evaluation_count: Object.freeze({ offset: 24, size: 4, length: 1, view: "Uint32" }),
+    initial_sign: Object.freeze({ offset: 28, size: 1, length: 1, view: "Int8" }),
+    final_sign: Object.freeze({ offset: 29, size: 1, length: 1, view: "Int8" }),
+  }),
+});
+
+export const ORBPRO_EVENT_STATE_REQUEST = Object.freeze({
+  name: "EventStateRequest",
+  cName: "OrbProEventStateRequest",
+  size: 16,
+  alignment: 4,
+  offsets: Object.freeze({
+    epoch_count: 0,
+    object_count: 4,
+    reference_frame: 8,
+    flags: 12,
+  }),
+  fields: Object.freeze({
+    epoch_count: Object.freeze({ offset: 0, size: 4, length: 1, view: "Uint32" }),
+    object_count: Object.freeze({ offset: 4, size: 4, length: 1, view: "Uint32" }),
+    reference_frame: Object.freeze({ offset: 8, size: 1, length: 1, view: "Uint8" }),
+    flags: Object.freeze({ offset: 12, size: 4, length: 1, view: "Uint32" }),
+  }),
+});
+
+export const ORBPRO_EVENTS_ABI = Object.freeze({
+  RootPolicy: ORBPRO_ROOT_POLICY,
+  EventInterval: ORBPRO_EVENT_INTERVAL,
+  EventHit: ORBPRO_EVENT_HIT,
+  EventScanSummary: ORBPRO_EVENT_SCAN_SUMMARY,
+  EventStateRequest: ORBPRO_EVENT_STATE_REQUEST,
+});