space-data-module-sdk 0.8.6 → 0.8.8

package/schemas/orbpro/Propagator.fbs

@@ -21,9 +21,25 @@ enum StateFlags : uint {
   HAS_COVARIANCE = 32
 }
 
+// Synced to the ratified SDS VCM.propagatorFamily vocabulary (schema/VCM/main.fbs)
+// so any provider self-identifying in PropagatorDescribeSourcesBatchResult uses
+// the SAME family codes SDS already carries — HPOP/Cowell-class numerical
+// integrators map to COWELL (no HPOP-specific code needed); new codes go
+// through Themis's SDS auto-ratification law, never invented here first.
 enum PropagatorSourceKind : ubyte {
-  UNKNOWN = 0,
-  SGP4 = 1
+  NONE = 0,
+  SEMI_ANALYTICAL = 1,
+  VINTI = 2,
+  SGP4 = 3,
+  COWELL = 4,
+  RK4 = 5,
+  NYX = 6,
+  GMAT = 7,
+  SPICE = 8,
+  SGP = 9,
+  SDP4 = 10,
+  SGP8 = 11,
+  SDP8 = 12
 }
 
 struct StateVector {
@@ -41,7 +57,7 @@ table PropagatorDescribeSourcesBatchRequest {
 
 table PropagatorSourceDescription {
   sourceHandle:uint = 0;
-  sourceKind:PropagatorSourceKind = UNKNOWN;
+  sourceKind:PropagatorSourceKind = NONE;
   objectName:string;
   objectId:string;
   noradCatId:uint = 0;

package/src/browser.js

@@ -16,7 +16,17 @@ export * from "./host/sabHostcallChannel.js";
 export * from "./host/timerDriver.js";
 export * from "./flow/index.js";
 export * from "./compat/index.js";
-export * from "./host/isomorphicLoader.js";
-export { createBrowserModuleHarness, detectArtifactProfile } from "./testing/browserModuleHarness.js";
-export { createWorkerModuleHarness } from "./testing/workerModuleHarness.js";
-export { createModuleFlatBufferStreamPump } from "./testing/moduleFlatbufferStreamPump.js";
+// The browser leg of `./host/isomorphic`. NEVER isomorphicLoader.js: that is
+// the Node leg, and a bundler resolves its node:* branches even though a
+// browser can never take them.
+export * from "./host/isomorphicLoaderBrowser.js";
+// Browser module hosts. These are runtime surface and live in src/host/;
+// nothing under src/testing/ is reachable from this entry.
+export {
+  createBrowserModuleHarness,
+  detectArtifactProfile,
+  zeroWasmBytes,
+  isSharedArrayBufferLike,
+} from "./host/browserModuleHarness.js";
+export { createWorkerModuleHarness } from "./host/workerModuleHarness.js";
+export { createModuleFlatBufferStreamPump } from "./host/moduleFlatbufferStreamPump.js";

package/src/bundle/artifactBytes.js

@@ -0,0 +1,44 @@
+/**
+ * Artifact byte reduction — runtime surface, not test-harness surface.
+ *
+ * A published module artifact is `module.wasm` plus an appended publication
+ * record collection (MBL bundle: the sds.signature entry, PNM/REC trailers).
+ * EVERY runtime that loads a module — browser, native WasmEdge, Docker
+ * WasmEdge — must reduce the artifact to the same canonical payload before it
+ * reaches a wasm engine, because every engine rejects the trailing bytes
+ * ("unknown section code" / "malformed section id"). Same input bytes in,
+ * byte-identical payload out, in all three runtimes.
+ *
+ * That makes this an ARTIFACT concern and it belongs beside signing and
+ * verification, on `space-data-module-sdk/bundle`. It previously lived in
+ * `src/testing/browserModuleHarness.js`, which forced production delivery code
+ * (OrbPro's SDN module decryptor) to import a TEST-harness subpath to get it —
+ * the import that dragged the Node harnesses into a browser bundle and blanked
+ * all 275 gallery demos (`orbpro-engine-bundle-ships-node-builtins`).
+ */
+
+import { extractPublicationRecordCollection } from "../transport/records.js";
+import { ModuleSignatureError } from "./signing.js";
+
+/**
+ * Reduce a module artifact to the bytes a wasm engine can compile.
+ *
+ * ENC-protected payloads cannot be reduced here — decryption is a host
+ * concern, and the caller must decrypt before loading.
+ *
+ * @param {Uint8Array} bytes - raw artifact bytes
+ * @returns {Uint8Array} compilable wasm bytes
+ */
+export function toLoadableWasmBytes(bytes) {
+  const publication = extractPublicationRecordCollection(bytes);
+  if (!publication) {
+    return bytes;
+  }
+  if (publication.enc) {
+    throw new ModuleSignatureError(
+      "encrypted_artifact",
+      "Module artifact payload is ENC-protected; decrypt it before loading.",
+    );
+  }
+  return publication.payloadBytes;
+}

package/src/bundle/index.js

@@ -1,6 +1,7 @@
 export * from "./constants.js";
 export * from "./codec.js";
 export * from "./wasm.js";
+export * from "./artifactBytes.js";
 export * from "./signing.js";
 // Re-exported under explicit names rather than `export *`: sigdomain's own
 // names (`statement`, `domains`, `describe`, `registered`) are deliberately

package/src/compiler/compileModule.js

@@ -160,6 +160,15 @@ function usesPthreadCompileFlags(options = {}) {
 const MIN_STACK_SIZE_BYTES = 64 * 1024;
 const MAX_STACK_SIZE_BYTES = 1024 * 1024 * 1024;
 
+// The wasi-sequential heap contract. 16 MiB initial matches what the previous
+// (Emscripten) sequential artifacts shipped with; the 2 GiB ceiling is the SAME
+// number PTHREAD_FINAL_LINK_FLAGS pins, so the two thread models differ in
+// their threading contract and NOTHING else. wasm-ld defaults the maximum to
+// the computed minimum when neither flag is given, which is what made a
+// sequential guest unable to grow its heap by a single page.
+const SEQUENTIAL_INITIAL_MEMORY_BYTES = 16 * 1024 * 1024;
+const SEQUENTIAL_MAX_MEMORY_BYTES = 2147483648;
+
 function resolveStackSize(stackSize) {
   if (stackSize === undefined || stackSize === null) {
     return null;
@@ -193,7 +202,21 @@ function buildCompilerArgs(exportedSymbols, options = {}) {
   // refuses to instantiate it ("unknown import: env.memory"). Held to that
   // shape by assertSequentialArtifact.
   if (options.threadModel === ModuleThreadModel.WASI_SEQUENTIAL) {
-    const sequentialArgs = ["-O3", "-mbulk-memory"];
+    // A sequential guest still needs a HEAP. Without an explicit ceiling the
+    // sequential link emitted a memory whose maximum equalled its minimum (18
+    // pages for a status node), so the guest could not grow at all and
+    // plugin_alloc returned null for the first frame larger than ~1 MiB — while
+    // the SAME source on the pthreads profile got a 2 GiB-growable memory.
+    // Two thread models must differ in their THREADING contract only; a guest
+    // that cannot allocate is not "sequential", it is broken. Same ceiling as
+    // PTHREAD_FINAL_LINK_FLAGS' --max-memory, unshared and unimported so the
+    // browser needs no cross-origin isolation to load it.
+    const sequentialArgs = [
+      "-O3",
+      "-mbulk-memory",
+      `-Wl,--initial-memory=${SEQUENTIAL_INITIAL_MEMORY_BYTES}`,
+      `-Wl,--max-memory=${SEQUENTIAL_MAX_MEMORY_BYTES}`,
+    ];
     if (options.noEntry === true) {
       sequentialArgs.push("-mexec-model=reactor");
     }

package/src/flow/flowCompiler.js

@@ -84,7 +84,7 @@ import {
   TriggerBindingT,
   TriggerKind,
 } from "../generated/orbpro/flow.js";
-import { DrainPolicy } from "../generated/orbpro/manifest.js";
+import { DrainPolicy, PluginFamily } from "../generated/orbpro/manifest.js";
 
 const RUNTIME_TEMPLATE_PATH = fileURLToPath(
   new URL("./runtime-src/flow_runtime.cpp", import.meta.url),
@@ -1184,6 +1184,131 @@ export function validateFlowAPIDeclaration(flow, issues) {
   });
 }
 
+// ---------------------------------------------------------------------------
+// Family/interface-typed node binding (PLUGGABLE-PROPAGATION LAW, ruling E).
+//
+// The exact-pluginId path above is the ONLY binding mode this compiler has
+// ever had — every propagator reference in every flow.json was a design-time
+// fixed ID, which is exactly the gap the law's own flow-side contract
+// ("propagator input ports in composed flows") left unclosed. This adds an
+// ADDITIVE alternative: a node may declare `pluginFamily` (e.g.
+// "propagator") instead of `pluginId`, and is bound at CHECK TIME to the one
+// dependency in that family whose manifest exposes `methodId` — "any
+// pluginFamily:propagator satisfying method X". Resolution is a
+// DECLARATION, never an inference: zero or more than one qualifying
+// candidate is a compile error, never a guess (mirrors the wasi-sequential
+// thread model's own rule, applied here).
+//
+// Ruling C (provider method vocabulary): providers in one family are NOT
+// required to share a uniform method vocabulary beyond whatever the
+// binding's own declared `methodId` demands — sgp4 exposes
+// ingest_omm/upsert_cat/propagate_state/propagate_path/catalog_query, hpop
+// exposes invoke/ingest_state/propagate_state/prepare_trajectory_segments/
+// describe_trajectory_segments; a node that asks for "propagator satisfying
+// propagate_state" resolves against either, a node that asks for
+// "propagator satisfying catalog_query" resolves only against sgp4-shaped
+// providers. No vocabulary unification is needed: findMethod() already
+// enforces this per-candidate, the same check exact-ID binding uses.
+//
+// Ruling E (scope): this binds NODE -> PLUGIN only. Edge type contracts
+// still resolve by concrete SDS type refs (unrelated mechanism), and
+// requiredPlugins still enumerates concrete plugin ids — once a family
+// binding resolves, `node.pluginId` is backfilled with the concrete winner
+// BEFORE any other validation runs, so every downstream stage (edge typing,
+// manifest capability union, generateFlowTables, buildFlowModuleManifest,
+// the embedded FlowProgram record itself) sees an ordinary exact-ID node.
+// This is authoring-time sugar, not a new wire concept: zero ABI/schema
+// change, zero tri-runtime parity impact — the compiled artifact never
+// carries the word "pluginFamily".
+function normalizePluginFamilyName(value) {
+  if (typeof value === "number") {
+    return PluginFamily[value] ?? null;
+  }
+  const trimmed = String(value ?? "").trim();
+  if (!trimmed) return null;
+  const upper = trimmed.toUpperCase().replace(/[\s-]+/g, "_");
+  return upper === "DATASOURCE" ? "DATA_SOURCE" : upper;
+}
+
+function resolveNodePluginFamilyBindings({ flow, dependencies, issues }) {
+  const failed = new Set();
+  const nodes = Array.isArray(flow?.nodes) ? flow.nodes : [];
+  nodes.forEach((node, index) => {
+    if (!node || !node.pluginFamily) return;
+    const label = node.nodeId || `flow.nodes[${index}]`;
+    const location = `flow.nodes[${index}].pluginFamily`;
+    if (node.pluginId) {
+      pushIssue(
+        issues,
+        "error",
+        "ambiguous-plugin-binding",
+        `Node "${label}" declares both pluginId and pluginFamily; a node binds by ` +
+          `EXACTLY ONE (declaration, never inference).`,
+        location,
+      );
+      failed.add(node);
+      return;
+    }
+    const requestedFamily = normalizePluginFamilyName(node.pluginFamily);
+    if (!requestedFamily) {
+      pushIssue(
+        issues,
+        "error",
+        "invalid-plugin-family",
+        `Node "${label}" declares an empty or unreadable pluginFamily.`,
+        location,
+      );
+      failed.add(node);
+      return;
+    }
+    if (!node.methodId) {
+      pushIssue(
+        issues,
+        "error",
+        "missing-method-id",
+        `Node "${label}" declares pluginFamily "${node.pluginFamily}" but no methodId to resolve ` +
+          `against (family binding always resolves by "pluginFamily:<X> satisfying method <Y>").`,
+        location,
+      );
+      failed.add(node);
+      return;
+    }
+    const candidates = [...dependencies.values()].filter(
+      (dependency) =>
+        normalizePluginFamilyName(dependency.normalized?.pluginFamily) === requestedFamily &&
+        findMethod(dependency.normalized, node.methodId),
+    );
+    if (candidates.length === 0) {
+      pushIssue(
+        issues,
+        "error",
+        "unresolvable-plugin-family",
+        `Node "${label}" requests pluginFamily "${node.pluginFamily}" satisfying method ` +
+          `"${node.methodId}", but no resolvable dependency in that family exposes it.`,
+        location,
+      );
+      failed.add(node);
+      return;
+    }
+    if (candidates.length > 1) {
+      pushIssue(
+        issues,
+        "error",
+        "ambiguous-plugin-family",
+        `Node "${label}" requests pluginFamily "${node.pluginFamily}" satisfying method ` +
+          `"${node.methodId}", but ${candidates.length} dependencies qualify (` +
+          `${candidates.map((c) => c.pluginId).sort().join(", ")}); disambiguate with an exact pluginId.`,
+        location,
+      );
+      failed.add(node);
+      return;
+    }
+    node.pluginId = candidates[0].pluginId;
+    node.resolvedFromPluginFamily = requestedFamily;
+  });
+  return failed;
+}
+
 /**
  * Validate a flow document against its dependency manifests. Returns
  * { ok, issues, capabilities, nodes } where `capabilities` is the computed
@@ -1192,6 +1317,11 @@ export function validateFlowAPIDeclaration(flow, issues) {
  */
 export function checkFlowProgram({ flow, dependencies = new Map() } = {}) {
   const issues = [];
+  const familyResolutionFailed = resolveNodePluginFamilyBindings({
+    flow,
+    dependencies,
+    issues,
+  });
   const nodes = Array.isArray(flow?.nodes) ? flow.nodes : [];
   const edges = Array.isArray(flow?.edges) ? flow.edges : [];
   const triggers = Array.isArray(flow?.triggers) ? flow.triggers : [];
@@ -1270,7 +1400,11 @@ export function checkFlowProgram({ flow, dependencies = new Map() } = {}) {
           location,
         );
       }
-    } else if (!isHostModelNode(node)) {
+    } else if (!isHostModelNode(node) && !familyResolutionFailed.has(node)) {
+      // A node in familyResolutionFailed already has its own precise error
+      // (ambiguous/unresolvable/invalid pluginFamily) from
+      // resolveNodePluginFamilyBindings above; "references plugin undefined"
+      // here would just be a confusing echo of that same failure.
       pushIssue(
         issues,
         "error",
@@ -1655,6 +1789,9 @@ export function checkFlowProgram({ flow, dependencies = new Map() } = {}) {
       pluginId: entry.node.pluginId,
       methodId: entry.node.methodId,
       dispatchModel: entry.dispatchModel,
+      // Present only for nodes bound via the additive pluginFamily path;
+      // absent (undefined) for ordinary exact-pluginId nodes.
+      resolvedFromPluginFamily: entry.node.resolvedFromPluginFamily ?? null,
     })),
   };
 }
@@ -2897,4 +3034,6 @@ export const __testables = {
   // SHARED statement-domain vectors directly, instead of inferring it from a
   // full compile that fails for a dozen later reasons.
   verifyIsomorphicNodeArtifacts,
+  normalizePluginFamilyName,
+  resolveNodePluginFamilyBindings,
 };

package/src/flow/flowRuntimeHost.js

@@ -202,7 +202,13 @@ export async function createFlowRuntimeHost(options = {}) {
     const bytes = stripPublicationTrailer(
       source instanceof Uint8Array ? source : new Uint8Array(source),
     );
-    wasmModule = await WebAssembly.compile(bytes.slice().buffer);
+    // Plaintext hygiene: `bytes` is a VIEW over the caller's own buffer
+    // (stripPublicationTrailer only ever narrows via subarray(), never
+    // copies), so it is never this function's buffer to zero — and
+    // WebAssembly.compile accepts a BufferSource view directly, so a
+    // defensive `.slice().buffer` copy here would only add an extra
+    // plaintext buffer that nothing zeroes. Compile from the view; no copy.
+    wasmModule = await WebAssembly.compile(bytes);
   }
 
   const wasi = createBrowserWasiShim({

package/src/flow/isomorphicFlowHost.js

@@ -5,7 +5,7 @@ import {
 } from "../bundle/signing.js";
 import { getWasmCustomSections } from "../bundle/wasm.js";
 import { decodePlgManifest } from "../manifest/plgCodec.js";
-import { createBrowserModuleHarness } from "../testing/browserModuleHarness.js";
+import { createBrowserModuleHarness } from "../host/browserModuleHarness.js";
 import { extractPublicationRecordCollection } from "../transport/records.js";
 import { sha256Bytes } from "../utils/crypto.js";
 import { bytesToHex } from "../utils/encoding.js";

package/src/flow/vendor/sdn-flow/MethodRegistry.js

@@ -1,10 +1,15 @@
 import { DrainPolicy } from "./constants.js";
+// Import the type-ref helpers from their own module, NOT from the manifest
+// barrel: `manifest/index.js` re-exports the build-time embedded-manifest
+// writers, which pull `node:fs`/`node:path`. A relative import bypasses the
+// package's `browser` export condition, so the barrel would drag Node builtins
+// into every browser bundle that reaches the flow runtime host.
 import {
   clonePayloadTypeRef,
   normalizePayloadWireFormatName,
   payloadTypeRefsMatch,
   selectPreferredPayloadTypeRef,
-} from "../../../manifest/index.js";
+} from "../../../manifest/typeRefs.js";
 import { normalizeFrame, normalizeManifest } from "./normalize.js";
 
 const INTERNAL_ALIGNED_BINARY_EXCEPTION_INTERFACE_KINDS = new Set([

package/src/generated/orbpro/propagator/propagator-source-description.js

@@ -29,7 +29,7 @@ class PropagatorSourceDescription {
   }
   sourceKind() {
     const offset = this.bb.__offset(this.bb_pos, 6);
-    return offset ? this.bb.readUint8(this.bb_pos + offset) : PropagatorSourceKind.UNKNOWN;
+    return offset ? this.bb.readUint8(this.bb_pos + offset) : PropagatorSourceKind.NONE;
   }
   objectName(optionalEncoding) {
     const offset = this.bb.__offset(this.bb_pos, 8);
@@ -114,7 +114,7 @@ class PropagatorSourceDescription {
     builder.addFieldInt32(0, sourceHandle, 0);
   }
   static addSourceKind(builder, sourceKind) {
-    builder.addFieldInt8(1, sourceKind, PropagatorSourceKind.UNKNOWN);
+    builder.addFieldInt8(1, sourceKind, PropagatorSourceKind.NONE);
   }
   static addObjectName(builder, objectNameOffset) {
     builder.addFieldOffset(2, objectNameOffset, 0);

package/src/generated/orbpro/propagator/propagator-source-description.ts

@@ -32,7 +32,7 @@ sourceHandle():number {
 
 sourceKind():PropagatorSourceKind {
   const offset = this.bb!.__offset(this.bb_pos, 6);
-  return offset ? this.bb!.readUint8(this.bb_pos + offset) : PropagatorSourceKind.UNKNOWN;
+  return offset ? this.bb!.readUint8(this.bb_pos + offset) : PropagatorSourceKind.NONE;
 }
 
 objectName():string|null
@@ -145,7 +145,7 @@ static addSourceHandle(builder:flatbuffers.Builder, sourceHandle:number) {
 }
 
 static addSourceKind(builder:flatbuffers.Builder, sourceKind:PropagatorSourceKind) {
-  builder.addFieldInt8(1, sourceKind, PropagatorSourceKind.UNKNOWN);
+  builder.addFieldInt8(1, sourceKind, PropagatorSourceKind.NONE);
 }
 
 static addObjectName(builder:flatbuffers.Builder, objectNameOffset:flatbuffers.Offset) {

package/src/generated/orbpro/propagator/propagator-source-kind.js

@@ -1,6 +1,17 @@
 var PropagatorSourceKind = /* @__PURE__ */ ((PropagatorSourceKind2) => {
-  PropagatorSourceKind2[PropagatorSourceKind2["UNKNOWN"] = 0] = "UNKNOWN";
-  PropagatorSourceKind2[PropagatorSourceKind2["SGP4"] = 1] = "SGP4";
+  PropagatorSourceKind2[PropagatorSourceKind2["NONE"] = 0] = "NONE";
+  PropagatorSourceKind2[PropagatorSourceKind2["SEMI_ANALYTICAL"] = 1] = "SEMI_ANALYTICAL";
+  PropagatorSourceKind2[PropagatorSourceKind2["VINTI"] = 2] = "VINTI";
+  PropagatorSourceKind2[PropagatorSourceKind2["SGP4"] = 3] = "SGP4";
+  PropagatorSourceKind2[PropagatorSourceKind2["COWELL"] = 4] = "COWELL";
+  PropagatorSourceKind2[PropagatorSourceKind2["RK4"] = 5] = "RK4";
+  PropagatorSourceKind2[PropagatorSourceKind2["NYX"] = 6] = "NYX";
+  PropagatorSourceKind2[PropagatorSourceKind2["GMAT"] = 7] = "GMAT";
+  PropagatorSourceKind2[PropagatorSourceKind2["SPICE"] = 8] = "SPICE";
+  PropagatorSourceKind2[PropagatorSourceKind2["SGP"] = 9] = "SGP";
+  PropagatorSourceKind2[PropagatorSourceKind2["SDP4"] = 10] = "SDP4";
+  PropagatorSourceKind2[PropagatorSourceKind2["SGP8"] = 11] = "SGP8";
+  PropagatorSourceKind2[PropagatorSourceKind2["SDP8"] = 12] = "SDP8";
   return PropagatorSourceKind2;
 })(PropagatorSourceKind || {});
 export {

package/src/generated/orbpro/propagator/propagator-source-kind.ts

@@ -3,6 +3,17 @@
 /* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
 
 export enum PropagatorSourceKind {
-  UNKNOWN = 0,
-  SGP4 = 1
+  NONE = 0,
+  SEMI_ANALYTICAL = 1,
+  VINTI = 2,
+  SGP4 = 3,
+  COWELL = 4,
+  RK4 = 5,
+  NYX = 6,
+  GMAT = 7,
+  SPICE = 8,
+  SGP = 9,
+  SDP4 = 10,
+  SGP8 = 11,
+  SDP8 = 12
 }

package/src/generated/spacedatastandards/plg/pluginCategory.d.ts

@@ -77,6 +77,23 @@ export declare enum pluginCategory {
     /**
      * Basilisk astrodynamics simulation module
      */
-    Basilisk = 18
+    Basilisk = 18,
+    /**
+     * Maneuver planning, targeting and trajectory optimization
+     */
+    Maneuver = 19,
+    /**
+     * A composed flow published as a single loadable module. The unit is a
+     * graph of other modules, not a leaf algorithm.
+     */
+    Flow = 20,
+    /**
+     * No family stated. Sits at the end of the enum rather than at 0 because
+     * this enum is append-only and `Sensor` already holds 0; it exists so a
+     * record can distinguish "the provider did not say" from "Sensor". A
+     * consumer MUST render an `Unspecified` module as ungrouped, never as a
+     * member of any family.
+     */
+    Unspecified = 21
 }
 //# sourceMappingURL=pluginCategory.d.ts.map

package/src/generated/spacedatastandards/plg/pluginCategory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pluginCategory.d.ts","sourceRoot":"","sources":["../../../ts/PLG/pluginCategory.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,oBAAY,cAAc;IACxB;;OAEG;IACH,MAAM,IAAI;IAEV;;OAEG;IACH,UAAU,IAAI;IAEd;;OAEG;IACH,QAAQ,IAAI;IAEZ;;OAEG;IACH,QAAQ,IAAI;IAEZ;;OAEG;IACH,UAAU,IAAI;IAEd;;OAEG;IACH,EAAE,IAAI;IAEN;;OAEG;IACH,KAAK,IAAI;IAET;;OAEG;IACH,OAAO,IAAI;IAEX;;OAEG;IACH,MAAM,IAAI;IAEV;;OAEG;IACH,MAAM,IAAI;IAEV;;OAEG;IACH,SAAS,KAAK;IAEd;;OAEG;IACH,YAAY,KAAK;IAEjB;;OAEG;IACH,QAAQ,KAAK;IAEb;;OAEG;IACH,UAAU,KAAK;IAEf;;OAEG;IACH,cAAc,KAAK;IAEnB;;OAEG;IACH,SAAS,KAAK;IAEd;;OAEG;IACH,UAAU,KAAK;IAEf;;OAEG;IACH,SAAS,KAAK;IAEd;;OAEG;IACH,QAAQ,KAAK;CACd"}
+{"version":3,"file":"pluginCategory.d.ts","sourceRoot":"","sources":["../../../ts/PLG/pluginCategory.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,oBAAY,cAAc;IACxB;;OAEG;IACH,MAAM,IAAI;IAEV;;OAEG;IACH,UAAU,IAAI;IAEd;;OAEG;IACH,QAAQ,IAAI;IAEZ;;OAEG;IACH,QAAQ,IAAI;IAEZ;;OAEG;IACH,UAAU,IAAI;IAEd;;OAEG;IACH,EAAE,IAAI;IAEN;;OAEG;IACH,KAAK,IAAI;IAET;;OAEG;IACH,OAAO,IAAI;IAEX;;OAEG;IACH,MAAM,IAAI;IAEV;;OAEG;IACH,MAAM,IAAI;IAEV;;OAEG;IACH,SAAS,KAAK;IAEd;;OAEG;IACH,YAAY,KAAK;IAEjB;;OAEG;IACH,QAAQ,KAAK;IAEb;;OAEG;IACH,UAAU,KAAK;IAEf;;OAEG;IACH,cAAc,KAAK;IAEnB;;OAEG;IACH,SAAS,KAAK;IAEd;;OAEG;IACH,UAAU,KAAK;IAEf;;OAEG;IACH,SAAS,KAAK;IAEd;;OAEG;IACH,QAAQ,KAAK;IAEb;;OAEG;IACH,QAAQ,KAAK;IAEb;;;OAGG;IACH,IAAI,KAAK;IAET;;;;;;OAMG;IACH,WAAW,KAAK;CACjB"}

package/src/generated/spacedatastandards/plg/pluginCategory.js

@@ -81,4 +81,21 @@ export var pluginCategory;
      * Basilisk astrodynamics simulation module
      */
     pluginCategory[pluginCategory["Basilisk"] = 18] = "Basilisk";
+    /**
+     * Maneuver planning, targeting and trajectory optimization
+     */
+    pluginCategory[pluginCategory["Maneuver"] = 19] = "Maneuver";
+    /**
+     * A composed flow published as a single loadable module. The unit is a
+     * graph of other modules, not a leaf algorithm.
+     */
+    pluginCategory[pluginCategory["Flow"] = 20] = "Flow";
+    /**
+     * No family stated. Sits at the end of the enum rather than at 0 because
+     * this enum is append-only and `Sensor` already holds 0; it exists so a
+     * record can distinguish "the provider did not say" from "Sensor". A
+     * consumer MUST render an `Unspecified` module as ungrouped, never as a
+     * member of any family.
+     */
+    pluginCategory[pluginCategory["Unspecified"] = 21] = "Unspecified";
 })(pluginCategory || (pluginCategory = {}));

package/src/generated/spacedatastandards/plg/pluginCategory.ts

@@ -99,5 +99,25 @@ export enum pluginCategory {
   /**
    * Basilisk astrodynamics simulation module
    */
-  Basilisk = 18
+  Basilisk = 18,
+
+  /**
+   * Maneuver planning, targeting and trajectory optimization
+   */
+  Maneuver = 19,
+
+  /**
+   * A composed flow published as a single loadable module. The unit is a
+   * graph of other modules, not a leaf algorithm.
+   */
+  Flow = 20,
+
+  /**
+   * No family stated. Sits at the end of the enum rather than at 0 because
+   * this enum is append-only and `Sensor` already holds 0; it exists so a
+   * record can distinguish "the provider did not say" from "Sensor". A
+   * consumer MUST render an `Unspecified` module as ungrouped, never as a
+   * member of any family.
+   */
+  Unspecified = 21
 }