space-data-module-sdk 0.8.15 → 0.8.17

package/templates/estimation-module/README.md

@@ -0,0 +1,24 @@
+# Estimation reference module
+
+This is the force-model-blind reference implementation for the fixed
+estimation ABI. It demonstrates one covariance-form position update using an
+`OrbProEstimationPropagatorSample` supplied by the caller. It never propagates
+an orbit and never names a provider: production estimators obtain state and
+STM samples from the caller-selected `plugin_propagate` /
+`plugin_compute_stm` port.
+
+The reference export is:
+
+```c
+int32_t orbpro_estimation_reference_position_update(
+    const OrbProEstimationConfig*,
+    const OrbProEstimationObservation*,
+    const OrbProEstimationPropagatorSample*,
+    OrbProEstimationState*);
+```
+
+It accepts only a three-lane `POSITION_VECTOR` observation. That narrow shape
+is deliberate: the reference proves ABI layout, covariance update, typed
+refusal and deterministic bytes. The estimation conformance kit adjudicates
+full modules against Orekit, Vallado, media, Monte-Carlo and runtime evidence.
+It is not a second JS physics implementation.

package/templates/estimation-module/build.mjs

@@ -0,0 +1,32 @@
+import fs from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { compileModuleFromSource } from "space-data-module-sdk/compiler";
+
+const require = createRequire(import.meta.url);
+const root = fileURLToPath(new URL(".", import.meta.url));
+const manifest = JSON.parse(await fs.readFile(path.join(root, "plugin-manifest.json"), "utf8"));
+const source = await fs.readFile(path.join(root, "src/reference_estimation.cpp"), "utf8");
+const propagatorHeader = await fs.readFile(
+  require.resolve("space-data-module-sdk/include/orbpro/orbpro_propagator_abi.h"), "utf8");
+const estimationHeader = (await fs.readFile(
+  require.resolve("space-data-module-sdk/include/orbpro/orbpro_estimation_abi.h"), "utf8"))
+  .replace('#include "orbpro/orbpro_propagator_abi.h"', "");
+const translationUnit = source
+  .replace('#include "orbpro/orbpro_propagator_abi.h"', propagatorHeader)
+  .replace('#include "orbpro/orbpro_estimation_abi.h"', estimationHeader);
+const outputPath = path.join(root, "dist/isomorphic/module.wasm");
+await fs.rm(path.join(root, "dist"), { recursive: true, force: true });
+await fs.mkdir(path.dirname(outputPath), { recursive: true });
+const result = await compileModuleFromSource({
+  manifest,
+  sourceCode: translationUnit,
+  language: "c++",
+  outputPath,
+  threadModel: manifest.threadModel,
+});
+if (!result.report?.ok) throw new Error(JSON.stringify(result.report?.issues ?? [], null, 2));
+await fs.copyFile(path.join(root, "plugin-manifest.json"), path.join(root, "dist/plugin-manifest.json"));
+console.log(`Built ${path.relative(root, outputPath)} with ${result.compiler}`);

package/templates/estimation-module/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "space-data-network-module-estimation-reference",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "node build.mjs"
+  },
+  "dependencies": {
+    "space-data-module-sdk": "^0.8.16"
+  }
+}

package/templates/estimation-module/plugin-manifest.json

@@ -0,0 +1,34 @@
+{
+  "pluginId": "com.orbpro.estimation.reference",
+  "name": "Estimation ABI Reference",
+  "version": "0.1.0",
+  "description": "Force-model-blind covariance update reference for the ratified estimation ABI.",
+  "pluginFamily": "analysis",
+  "capabilities": [],
+  "externalInterfaces": [],
+  "invokeSurfaces": ["direct"],
+  "runtimeTargets": ["browser", "wasmedge"],
+  "threadModel": "wasi-sequential",
+  "sequentialJustification": {
+    "kind": "inherently-sequential-algorithm",
+    "detail": "One six-state covariance update is order-dependent and small; callers parallelize independent tracks. The artifact still uses the sanctioned wasm32-wasip1-threads compiler lane."
+  },
+  "methods": [
+    {
+      "methodId": "abi_probe",
+      "displayName": "ABI Probe",
+      "description": "Returns success after the artifact has instantiated; estimation data uses the fixed direct export documented in README.md.",
+      "inputPorts": [],
+      "outputPorts": [],
+      "maxBatch": 1,
+      "drainPolicy": "single-shot"
+    }
+  ],
+  "schemasUsed": [
+    {"schemaName": "Estimation.fbs", "fileIdentifier": "$EST", "rootTypeName": "EstimationEnvelope"}
+  ],
+  "buildArtifacts": [
+    {"artifactId": "estimation-reference-isomorphic", "kind": "wasm", "path": "dist/isomorphic/module.wasm", "target": "browser,wasmedge"}
+  ],
+  "abiVersion": 1
+}

package/templates/estimation-module/src/reference_estimation.cpp

@@ -0,0 +1,53 @@
+#include "orbpro/orbpro_propagator_abi.h"
+#include "orbpro/orbpro_estimation_abi.h"
+
+#include <cmath>
+#include <cstdint>
+
+#if defined(__wasm__)
+#define ESTIMATION_EXPORT(name) __attribute__((export_name(name))) extern "C"
+#else
+#define ESTIMATION_EXPORT(name) extern "C"
+#endif
+
+extern "C" int abi_probe(void) { return 0; }
+
+ESTIMATION_EXPORT("orbpro_estimation_reference_position_update")
+int32_t orbpro_estimation_reference_position_update(
+    const OrbProEstimationConfig* config,
+    const OrbProEstimationObservation* observation,
+    const OrbProEstimationPropagatorSample* sample,
+    OrbProEstimationState* output) {
+  if (config == nullptr || observation == nullptr || sample == nullptr || output == nullptr) {
+    return ORBPRO_ESTIMATION_NULL_OUTPUT;
+  }
+  if (observation->kind != ORBPRO_MEASUREMENT_POSITION_VECTOR ||
+      observation->value_count != 3) {
+    return ORBPRO_ESTIMATION_BAD_INPUT;
+  }
+
+  orbpro_estimation_state_init(output);
+  output->epoch[0] = sample->epoch[0];
+  output->epoch[1] = sample->epoch[1];
+  for (int axis = 0; axis < 6; ++axis) {
+    output->state[axis] = sample->state[axis];
+    for (int column = 0; column < 6; ++column) {
+      output->covariance[axis * 6 + column] = config->initial_covariance[axis * 6 + column];
+    }
+  }
+  for (int axis = 0; axis < 3; ++axis) {
+    const double prior = output->covariance[axis * 6 + axis];
+    const double sigma = observation->sigma[axis];
+    if (!(prior > 0.0) || !(sigma > 0.0) || !std::isfinite(sigma)) {
+      return ORBPRO_ESTIMATION_BAD_INPUT;
+    }
+    const double measurement_variance = sigma * sigma;
+    const double gain = prior / (prior + measurement_variance);
+    output->state[axis] += gain * (observation->value[axis] - output->state[axis]);
+    output->covariance[axis * 6 + axis] = (1.0 - gain) * prior;
+  }
+  output->accepted_count = 1;
+  output->converged = 1;
+  output->estimator = ORBPRO_ESTIMATOR_EXTENDED_KALMAN_FILTER;
+  return ORBPRO_ESTIMATION_OK;
+}