space-data-module-sdk 0.8.15 → 0.8.16

package/schemas/orbpro/reference-frame-crosswalk.json

@@ -0,0 +1,108 @@
+{
+  "note": "Every ReferenceFrame-shaped vocabulary that crosses a seam with the orbpro.propagator ABI enum, and how each of its members maps ONTO that enum BY NAMED TOKEN. Numeric identity is never asserted across repositories: ECI==0, TEME==0 and FIXED==0 all collide, and ECEF is 1 in orbpro.plugins but 3 in the ABI. scripts/check-reference-frame-uniqueness.mjs holds this file and schemas/orbpro/Propagator.fbs to each other, and re-reads any listed source that is present on disk.",
+  "authority": "schemas/orbpro/Propagator.fbs :: enum ReferenceFrame",
+  "vocabularies": [
+    {
+      "id": "orbpro.plugins",
+      "description": "PropagatorState.fbs / \"PRST\" \u2014 the wire the compiled sgp4, hpop, conjunction-assessment and sensor-shader modules already emit. Its values are FROZEN by artifacts in the field; collapsing it into the ABI enum is a wire break, tracked as sdk-reference-frame-enum-unification.",
+      "repo": "space-data-network-modules",
+      "source": "propagator/sgp4/schemas/PropagatorState.fbs",
+      "members": {
+        "ECI": "ICRF",
+        "ECEF": "ECEF",
+        "TEME": "TEME",
+        "ICRF": "ICRF"
+      }
+    },
+    {
+      "id": "orbpro.engine",
+      "description": "The OrbPro engine's ReferenceFrame.js. NINE members, not the two this SDK's comment block claimed until 2026-08-30. FIXED/INERTIAL are INVERTED against the ABI's 0/1 \u2014 a live semantic difference, not a numbering accident \u2014 and reconciling that is sdk-reference-frame-enum-unification's job, not this crosswalk's. The four local orbital triads collapse onto OBJECT_REFERENCED with an axes spec.",
+      "repo": "OrbPro",
+      "source": "packages/engine/Source/Core/ReferenceFrame.js",
+      "members": {
+        "FIXED": "ECEF",
+        "INERTIAL": "ICRF",
+        "TEME": "TEME",
+        "VVLH": "OBJECT_REFERENCED",
+        "ENU": "TOPOCENTRIC",
+        "NED": "TOPOCENTRIC",
+        "NEU": "TOPOCENTRIC",
+        "RIC": "OBJECT_REFERENCED",
+        "LVLH": "OBJECT_REFERENCED"
+      }
+    },
+    {
+      "id": "orbpro.conjunction",
+      "description": "ConjunctionCommon.fbs, carried by the conjunction module.",
+      "repo": "space-data-network-modules",
+      "source": "analysis/conjunction-assessment/schemas/ConjunctionCommon.fbs",
+      "members": {
+        "UNKNOWN": null,
+        "ECI": "ICRF",
+        "ECEF": "ECEF",
+        "TEME": "TEME",
+        "ICRF": "ICRF"
+      }
+    },
+    {
+      "id": "modules.foundation.frames",
+      "description": "foundation/frames AxisType, mirroring SDS rfmAxisType. It is an ORIENTATION RULE roster and carries no origin, so it is not a ReferenceFrame; the mapping below is the axis half only, and a consumer still needs the RFMOrigin to have a coordinate system.",
+      "repo": "space-data-network-modules",
+      "source": "foundation/frames/src/axis_engine.hpp",
+      "members": {
+        "UNSPECIFIED": null,
+        "MJ2000EQ": "J2000",
+        "MJ2000EC": "MJ2000EC",
+        "ICRF": "ICRF",
+        "TEME": "TEME",
+        "MOD": "MOD",
+        "TOD": "TOD",
+        "MOE": "MOE",
+        "TOE": "TOE",
+        "BODY_FIXED": "BODY_FIXED",
+        "BODY_INERTIAL": "BODY_INERTIAL",
+        "OBJECT_REFERENCED": "OBJECT_REFERENCED",
+        "LOCAL_ALIGNED_CONSTRAINED": "LOCAL_ALIGNED_CONSTRAINED",
+        "EQUATOR": "EQUATOR",
+        "GSE": "GSE",
+        "GSM": "GSM",
+        "TOPOCENTRIC": "TOPOCENTRIC",
+        "BODY_SPIN_SUN": "BODY_SPIN_SUN",
+        "SPICE_DEFINED": "SPICE_DEFINED",
+        "MOD_FK5": "MOD_FK5",
+        "TOD_FK5": "TOD_FK5",
+        "ITRF": "ECEF"
+      }
+    },
+    {
+      "id": "modules.hpop.coords",
+      "description": "The HPOP propagator's internal chain vocabulary.",
+      "repo": "space-data-network-modules",
+      "source": "propagator/hpop/lib/coords_types.h",
+      "members": {
+        "TEME": "TEME",
+        "GCRF": "ICRF",
+        "ITRF": "ECEF",
+        "J2000": "J2000",
+        "ECEF": "ECEF",
+        "TOD": "TOD",
+        "MOD": "MOD"
+      }
+    }
+  ],
+  "rtnConvention": {
+    "abiMember": "OBJECT_REFERENCED",
+    "note": "The three live RTN triads collapse to ONE ABI member plus an axes spec. RIC, RSW and RTN name the SAME triad (x radial, z orbit normal, y completing); LVLH and VVLH are relabellings of it produced by naming a different primary. None of them is a separate ReferenceFrame, and adding a second RTN-named ABI member is a defect this check refuses.",
+    "aliases": [
+      "RIC",
+      "RSW",
+      "RTN",
+      "LVLH",
+      "VVLH",
+      "QSW",
+      "NTW",
+      "TNW",
+      "UVW"
+    ]
+  }
+}

package/schemas/orbpro/reference-frame.lock.json

@@ -0,0 +1,98 @@
+{
+  "note": "The committed numbering of the ONE ReferenceFrame enum that crosses the ABI seam. scripts/check-reference-frame-uniqueness.mjs holds schemas/orbpro/Propagator.fbs to this file: values 0-5 are FROZEN and no member may ever be renamed, renumbered or removed. Appending a member means appending a row here in the same commit.",
+  "frozenThrough": 5,
+  "members": [
+    {
+      "name": "TEME",
+      "value": 0
+    },
+    {
+      "name": "J2000",
+      "value": 1
+    },
+    {
+      "name": "ICRF",
+      "value": 2
+    },
+    {
+      "name": "ECEF",
+      "value": 3
+    },
+    {
+      "name": "MCI",
+      "value": 4
+    },
+    {
+      "name": "MCMF",
+      "value": 5
+    },
+    {
+      "name": "MJ2000EC",
+      "value": 6
+    },
+    {
+      "name": "MOD",
+      "value": 7
+    },
+    {
+      "name": "TOD",
+      "value": 8
+    },
+    {
+      "name": "MOE",
+      "value": 9
+    },
+    {
+      "name": "TOE",
+      "value": 10
+    },
+    {
+      "name": "BODY_FIXED",
+      "value": 11
+    },
+    {
+      "name": "BODY_INERTIAL",
+      "value": 12
+    },
+    {
+      "name": "OBJECT_REFERENCED",
+      "value": 13
+    },
+    {
+      "name": "LOCAL_ALIGNED_CONSTRAINED",
+      "value": 14
+    },
+    {
+      "name": "EQUATOR",
+      "value": 15
+    },
+    {
+      "name": "GSE",
+      "value": 16
+    },
+    {
+      "name": "GSM",
+      "value": 17
+    },
+    {
+      "name": "TOPOCENTRIC",
+      "value": 18
+    },
+    {
+      "name": "BODY_SPIN_SUN",
+      "value": 19
+    },
+    {
+      "name": "SPICE_DEFINED",
+      "value": 20
+    },
+    {
+      "name": "MOD_FK5",
+      "value": 21
+    },
+    {
+      "name": "TOD_FK5",
+      "value": 22
+    }
+  ]
+}

package/src/browser.js

@@ -29,6 +29,19 @@ export {
   zeroWasmBytes,
   isSharedArrayBufferLike,
 } from "./host/browserModuleHarness.js";
+// The wasi-threads BROWSER WORKER ANCHOR. A bundling consumer MUST tell the SDK
+// where its build serves the host worker chain from — `import.meta.url` inside a
+// bundle points at the bundle, not at the package layout, and the worker 404s
+// (fail-loud: WasiThreadWorkerUnreachableError). Either call
+// `setBrowserWasiThreadWorkerBase(...)` once in the host shim, or pass
+// `wasiThreadWorkerBaseUrl` to `createBrowserModuleHarness`.
+export {
+  setBrowserWasiThreadWorkerBase,
+  getBrowserWasiThreadWorkerBase,
+  resolveBrowserWorkerUrl,
+  DEFAULT_BROWSER_WORKER_URL,
+  WasiThreadWorkerUnreachableError,
+} from "./host/wasiThreadHost.js";
 // The runtime-target gate is reachable so a consumer can catch the refusal by
 // CLASS (`error instanceof RuntimeTargetError`) rather than by matching a
 // message string, and can ask the same question the loaders ask before it

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,
+});