space-data-module-sdk 0.8.0 → 0.8.2

package/README.md

@@ -410,11 +410,22 @@ for resolved protocol installations and producer input bindings.
 ## Publication Protection Extensions
 
 Digital signature and encrypted-delivery metadata are publication-layer
-extensions, not a second module format. The canonical module is still:
+extensions. The canonical runtime module is still:
 
 - valid `.wasm`
 - optionally carrying one appended SDS `REC` trailer after the wasm bytes
 
+The same-file protected delivery layout is:
+
+```text
+protected-payload-bytes || REC-flatbuffer-bytes || uint32le(REC length) || "$REC"
+```
+
+For signed-only delivery, the protected payload bytes are the wasm bytes. For
+encrypted binary delivery, the protected payload bytes are ciphertext and the
+appended `REC` trailer carries `ENC` so a loader can decrypt them back to the
+canonical wasm before runtime startup.
+
 That trailing `REC` FlatBuffer is the standards-backed container for
 publication records:
 
@@ -435,7 +446,7 @@ The loader contract is always:
    FlatBuffers from `spacedatastandards.org`.
 4. Resolve `PNM` for signature/publication metadata.
 5. Resolve `ENC` if the delivery was encrypted.
-6. Strip the trailer or decrypt the protected payload.
+6. Strip the trailer or decrypt the protected payload bytes.
 7. Hand the remaining raw wasm bytes to the runtime.
 
 Aligned-binary payloads are a separate invoke-ABI optimization. They do not
@@ -547,9 +558,12 @@ npx space-data-module check --manifest ./manifest.json --wasm ./dist/isomorphic/
 # Compile C/C++ source and embed the manifest
 npx space-data-module compile --manifest ./manifest.json --source ./src/module.c --out ./dist/isomorphic/module.wasm
 
-# Sign and encrypt a deployment payload
+# Sign a deployment payload and print JSON metadata
 npx space-data-module protect --manifest ./manifest.json --wasm ./dist/isomorphic/module.wasm --json
 
+# Emit an encrypted binary with an appended REC trailer
+npx space-data-module protect --manifest ./manifest.json --wasm ./dist/isomorphic/module.wasm --recipient-public-key <hex> --out ./dist/module.wasm.enc
+
 # Emit a single-file bundled wasm
 npx space-data-module protect --manifest ./manifest.json --wasm ./dist/isomorphic/module.wasm --single-file-bundle --out ./dist/module.bundle.wasm
 ```

package/bin/space-data-module.js

@@ -106,6 +106,7 @@ function printUsage() {
   space-data-module check --manifest ./manifest.json --wasm ./dist/module.wasm
   space-data-module compile --manifest ./manifest.json --source ./src/module.c --out ./dist/module.wasm
   space-data-module protect --manifest ./manifest.json --wasm ./dist/module.wasm --json
+  space-data-module protect --manifest ./manifest.json --wasm ./dist/module.wasm --recipient-public-key <hex> --out ./dist/module.wasm.enc
   space-data-module protect --manifest ./manifest.json --wasm ./dist/module.wasm --single-file-bundle --out ./dist/module.bundle.wasm
 `);
 }
@@ -213,9 +214,6 @@ async function runProtect(argv) {
   if (!options.manifestPath || !options.wasmPath) {
     throw new Error("protect requires --manifest and --wasm.");
   }
-  if (options.outputPath && options.singleFileBundle !== true) {
-    throw new Error("protect only supports --out together with --single-file-bundle.");
-  }
   const manifest = await loadManifestFromFile(options.manifestPath);
   const wasmBytes = new Uint8Array(await readFile(options.wasmPath));
   const result = await protectModuleArtifact({
@@ -225,8 +223,11 @@ async function runProtect(argv) {
     mnemonic: options.mnemonic,
     singleFileBundle: options.singleFileBundle,
   });
-  if (options.singleFileBundle && options.outputPath && result.bundledWasmBytes) {
-    await writeFile(options.outputPath, result.bundledWasmBytes);
+  if (options.outputPath) {
+    await writeFile(
+      options.outputPath,
+      result.bundledWasmBytes ?? result.protectedArtifactBytes,
+    );
   }
   if (options.json) {
     console.log(JSON.stringify(result, null, 2));
@@ -235,7 +236,8 @@ async function runProtect(argv) {
     console.log(`signingPublicKeyHex=${result.signingPublicKeyHex}`);
     console.log(`encrypted=${result.encrypted}`);
     console.log(`wasmBase64Length=${bytesToBase64(wasmBytes).length}`);
-    if (result.bundledWasmBytes) {
+    console.log(`protectedArtifactBytes=${result.protectedArtifactBytes.length}`);
+    if (options.singleFileBundle && result.bundledWasmBytes) {
       console.log(`singleFileBundle=true`);
       console.log(`bundledWasmBytes=${result.bundledWasmBytes.length}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "space-data-module-sdk",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Module SDK for building, validating, signing, and deploying WebAssembly modules on the Space Data Network.",
   "type": "module",
   "types": "./src/index.d.ts",
@@ -72,7 +72,7 @@
     "flatsql": "^0.4.0",
     "hd-wallet-wasm": "1.6.0",
     "sdn-emception": "1.0.0",
-    "spacedatastandards.org": "1.85.0"
+    "spacedatastandards.org": "^1.92.0"
   },
   "devDependencies": {
     "express": "^4.21.2"

package/schemas/spacedatastandards/PLG.fbs

@@ -0,0 +1,191 @@
+// Canonical plugin manifest schema.
+//
+// Upstream source: https://github.com/DigitalArsenal/spacedatastandards.org
+// Path:            schema/PLG/main.fbs
+// Version:         1.0.6
+// Upstream hash:   2c9ca90ec923b2476832517dee715559c45dd198d3bdd4b5b3dfe0a4d05c4882
+//
+// This is the canonical spacedatastandards.org "PLG" manifest.
+// It is vendored here verbatim so the plugin SDK can depend on a stable copy
+// without adding a network or submodule fetch at build time. Keep this file
+// byte-for-byte identical to the upstream version; if a refresh is needed,
+// re-vendor from the upstream path above rather than hand-editing.
+
+// Hash: 2c9ca90ec923b2476832517dee715559c45dd198d3bdd4b5b3dfe0a4d05c4882
+// Version: 1.0.6
+// -----------------------------------END_HEADER
+/// Plugin type category
+enum pluginCategory : byte {
+  /// Sensor simulation and analysis
+  Sensor,
+  /// Orbital propagation algorithms
+  Propagator,
+  /// Custom rendering/visualization
+  Renderer,
+  /// Data analysis and processing
+  Analysis,
+  /// External data source integration
+  DataSource,
+  /// Electronic warfare simulation
+  EW,
+  /// Communications modeling
+  Comms,
+  /// Physics simulation
+  Physics,
+  /// GLSL shader plugins for custom visualization
+  Shader
+}
+
+/// Storefront payment model for the plugin listing
+enum purchaseTier : byte {
+  /// No payment required
+  Free,
+  /// Single one-time purchase
+  OneTime,
+  /// Recurring subscription purchase
+  Subscription
+}
+
+/// Publication visibility for the plugin listing
+enum publicationState : byte {
+  /// Discoverable in public storefront listings
+  Public,
+  /// Addressable directly but hidden from public browse surfaces
+  Unlisted,
+  /// No longer offered for new installs or purchases
+  Retired
+}
+
+/// Plugin capability declaration
+table PluginCapability {
+  /// Capability name, e.g., "gpu_compute", "wasm_simd"
+  NAME: string;
+  /// Capability version
+  VERSION: string;
+  /// Whether this capability is required
+  REQUIRED: bool;
+}
+
+/// Plugin dependency on another plugin
+table PluginDependency {
+  /// Plugin ID of the dependency
+  PLUGIN_ID: string;
+  /// Minimum version required (semver)
+  MIN_VERSION: string;
+  /// Maximum version allowed (optional)
+  MAX_VERSION: string;
+}
+
+/// Plugin entry point function definition
+table EntryFunction {
+  /// Function name as exported from WASM
+  NAME: string (required);
+  /// Human-readable description
+  DESCRIPTION: string;
+  /// Input parameter types (FlatBuffer schema names)
+  INPUT_SCHEMAS: [string];
+  /// Output type (FlatBuffer schema name)
+  OUTPUT_SCHEMA: string;
+}
+
+/// Plugin Manifest - canonical signed storefront and WASM distribution record
+table PLG {
+  /// Unique identifier for the plugin
+  PLUGIN_ID: string (required);
+  /// Human-readable plugin name
+  NAME: string (required);
+  /// Plugin version (semver format)
+  VERSION: string (required);
+  /// Detailed description of plugin functionality
+  DESCRIPTION: string;
+  /// Short marketing summary shown in storefront listings
+  TAGLINE: string;
+  /// Type/category of the plugin
+  PLUGIN_TYPE: pluginCategory;
+  /// Human-readable publisher or organization name
+  PUBLISHER_NAME: string;
+  /// Publisher handle or username
+  PUBLISHER_HANDLE: string;
+  /// Canonical publisher website
+  PUBLISHER_URL: string;
+  /// Support or helpdesk URL for this plugin
+  SUPPORT_URL: string;
+  /// Search and categorization tags for discovery
+  TAGS: [string];
+  /// Short feature bullets highlighted in storefront listings
+  FEATURES: [string];
+  /// Screenshot URLs showing the plugin in use
+  SCREENSHOT_URLS: [string];
+  /// Optional hero/banner image URL for the listing
+  BANNER_URL: string;
+
+  /// ABI version for compatibility checking
+  ABI_VERSION: uint32 = 1;
+
+  /// SHA256 hash of the decrypted WASM binary
+  WASM_HASH: [ubyte];
+  /// Size of decrypted WASM binary in bytes
+  WASM_SIZE: uint64;
+  /// IPFS CID of the encrypted WASM binary
+  WASM_CID: string;
+  /// SHA256 hash of the encrypted delivery artifact bytes
+  ENCRYPTED_WASM_HASH: [ubyte];
+  /// Size of the encrypted delivery artifact in bytes
+  ENCRYPTED_WASM_SIZE: uint64;
+
+  /// Entry point functions exported by the plugin
+  ENTRY_FUNCTIONS: [EntryFunction];
+  /// FlatBuffer schemas required by this plugin
+  REQUIRED_SCHEMAS: [string];
+  /// Other plugins this depends on
+  DEPENDENCIES: [PluginDependency];
+  /// Capabilities provided by this plugin
+  CAPABILITIES: [PluginCapability];
+
+  /// Peer ID of the plugin provider
+  PROVIDER_PEER_ID: string;
+  /// IPFS CID of provider's EPM (Entity Profile Message)
+  PROVIDER_EPM_CID: string;
+
+  /// Whether the WASM binary is encrypted
+  ENCRYPTED: bool = true;
+  /// Canonical required scope for grant issuance
+  REQUIRED_SCOPE: string;
+  /// Provider-local identifier for the module content key
+  KEY_ID: string;
+  /// Allowed requester domains for module grants
+  ALLOWED_DOMAINS: [string];
+  /// Maximum grant timeout allowed for this module publication
+  MAX_GRANT_TIMEOUT_MS: uint64;
+  /// Minimum permissions required to run
+  MIN_PERMISSIONS: [string];
+
+  /// Unix timestamp when plugin was created
+  CREATED_AT: uint64;
+  /// Unix timestamp when plugin was last updated
+  UPDATED_AT: uint64;
+  /// URL to plugin documentation
+  DOCUMENTATION_URL: string;
+  /// URL to plugin changelog or release notes
+  CHANGELOG_URL: string;
+  /// URL to plugin icon/logo
+  ICON_URL: string;
+  /// License identifier (SPDX format)
+  LICENSE: string;
+  /// Commercial model used for storefront purchase flows
+  PAYMENT_MODEL: purchaseTier = Free;
+  /// Price in USD cents for one-time purchase or subscription period
+  PRICE_USD_CENTS: uint32;
+  /// Subscription billing period length in days
+  SUBSCRIPTION_PERIOD_DAYS: uint32;
+  /// Accepted payment methods, e.g. "stripe", "sol", "usdc"
+  ACCEPTED_PAYMENT_METHODS: [string];
+  /// Storefront publication state for this manifest version
+  LISTING_STATUS: publicationState = Public;
+
+  /// Ed25519 signature from provider over manifest
+  SIGNATURE: [ubyte];
+}
+
+root_type PLG;
+file_identifier "$PLG";

package/src/bundle/wasm.js

@@ -1,5 +1,11 @@
 import { canonicalBytes } from "../auth/canonicalize.js";
-import { decodePluginManifest, encodePluginManifest } from "../manifest/index.js";
+import {
+  decodePluginManifest,
+  decodePlgManifest,
+  encodePlgManifest,
+  isPlgManifestBuffer,
+  legacyManifestToPlg,
+} from "../manifest/index.js";
 import { toUint8Array } from "../runtime/bufferLike.js";
 import { sha256Bytes } from "../utils/crypto.js";
 import { bytesToHex } from "../utils/encoding.js";
@@ -226,20 +232,36 @@ function normalizeJsonPayload(value) {
   return new Uint8Array(canonicalBytes(value));
 }
 
+function encodeBundleManifest(manifest) {
+  return encodePlgManifest(legacyManifestToPlg(manifest));
+}
+
+function decodeBundleManifest(payloadBytes) {
+  return isPlgManifestBuffer(payloadBytes)
+    ? decodePlgManifest(payloadBytes)
+    : decodePluginManifest(payloadBytes);
+}
+
 function normalizeManifestEntry(manifest, manifestBytes) {
   if (!manifest && !manifestBytes) {
     return null;
   }
-  const payload = manifestBytes ?? encodePluginManifest(manifest);
+  const payload = manifestBytes ?? encodeBundleManifest(manifest);
+  const isPlg = isPlgManifestBuffer(payload);
   return {
     entryId: "manifest",
     role: "manifest",
     sectionName: "sds.manifest",
     payloadEncoding: "flatbuffer",
-    typeRef: {
-      schemaName: "PluginManifest.fbs",
-      fileIdentifier: "PMAN",
-    },
+    typeRef: isPlg
+      ? {
+          schemaName: "PLG.fbs",
+          fileIdentifier: "$PLG",
+        }
+      : {
+          schemaName: "PluginManifest.fbs",
+          fileIdentifier: "PMAN",
+        },
     payload,
     description: "Canonical plugin manifest.",
   };
@@ -330,7 +352,7 @@ function buildParsedEntries(bundle) {
       parsedEntry.payloadEncodingName === "flatbuffer"
     ) {
       try {
-        parsedEntry.decodedManifest = decodePluginManifest(payloadBytes);
+        parsedEntry.decodedManifest = decodeBundleManifest(payloadBytes);
       } catch {
         parsedEntry.decodedManifest = null;
       }
@@ -380,7 +402,7 @@ export async function createSingleFileBundle(options = {}) {
     options.manifestBytes !== undefined
       ? normalizeBytes(options.manifestBytes, "manifestBytes")
       : options.manifest
-        ? encodePluginManifest(options.manifest)
+        ? encodeBundleManifest(options.manifest)
         : null;
   const manifestEntry = normalizeManifestEntry(options.manifest, manifestBytes);
   const rawEntries = [
@@ -463,7 +485,7 @@ export async function parseSingleFileBundle(bytes, options = {}) {
   let manifest = null;
   if (manifestEntry) {
     try {
-      manifest = decodePluginManifest(new Uint8Array(manifestEntry.payload ?? []));
+      manifest = decodeBundleManifest(new Uint8Array(manifestEntry.payload ?? []));
     } catch {
       manifest = null;
     }

package/src/compliance/index.js

@@ -2,8 +2,10 @@ import {
   findManifestFiles,
   getWasmExportNames,
   getWasmExportNamesFromFile,
+  hasLegacyPmanManifest,
   loadManifestFromFile,
   loadComplianceConfig,
+  locateEmbeddedPlgManifest,
   resolveManifestFiles,
   validatePluginArtifact,
   validatePluginManifest,
@@ -49,8 +51,10 @@ export {
   findManifestFiles,
   getWasmExportNames,
   getWasmExportNamesFromFile,
+  hasLegacyPmanManifest,
   loadManifestFromFile,
   loadComplianceConfig,
+  locateEmbeddedPlgManifest,
   RecommendedCapabilityIds,
   StandaloneWasiCapabilityIds,
   resolveManifestFiles,

package/src/compliance/pluginCompliance.js

@@ -16,6 +16,11 @@ import {
   RecommendedCapabilityIds,
   StandaloneWasiCapabilityIds,
 } from "../capabilities.js";
+import {
+  PLG_FILE_IDENTIFIER,
+  decodePlgManifest,
+  isPlgManifestBuffer,
+} from "../manifest/plgCodec.js";
 
 const RecommendedCapabilitySet = new Set(RecommendedCapabilityIds);
 const StandaloneWasiCapabilitySet = new Set(StandaloneWasiCapabilityIds);
@@ -1356,11 +1361,143 @@ export async function getWasmExportNamesFromFile(wasmPath) {
   return getWasmExportNames(wasmBytes);
 }
 
+const PLG_IDENTIFIER_BYTES = Uint8Array.from(
+  Array.from(PLG_FILE_IDENTIFIER, (ch) => ch.charCodeAt(0)),
+);
+const LEGACY_PMAN_IDENTIFIER_BYTES = Uint8Array.from([0x50, 0x4d, 0x41, 0x4e]);
+
+function indexOfBytes(haystack, needle, startIndex = 0) {
+  if (!haystack || needle.length === 0 || haystack.length < needle.length) {
+    return -1;
+  }
+  for (let i = startIndex; i <= haystack.length - needle.length; i += 1) {
+    let matched = true;
+    for (let j = 0; j < needle.length; j += 1) {
+      if (haystack[i + j] !== needle[j]) {
+        matched = false;
+        break;
+      }
+    }
+    if (matched) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Scan wasm bytes for the canonical `$PLG` FlatBuffer identifier and, when
+ * found, return both the raw offset and the smallest aligned candidate buffer
+ * that a downstream decoder can try to parse. The wasm `data` sections embed
+ * the manifest bytes verbatim; FlatBuffer headers are `<root_offset:u32><$PLG>`
+ * so we walk backwards one 4-byte word and hand the caller a slice starting
+ * there.
+ */
+export function locateEmbeddedPlgManifest(wasmBytes) {
+  const bytes = wasmBytes instanceof Uint8Array
+    ? wasmBytes
+    : new Uint8Array(wasmBytes);
+  const identifierOffset = indexOfBytes(bytes, PLG_IDENTIFIER_BYTES);
+  if (identifierOffset < 4) {
+    return null;
+  }
+  const start = identifierOffset - 4;
+  // Upper bound on the manifest size — grab up to 64KB and let the caller
+  // decide how much to trim. FlatBuffer decoders only read what they need.
+  const end = Math.min(bytes.length, start + 65536);
+  const candidate = bytes.subarray(start, end);
+  if (!isPlgManifestBuffer(candidate)) {
+    return null;
+  }
+  return { start, identifierOffset, bytes: candidate };
+}
+
+export function hasLegacyPmanManifest(wasmBytes) {
+  const bytes = wasmBytes instanceof Uint8Array
+    ? wasmBytes
+    : new Uint8Array(wasmBytes);
+  return indexOfBytes(bytes, LEGACY_PMAN_IDENTIFIER_BYTES) !== -1;
+}
+
+function validateEmbeddedManifestBytes({
+  wasmBytes,
+  manifest,
+  issues,
+  sourceLabel,
+}) {
+  if (hasLegacyPmanManifest(wasmBytes)) {
+    pushIssue(
+      issues,
+      "error",
+      "legacy-pman-manifest-embedded",
+      "Plugin artifact embeds legacy PMAN manifest bytes — rebuild with the PLG codec.",
+      sourceLabel,
+    );
+  }
+
+  const located = locateEmbeddedPlgManifest(wasmBytes);
+  if (!located) {
+    pushIssue(
+      issues,
+      "error",
+      "missing-plg-manifest-bytes",
+      `Plugin artifact does not embed a canonical \"${PLG_FILE_IDENTIFIER}\" manifest buffer.`,
+      sourceLabel,
+    );
+    return;
+  }
+
+  let decoded;
+  try {
+    decoded = decodePlgManifest(located.bytes);
+  } catch (error) {
+    pushIssue(
+      issues,
+      "error",
+      "plg-manifest-decode-failed",
+      `Failed to decode embedded PLG manifest: ${error?.message ?? error}`,
+      sourceLabel,
+    );
+    return;
+  }
+
+  const sourcePluginId = manifest?.pluginId ?? manifest?.plugin_id ?? null;
+  if (
+    isNonEmptyString(sourcePluginId) &&
+    isNonEmptyString(decoded?.pluginId) &&
+    sourcePluginId !== decoded.pluginId
+  ) {
+    pushIssue(
+      issues,
+      "error",
+      "plg-manifest-plugin-id-mismatch",
+      `Embedded PLG manifest pluginId \"${decoded.pluginId}\" does not match source manifest pluginId \"${sourcePluginId}\".`,
+      sourceLabel,
+    );
+  }
+
+  const sourceVersion = manifest?.version ?? null;
+  if (
+    isNonEmptyString(sourceVersion) &&
+    isNonEmptyString(decoded?.version) &&
+    sourceVersion !== decoded.version
+  ) {
+    pushIssue(
+      issues,
+      "warning",
+      "plg-manifest-version-mismatch",
+      `Embedded PLG manifest version \"${decoded.version}\" does not match source manifest version \"${sourceVersion}\".`,
+      sourceLabel,
+    );
+  }
+}
+
 export async function validatePluginArtifact(options) {
   const {
     manifest,
     manifestPath = null,
     wasmPath = null,
+    wasmBytes: inputWasmBytes = null,
     exportNames = null,
     sourceName = manifestPath ?? "manifest",
   } = options;
@@ -1368,15 +1505,26 @@ export async function validatePluginArtifact(options) {
   const issues = [...report.issues];
   let resolvedExportNames = [];
   let checkedArtifact = false;
+  let loadedWasmBytes = null;
   const declaredInvokeSurfaces = Array.isArray(manifest?.invokeSurfaces)
     ? manifest.invokeSurfaces.filter((surface) => InvokeSurfaceSet.has(surface))
     : [];
 
-  if (Array.isArray(exportNames)) {
+  if (inputWasmBytes) {
+    loadedWasmBytes =
+      inputWasmBytes instanceof Uint8Array
+        ? inputWasmBytes
+        : new Uint8Array(inputWasmBytes);
+    resolvedExportNames = Array.isArray(exportNames)
+      ? [...exportNames]
+      : getWasmExportNames(loadedWasmBytes);
+    checkedArtifact = true;
+  } else if (Array.isArray(exportNames)) {
     resolvedExportNames = [...exportNames];
     checkedArtifact = true;
   } else if (isNonEmptyString(wasmPath)) {
-    resolvedExportNames = await getWasmExportNamesFromFile(wasmPath);
+    loadedWasmBytes = new Uint8Array(await readFile(wasmPath));
+    resolvedExportNames = getWasmExportNames(loadedWasmBytes);
     checkedArtifact = true;
   }
 
@@ -1424,6 +1572,14 @@ export async function validatePluginArtifact(options) {
         wasmPath ?? sourceName,
       );
     }
+    if (loadedWasmBytes) {
+      validateEmbeddedManifestBytes({
+        wasmBytes: loadedWasmBytes,
+        manifest,
+        issues,
+        sourceLabel: wasmPath ?? sourceName,
+      });
+    }
   } else {
     pushIssue(
       issues,

package/src/embeddedManifest.js

@@ -2,8 +2,19 @@ import fs from "node:fs";
 import path from "node:path";
 
 import { encodePluginManifest } from "./manifest/index.js";
-
-function toManifestBytes(manifest) {
+import { legacyManifestToPlg } from "./manifest/legacyToPlg.js";
+import { encodePlgManifest } from "./manifest/plgCodec.js";
+
+/**
+ * Convert a manifest input to the raw FlatBuffer bytes that will be
+ * embedded in the plugin artifact.
+ *
+ * The embedded manifest is the canonical spacedatastandards.org PLG
+ * schema (`$PLG` file_identifier) by default. Pass `format: "pman"` to
+ * emit the internal PluginManifest schema instead (legacy path, retained
+ * for tests that still compare against PMAN bytes).
+ */
+function toManifestBytes(manifest, format = "plg") {
   if (manifest instanceof Uint8Array) {
     return manifest;
   }
@@ -17,7 +28,13 @@ function toManifestBytes(manifest) {
       manifest.byteLength,
     );
   }
-  return encodePluginManifest(manifest);
+  if (format === "pman") {
+    return encodePluginManifest(manifest);
+  }
+  // Default: PLG. Accept both PLG-shaped and legacy PluginManifest-shaped
+  // inputs; the converter is a no-op for PLG-native shapes.
+  const plgShape = legacyManifestToPlg(manifest);
+  return encodePlgManifest(plgShape);
 }
 
 function renderByteRows(bytes) {
@@ -34,7 +51,10 @@ function renderByteRows(bytes) {
 }
 
 export function generateEmbeddedManifestSource(options = {}) {
-  const manifestBytes = toManifestBytes(options.manifest);
+  const manifestBytes = toManifestBytes(
+    options.manifest,
+    options.format ?? "plg",
+  );
   if (manifestBytes.length === 0) {
     throw new Error("generateEmbeddedManifestSource requires manifest bytes.");
   }
@@ -91,7 +111,7 @@ export function writeEmbeddedManifestArtifacts(options = {}) {
     throw new Error("writeEmbeddedManifestArtifacts requires outputDir.");
   }
 
-  const manifestBytes = toManifestBytes(manifest);
+  const manifestBytes = toManifestBytes(manifest, options.format ?? "plg");
   fs.mkdirSync(outputDir, { recursive: true });
 
   const binaryPath = path.join(outputDir, binaryFileName);

package/src/generated/orbpro/invoke/plugin-invoke-request.js

@@ -1,6 +1,6 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 /* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
-import * as flatbuffers from "flatbuffers/mjs/flatbuffers.js";
+import * as flatbuffers from "../../../vendor/flatbuffers/flatbuffers.js";
 import { TypedArenaBuffer } from '../../orbpro/stream/typed-arena-buffer.js';
 /**
  * Canonical invoke envelope consumed by direct ABI and command-mode execution.
@@ -128,4 +128,4 @@ export class PluginInvokeRequestT {
         return PluginInvokeRequest.createPluginInvokeRequest(builder, methodId, inputFrames, payloadArena);
     }
 }
-//# sourceMappingURL=plugin-invoke-request.js.map
+//# sourceMappingURL=plugin-invoke-request.js.map

package/src/generated/orbpro/invoke/plugin-invoke-response.js

@@ -1,6 +1,6 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 /* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
-import * as flatbuffers from "flatbuffers/mjs/flatbuffers.js";
+import * as flatbuffers from "../../../vendor/flatbuffers/flatbuffers.js";
 import { TypedArenaBuffer } from '../../orbpro/stream/typed-arena-buffer.js';
 /**
  * Canonical invoke result emitted by direct ABI and command-mode execution.
@@ -181,4 +181,4 @@ export class PluginInvokeResponseT {
         return PluginInvokeResponse.createPluginInvokeResponse(builder, this.statusCode, this.yielded, this.backlogRemaining, outputFrames, payloadArena, errorCode, errorMessage);
     }
 }
-//# sourceMappingURL=plugin-invoke-response.js.map
+//# sourceMappingURL=plugin-invoke-response.js.map