space-data-module-sdk 0.8.16 → 0.8.18

package/schemas/orbpro/Solver.fbs

@@ -0,0 +1,115 @@
+include "Propagator.fbs";
+
+namespace orbpro.solver;
+
+// Pull/supply solver protocol. The solver never imports a propagator or an
+// objective function: it asks the host for one evaluation at a candidate
+// control vector, and the host routes that request to the selected ports.
+
+enum SolverAlgorithm : ubyte (abi, abi_c_name: "OrbProSolverAlgorithm", abi_c_prefix: "ORBPRO_SOLVER_") {
+  NEWTON_RAPHSON = 0,
+  BROYDEN = 1,
+  MODIFIED_BROYDEN = 2,
+  SQP = 3
+}
+
+enum DifferenceMode : ubyte (abi, abi_c_name: "OrbProSolverDifferenceMode", abi_c_prefix: "ORBPRO_SOLVER_DIFFERENCE_") {
+  FORWARD = 0,
+  CENTRAL = 1,
+  ANALYTIC_STM = 2
+}
+
+enum SolverStatus : ubyte (abi, abi_c_name: "OrbProSolverStatus", abi_c_prefix: "ORBPRO_SOLVER_STATUS_") {
+  IDLE = 0,
+  NEEDS_EVALUATION = 1,
+  CONVERGED = 2,
+  INVALID_PROBLEM = 3,
+  EVALUATION_FAILED = 4,
+  SINGULAR_JACOBIAN = 5,
+  BUDGET_EXCEEDED = 6,
+  STALLED = 7,
+  INFEASIBLE = 8
+}
+
+enum EvaluationKind : ubyte (abi, abi_c_name: "OrbProSolverEvaluationKind", abi_c_prefix: "ORBPRO_SOLVER_EVALUATE_") {
+  VALUES = 0,
+  VALUES_AND_JACOBIAN = 1
+}
+
+/// Fixed ABI limit. A larger search problem travels as $SLP through the
+/// command surface; the direct pull/supply surface intentionally stays small.
+struct SolverSettings (abi, abi_c_name: "OrbProSolverSettings", abi_c_helper_prefix: "orbpro_solver_settings_") {
+  algorithm: SolverAlgorithm;
+  difference_mode: DifferenceMode;
+  _reserved0: ushort;
+  maximum_iterations: uint;
+  maximum_evaluations: uint;
+  variable_count: uint;
+  goal_count: uint;
+  equality_constraint_count: uint;
+  inequality_constraint_count: uint;
+  residual_tolerance: double;
+  step_tolerance: double;
+  constraint_tolerance: double;
+  kkt_tolerance: double;
+}
+
+/// Candidate that must be evaluated by the consumer-selected propagator and
+/// objective ports.
+struct SolverEvaluationRequest (abi, abi_c_name: "OrbProSolverEvaluationRequest", abi_c_helper_prefix: "orbpro_solver_request_") {
+  request_id: ulong;
+  kind: EvaluationKind;
+  _reserved0: [ubyte:3];
+  variable_count: uint;
+  variables: [double:16];
+}
+
+/// Values supplied after one request. Goals are the achieved values for a
+/// target problem. For an optimization problem, objective and constraints are
+/// also populated. The Jacobian is row-major with at most 16 by 16 entries.
+struct SolverEvaluation (abi, abi_c_name: "OrbProSolverEvaluation", abi_c_helper_prefix: "orbpro_solver_evaluation_") {
+  request_id: ulong;
+  valid: ubyte;
+  _reserved0: [ubyte:3];
+  goal_count: uint;
+  constraint_count: uint;
+  jacobian_rows: uint;
+  jacobian_columns: uint;
+  goals: [double:16];
+  objective: double;
+  constraints: [double:16];
+  jacobian: [double:256];
+}
+
+struct SolverIteration (abi, abi_c_name: "OrbProSolverIteration", abi_c_helper_prefix: "orbpro_solver_iteration_") {
+  iteration: uint;
+  evaluation_count: uint;
+  variable_count: uint;
+  goal_count: uint;
+  variables: [double:16];
+  values: [double:16];
+  residual_norm: double;
+  step_norm: double;
+  jacobian_condition: double;
+  maximum_constraint_violation: double;
+  kkt_residual: double;
+  accepted: ubyte;
+  _reserved0: [ubyte:7];
+}
+
+struct SolverResult (abi, abi_c_name: "OrbProSolverResult", abi_c_helper_prefix: "orbpro_solver_result_") {
+  status: SolverStatus;
+  _reserved0: [ubyte:3];
+  iteration_count: uint;
+  evaluation_count: uint;
+  variable_count: uint;
+  value_count: uint;
+  variables: [double:16];
+  values: [double:16];
+  objective: double;
+  residual_norm: double;
+  maximum_constraint_violation: double;
+  kkt_residual: double;
+}
+
+root_type SolverResult;

package/src/conformance/estimationReference.js

@@ -0,0 +1,81 @@
+/**
+ * A deterministic, non-physics reference receipt for exercising the
+ * estimation-family conformance evaluator. Real modules replace every value
+ * with measurements produced by their compiled WASM artifact. Keeping the
+ * evaluator's own known-good input here lets the negative controls prove that
+ * each required lane can fail without shipping a second JS estimator.
+ */
+
+const reference = {
+  schemaVersion: 1,
+  family: "estimation",
+  artifact: { sha256: "reference-estimation-artifact" },
+  runtime: {
+    browser: { outputSha256: "reference-output" },
+    wasmedge: { outputSha256: "reference-output" },
+    threads: {
+      "1": "reference-output",
+      "2": "reference-output",
+      "4": "reference-output",
+      "8": "reference-output",
+    },
+  },
+  batch: {
+    positionAbsoluteErrorM: 0.25,
+    positionRelativeError: 4e-8,
+    covarianceRssRelativeError: 0.02,
+    residualRmsRelativeError: 2e-8,
+    rejectedExpected: [7, 19],
+    rejectedActual: [7, 19],
+    iterationCount: 4,
+    iterationCovarianceCount: 4,
+    iterationCovariancesSpd: true,
+  },
+  filter: {
+    positionErrorM: 0.65,
+    smootherPositionErrorM: 0.21,
+    smootherCovarianceMonotone: true,
+    neesMean: 6.02,
+    nees95Lower: 5.34,
+    nees95Upper: 6.70,
+    sncCovarianceGrowthRatio: 1.21,
+    dmcCovarianceGrowthRatio: 1.58,
+    ekfUkfCovarianceDifference: 0.08,
+  },
+  measurements: {
+    rangeMaxRelativeError: 6e-16,
+    rangeRateMaxRelativeError: 5e-16,
+    azElMaxRelativeError: 5e-16,
+    raDecMaxRelativeError: 5e-16,
+    lightTimeMagnitudeErrorM: 2e-10,
+    sagnacMagnitudeErrorM: 2e-10,
+  },
+  media: {
+    hopfieldSaastamoinenMaxRelativeError: 6e-5,
+    mariniMaxRelativeError: 7e-5,
+    p531PublishedPrecisionError: 0,
+  },
+  iod: {
+    gaussPrintedPrecisionError: 0,
+    laplacePrintedPrecisionError: 0,
+    gibbsPrintedPrecisionError: 0,
+    herrickGibbsPrintedPrecisionError: 0,
+  },
+  simulator: {
+    runs: 200,
+    stateInsideThreeSigmaFraction: 0.965,
+    recoveredNoiseSigmaRelativeError: 0.031,
+  },
+  invariants: {
+    covarianceSymmetric: true,
+    covariancePositiveDefinite: true,
+    residualOrthogonalityMax: 3e-11,
+    actualOcmCovariance: true,
+  },
+};
+
+export const ESTIMATION_REFERENCE_EVIDENCE = Object.freeze(reference);
+
+export function makeEstimationReferenceEvidence() {
+  return structuredClone(reference);
+}

package/src/conformance/estimationSuite.js

@@ -0,0 +1,134 @@
+/** Estimation-family conformance receipt evaluator. No physics lives here. */
+
+import { computeVerdict } from "./propagatorSuite.js";
+
+const pass = (id, tier, detail) => ({ id, tier, required: true, status: "pass", detail });
+const fail = (id, tier, detail) => ({ id, tier, required: true, status: "fail", detail });
+
+function check(checks, id, tier, condition, detail, failure = detail) {
+  checks.push(condition ? pass(id, tier, detail) : fail(id, tier, failure));
+}
+
+function finiteAtMost(value, limit) {
+  return Number.isFinite(value) && value <= limit;
+}
+
+function sameSet(left = [], right = []) {
+  const a = [...new Set(left)].sort((x, y) => x - y);
+  const b = [...new Set(right)].sort((x, y) => x - y);
+  return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+
+export function runEstimationSuite(evidence) {
+  const checks = [];
+  const runtimeHashes = [
+    evidence?.runtime?.browser?.outputSha256,
+    evidence?.runtime?.wasmedge?.outputSha256,
+    evidence?.runtime?.threads?.["1"],
+    evidence?.runtime?.threads?.["2"],
+    evidence?.runtime?.threads?.["4"],
+    evidence?.runtime?.threads?.["8"],
+  ];
+  check(checks, "tier0/tri-runtime-byte-identity", "0",
+    runtimeHashes.every(Boolean) && new Set(runtimeHashes).size === 1,
+    "browser, WasmEdge and worker widths 1/2/4/8 emitted byte-identical results",
+    "missing or divergent browser/WasmEdge/thread-width output digests");
+
+  const batch = evidence?.batch ?? {};
+  check(checks, "tierA/batch-state", "A",
+    finiteAtMost(batch.positionAbsoluteErrorM, 1) &&
+      finiteAtMost(batch.positionRelativeError, 1e-3),
+    `absolute=${batch.positionAbsoluteErrorM} m relative=${batch.positionRelativeError}`,
+    "batch state exceeds 1 m absolute or 1e-3 relative");
+  check(checks, "tierA/batch-covariance", "A",
+    finiteAtMost(batch.covarianceRssRelativeError, 0.05),
+    `RSS position sigma relative error=${batch.covarianceRssRelativeError}`,
+    "batch covariance RSS differs from authority by more than 5%");
+  check(checks, "tierA/batch-residual-rms", "A",
+    finiteAtMost(batch.residualRmsRelativeError, 1e-6),
+    `residual RMS relative error=${batch.residualRmsRelativeError}`,
+    "batch residual RMS differs from authority by more than 1e-6 relative");
+  check(checks, "tierA/sigma-edit-set", "A",
+    sameSet(batch.rejectedExpected, batch.rejectedActual),
+    `exact rejected set [${batch.rejectedActual ?? []}]`,
+    "sigma editing rejected a different observation set");
+  check(checks, "tierC/batch-iteration-covariance", "C",
+    Number.isInteger(batch.iterationCount) && batch.iterationCount > 0 &&
+      batch.iterationCovarianceCount === batch.iterationCount &&
+      batch.iterationCovariancesSpd === true,
+    `${batch.iterationCovarianceCount}/${batch.iterationCount} iteration covariances are SPD`,
+    "batch iteration covariance history is missing, incomplete, or not SPD");
+
+  const filter = evidence?.filter ?? {};
+  check(checks, "tierA/filter-and-smoother-state", "A",
+    finiteAtMost(filter.positionErrorM, 1) &&
+      finiteAtMost(filter.smootherPositionErrorM, 0.5),
+    `filter=${filter.positionErrorM} m smoother=${filter.smootherPositionErrorM} m`,
+    "filter exceeds 1 m or RTS smoother exceeds 0.5 m");
+  check(checks, "tierC/smoother-covariance", "C",
+    filter.smootherCovarianceMonotone === true,
+    "smoothed covariance is no larger than filtered covariance at every epoch");
+  check(checks, "tierC/nees-100-run", "C",
+    Number.isFinite(filter.neesMean) && filter.neesMean >= filter.nees95Lower &&
+      filter.neesMean <= filter.nees95Upper,
+    `NEES mean=${filter.neesMean} band=[${filter.nees95Lower},${filter.nees95Upper}]`,
+    "100-run NEES lies outside the declared chi-square 95% band");
+  check(checks, "tierC/process-noise", "C",
+    Number.isFinite(filter.sncCovarianceGrowthRatio) && filter.sncCovarianceGrowthRatio !== 1 &&
+      Number.isFinite(filter.dmcCovarianceGrowthRatio) && filter.dmcCovarianceGrowthRatio !== 1,
+    `SNC ratio=${filter.sncCovarianceGrowthRatio} DMC ratio=${filter.dmcCovarianceGrowthRatio}`,
+    "SNC or DMC failed to change covariance growth");
+  check(checks, "tierC/ekf-ukf-not-aliased", "C",
+    Number.isFinite(filter.ekfUkfCovarianceDifference) && filter.ekfUkfCovarianceDifference > 0,
+    `covariance history distance=${filter.ekfUkfCovarianceDifference}`,
+    "EKF and UKF covariance histories are identical");
+
+  const measurement = evidence?.measurements ?? {};
+  for (const [name, key] of [["range", "rangeMaxRelativeError"],
+    ["range-rate", "rangeRateMaxRelativeError"], ["az-el", "azElMaxRelativeError"],
+    ["ra-dec", "raDecMaxRelativeError"]]) {
+    check(checks, `tierA/measurement-${name}`, "A", finiteAtMost(measurement[key], 1e-6),
+      `max relative error=${measurement[key]}`, `${name} exceeds 1e-6 relative`);
+  }
+  check(checks, "tierA/light-time", "A", finiteAtMost(measurement.lightTimeMagnitudeErrorM, 1e-6),
+    `magnitude error=${measurement.lightTimeMagnitudeErrorM} m`);
+  check(checks, "tierA/sagnac", "A", finiteAtMost(measurement.sagnacMagnitudeErrorM, 1e-6),
+    `magnitude error=${measurement.sagnacMagnitudeErrorM} m`);
+
+  const media = evidence?.media ?? {};
+  check(checks, "tierA/troposphere-hopfield-saastamoinen", "A",
+    finiteAtMost(media.hopfieldSaastamoinenMaxRelativeError, 1e-4),
+    `relative error=${media.hopfieldSaastamoinenMaxRelativeError}`);
+  check(checks, "tierA/troposphere-marini", "A",
+    finiteAtMost(media.mariniMaxRelativeError, 1e-4),
+    `relative error=${media.mariniMaxRelativeError}`);
+  check(checks, "tierB/ionosphere-p531", "B", media.p531PublishedPrecisionError === 0,
+    "P.531 table value reproduced to published precision");
+
+  for (const [name, key] of [["gauss", "gaussPrintedPrecisionError"],
+    ["laplace", "laplacePrintedPrecisionError"], ["gibbs", "gibbsPrintedPrecisionError"],
+    ["herrick-gibbs", "herrickGibbsPrintedPrecisionError"]]) {
+    check(checks, `tierB/iod-${name}`, "B", evidence?.iod?.[key] === 0,
+      "Vallado worked example reproduced to printed precision");
+  }
+
+  const simulator = evidence?.simulator ?? {};
+  check(checks, "tierC/simulator-coverage", "C",
+    simulator.runs >= 200 && simulator.stateInsideThreeSigmaFraction >= 0.95,
+    `${simulator.stateInsideThreeSigmaFraction} inside 3-sigma over ${simulator.runs} runs`);
+  check(checks, "tierC/simulator-noise-recovery", "C",
+    finiteAtMost(simulator.recoveredNoiseSigmaRelativeError, 0.05),
+    `noise sigma relative error=${simulator.recoveredNoiseSigmaRelativeError}`);
+
+  const invariants = evidence?.invariants ?? {};
+  check(checks, "tierC/covariance-spd", "C",
+    invariants.covarianceSymmetric === true && invariants.covariancePositiveDefinite === true,
+    "covariance is symmetric positive definite");
+  check(checks, "tierC/residual-orthogonality", "C",
+    finiteAtMost(invariants.residualOrthogonalityMax, 1e-6),
+    `max normalized normal-equation projection=${invariants.residualOrthogonalityMax}`);
+  check(checks, "tierC/ocm-covariance", "C", invariants.actualOcmCovariance === true,
+    "the emitted OCM carries the estimator covariance");
+
+  return { checks, verdict: computeVerdict(checks) };
+}

package/src/conformance/index.js

@@ -19,6 +19,8 @@ import path from "node:path";
 
 import { loadPropagatorArtifact } from "./abiDriver.js";
 import { computeVerdict, runPropagatorSuite } from "./propagatorSuite.js";
+import { runEstimationSuite } from "./estimationSuite.js";
+import { makeEstimationReferenceEvidence } from "./estimationReference.js";
 
 export { ErrorCode, REQUIRED_ABI_EXPORTS } from "./abiDriver.js";
 export {
@@ -34,14 +36,14 @@ export { runPropagatorSelfTest, formatSelfTestReport } from "./selfTest.js";
  * never coerced — the ANALYSIS fallback was the namespace corruption the
  * finding killed.
  */
-export const CONFORMANCE_FAMILIES = Object.freeze(["propagator"]);
+export const CONFORMANCE_FAMILIES = Object.freeze(["estimation", "propagator"]);
 
 export class UnknownConformanceFamilyError extends Error {
   constructor(family) {
     super(
       `no conformance kit for family "${family}" — kits exist for: ` +
         `${CONFORMANCE_FAMILIES.join(", ")}. A family with no kit can never be CORE ` +
-        "(finding §5); maneuver is Wave 2 (EXPERIMENTAL), OD is deferred by ruling.",
+        "(finding §5); maneuver remains Wave 2.",
     );
     this.name = "UnknownConformanceFamilyError";
     this.family = family;
@@ -93,6 +95,23 @@ export async function runConformance(options) {
   if (!CONFORMANCE_FAMILIES.includes(family)) {
     throw new UnknownConformanceFamilyError(options.family);
   }
+  if (family === "estimation") {
+    const evidence = options.evidence ?? JSON.parse(
+      await fs.readFile(path.resolve(options.evidencePath), "utf8"),
+    );
+    const evaluated = runEstimationSuite(evidence);
+    let artifact = evidence.artifact ?? null;
+    if (options.artifactPath) {
+      const artifactPath = path.resolve(options.artifactPath);
+      const artifactBytes = await fs.readFile(artifactPath);
+      artifact = {
+        path: artifactPath,
+        sha256: crypto.createHash("sha256").update(artifactBytes).digest("hex"),
+      };
+    }
+    return { family, artifact, corpus: null, evidence: options.evidencePath ?? null, ...evaluated };
+  }
+
   const artifactPath = path.resolve(options.artifactPath);
   const artifactBytes = await fs.readFile(artifactPath);
   const artifactSha256 = crypto
@@ -129,6 +148,24 @@ export async function runConformance(options) {
   };
 }
 
+export { runEstimationSuite } from "./estimationSuite.js";
+export { makeEstimationReferenceEvidence } from "./estimationReference.js";
+
+export async function runEstimationSelfTest() {
+  const controls = [];
+  for (const [id, mutate] of [
+    ["runtime-divergence", (e) => { e.runtime.threads["8"] = "different"; }],
+    ["ekf-ukf-alias", (e) => { e.filter.ekfUkfCovarianceDifference = 0; }],
+    ["covariance-placeholder", (e) => { e.invariants.actualOcmCovariance = false; }],
+  ]) {
+    const evidence = makeEstimationReferenceEvidence();
+    mutate(evidence);
+    const report = runEstimationSuite(evidence);
+    controls.push({ id, caught: report.verdict === "FAIL" });
+  }
+  return { ok: controls.every((control) => control.caught), controls };
+}
+
 export function formatConformanceReport(report) {
   const lines = [];
   lines.push(`conformance ${report.family} — ${report.verdict}`);

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

@@ -47,6 +47,27 @@ export const StateFlags = Object.freeze({
   HAS_COVARIANCE: 32,
 });
 
+export const ErrorCode = Object.freeze({
+  OK: 0,
+  NOT_INITIALIZED: -1,
+  BAD_ENTITY_INDEX: -2,
+  NULL_OUTPUT: -3,
+  BAD_INPUT: -4,
+  NOT_CONVERGED: -5,
+  UNPHYSICAL: -6,
+  UNSUPPORTED_FORMAT: -7,
+  EPOCH_OUT_OF_RANGE: -8,
+});
+
+export const EphemerisFormat = Object.freeze({
+  AUTO: 0,
+  CCSDS_OEM_KVN: 1,
+  SPK_DAF: 2,
+  CODE500: 3,
+  STK_EPHEMERIS: 4,
+  SP3_D: 5,
+});
+
 export const ORBPRO_STATE_VECTOR = Object.freeze({
   name: "StateVector",
   cName: "OrbProStateVector",

package/src/generated/orbpro/propagator-abi.ts

@@ -53,6 +53,56 @@ export enum StateFlags {
   HAS_COVARIANCE = 32,
 }
 
+/**
+ * The negative return codes every propagator export shares.
+ *
+ * These were documented in docs/propagator-abi.md and declared NOWHERE, so
+ * every module hand-typed them as literals and the contract lived only in
+ * prose. A propagator that returns -1 for everything is unconformable — the
+ * host cannot tell a bad entity index from an uninitialized module, so it
+ * cannot place the failure on the degradation ladder — and the cheapest way
+ * to end up there is having no names to return.
+ *
+ * VALUES ARE FROZEN. New classes are appended downward.
+ */
+export enum ErrorCode {
+  OK = 0,
+  NOT_INITIALIZED = -1,
+  BAD_ENTITY_INDEX = -2,
+  NULL_OUTPUT = -3,
+  BAD_INPUT = -4,
+  NOT_CONVERGED = -5,
+  UNPHYSICAL = -6,
+  UNSUPPORTED_FORMAT = -7,
+  EPOCH_OUT_OF_RANGE = -8,
+}
+
+/**
+ * The container an ephemeris-driven propagator was handed on
+ * `plugin_init_ephemeris`. A format is DATA, not identity: one ephemeris
+ * provider reads every member below behind this discriminator rather than
+ * shipping one artifact per container, because the interpolation, the time
+ * scale handling and the frame rotation are shared and splitting them
+ * re-creates the five-mirror drift this file exists to end.
+ *
+ * AUTO is the honest default: every container here is self-identifying in its
+ * first bytes (`DAF/SPK ` / `NAIF/DAF`, the OEM version keyword, the STK
+ * `stk.v.` banner, the SP3 `#d` line, the Code-500 fixed header block), so a
+ * caller that does not know what it fetched says so rather than guessing. A
+ * module that cannot identify the bytes returns UNSUPPORTED_FORMAT; it never
+ * falls back to a default container.
+ *
+ * VALUES ARE FROZEN AND ARE NEVER RENUMBERED. New containers are APPENDED.
+ */
+export enum EphemerisFormat {
+  AUTO = 0,
+  CCSDS_OEM_KVN = 1,
+  SPK_DAF = 2,
+  CODE500 = 3,
+  STK_EPHEMERIS = 4,
+  SP3_D = 5,
+}
+
 /** One field's placement inside an ABI struct. */
 export interface AbiField {
   readonly offset: number;

package/src/standards/sharedCatalog.js

@@ -219,6 +219,13 @@ const sharedModuleCatalogEntries = [
     fileIdentifier: "PRST",
     source: "orbpro-propagator",
   },
+  {
+    schemaCode: "ESTIMATION",
+    schemaName: "Estimation.fbs",
+    fileIdentifier: "$EST",
+    rootTypeName: "EstimationEnvelope",
+    source: "orbpro-estimation",
+  },
   {
     schemaCode: "ACCESSWINDOWREQUEST",
     schemaName: "AccessWindowRequest.fbs",

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