space-data-module-sdk 0.5.13 → 0.5.14

package/README.md

@@ -14,28 +14,11 @@ This repository is the source of truth for module-level concerns:
 - the `sds.bundle` single-file container
 - deployment authorization plus SDS publication records (`REC`, `PNM`, `ENC`)
 - the first canonical module hostcall/import ABI surface
-- shared module-level testing/runtime harnesses, including the WasmEdge
-  process runner used by package-level validation suites
 
 <p align="center">
   <img src="docs/architecture.svg" alt="Module architecture overview" width="820" />
 </p>
 
-## Shared Harness Ownership
-
-This repo owns the generic module-side runtime harnesses used across the stack:
-
-- `createModuleHarness(...)` for process and WasmEdge-backed module invocation
-- `resolveModuleHarnessLaunchPlan(...)` for portable launch planning
-- `buildWasmEdgeEmscriptenPthreadRunner(...)` plus the shared native runner
-  source and runner-level pthread smoke test
-
-Flow-specific standalone harnessing lives in `sdn-flow`, which layers flow
-enqueue/drain behavior on top of its compiled standalone runtime host. Package-
-specific validation suites, including conjunction replay/V&V, are expected to
-sit on top of these shared harnesses instead of defining their own runtime
-process model.
-
 ## Module Artifact Model
 
 A compliant module built with this SDK is always a valid `.wasm` artifact with:
@@ -195,11 +178,6 @@ semantics.
 This repo now exposes a manifest-driven harness generator from
 `space-data-module-sdk/testing` and two complementary integration suites:
 
-- shared process-level helpers for command-surface runtimes:
-  - `createPluginInvokeProcessClient(...)`
-  - `resolveWasmEdgePluginLaunchPlan(...)`
-  - `buildWasmEdgeEmscriptenPthreadRunner(...)`
-
 - `npm run test:runtime-matrix`
   - cross-language runtime smoke across the same WASM in Node.js, Go, Python,
     Rust, Java, C#, and Swift

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "space-data-module-sdk",
-  "version": "0.5.13",
+  "version": "0.5.14",
   "description": "Module SDK for building, validating, signing, and deploying WebAssembly modules on the Space Data Network.",
   "type": "module",
   "types": "./src/index.d.ts",
@@ -40,9 +40,6 @@
     "schemas/",
     "src/"
   ],
-  "publishConfig": {
-    "access": "public"
-  },
   "scripts": {
     "test": "node --test",
     "test:host-surfaces": "node --test test/node-host.test.js test/host-abi.test.js",

package/src/compiler/flatcSupport.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { readFile, readdir, stat } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 
 import { FlatcRunner } from "flatc-wasm";
@@ -18,48 +18,6 @@ function loadFlatcRunner() {
   return flatcRunnerPromise;
 }
 
-const FLATBUFFERS_INCLUDE_ROOT_CANDIDATES = [
-  process.env.FLATBUFFERS_INCLUDE_DIR,
-  "/opt/homebrew/include",
-  "/usr/local/include",
-  "/usr/include",
-].filter(Boolean);
-
-async function findFlatbuffersIncludeRoot() {
-  for (const candidate of FLATBUFFERS_INCLUDE_ROOT_CANDIDATES) {
-    const headerPath = path.join(candidate, "flatbuffers", "flatbuffers.h");
-    try {
-      const headerStat = await stat(headerPath);
-      if (headerStat.isFile()) {
-        return candidate;
-      }
-    } catch {
-      // Try the next candidate.
-    }
-  }
-  throw new Error(
-    "Unable to locate the installed flatbuffers C++ headers. Set FLATBUFFERS_INCLUDE_DIR to the directory containing flatbuffers/flatbuffers.h.",
-  );
-}
-
-async function readDirectoryTree(rootDir, currentDir = rootDir) {
-  const entries = await readdir(currentDir, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries) {
-    const fullPath = path.join(currentDir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...(await readDirectoryTree(rootDir, fullPath)));
-      continue;
-    }
-    if (!entry.isFile()) {
-      continue;
-    }
-    const relativePath = path.relative(rootDir, fullPath).split(path.sep).join("/");
-    files.push([`/${relativePath}`, await readFile(fullPath, "utf8")]);
-  }
-  return files;
-}
-
 async function loadInvokeSchemaFiles() {
   const filenames = [
     "TypedArenaBuffer.fbs",
@@ -78,10 +36,8 @@ async function loadInvokeSchemaFiles() {
 export async function getFlatbuffersCppRuntimeHeaders() {
   if (!flatbuffersCppRuntimeHeadersPromise) {
     flatbuffersCppRuntimeHeadersPromise = (async () => {
-      const includeRoot = await findFlatbuffersIncludeRoot();
-      return Object.fromEntries(
-        await readDirectoryTree(includeRoot, path.join(includeRoot, "flatbuffers")),
-      );
+      const flatc = await loadFlatcRunner();
+      return flatc.getEmbeddedRuntime("cpp");
     })();
   }
   return flatbuffersCppRuntimeHeadersPromise;

package/src/compliance/pluginCompliance.js

@@ -167,6 +167,134 @@ function normalizePayloadWireFormatName(value) {
   return null;
 }
 
+function normalizedPluginFamilyName(value) {
+  if (!isNonEmptyString(value)) {
+    return null;
+  }
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/-/g, "_");
+}
+
+function typeSetHasDualWireFormats(typeSet) {
+  if (!Array.isArray(typeSet?.allowedTypes) || typeSet.allowedTypes.length === 0) {
+    return false;
+  }
+  let hasFlatbuffer = false;
+  let hasAlignedBinary = false;
+  for (const allowedType of typeSet.allowedTypes) {
+    const wireFormat = normalizePayloadWireFormatName(allowedType?.wireFormat);
+    if (wireFormat === "flatbuffer") {
+      hasFlatbuffer = true;
+    } else if (wireFormat === "aligned-binary") {
+      hasAlignedBinary = true;
+    }
+  }
+  return hasFlatbuffer && hasAlignedBinary;
+}
+
+function validateCanonicalDualFormatPort(port, issues, location, methodId, portId) {
+  if (!port) {
+    pushIssue(
+      issues,
+      "error",
+      "propagator-missing-canonical-port",
+      `Canonical propagator method "${methodId}" must declare port "${portId}".`,
+      location,
+    );
+    return;
+  }
+  if (!Array.isArray(port.acceptedTypeSets) || port.acceptedTypeSets.length === 0) {
+    pushIssue(
+      issues,
+      "error",
+      "propagator-missing-canonical-port",
+      `Canonical propagator method "${methodId}" port "${portId}" must declare acceptedTypeSets.`,
+      `${location}.acceptedTypeSets`,
+    );
+    return;
+  }
+  port.acceptedTypeSets.forEach((typeSet, index) => {
+    if (!typeSetHasDualWireFormats(typeSet)) {
+      pushIssue(
+        issues,
+        "error",
+        "canonical-port-missing-dual-wire-format",
+        `Canonical propagator method "${methodId}" port "${portId}" acceptedTypeSet "${typeSet?.setId ?? index}" must accept both regular flatbuffer and aligned-binary payloads.`,
+        `${location}.acceptedTypeSets[${index}]`,
+      );
+    }
+  });
+}
+
+function validateCanonicalPropagatorContract(manifest, issues, sourceName) {
+  if (normalizedPluginFamilyName(manifest?.pluginFamily) !== "propagator") {
+    return;
+  }
+
+  const methods = Array.isArray(manifest?.methods) ? manifest.methods : [];
+  const methodRequirements = [
+    {
+      methodId: "ingest_omm",
+      inputPorts: ["omm"],
+      outputPorts: [],
+    },
+    {
+      methodId: "describe_sources_batch",
+      inputPorts: ["request"],
+      outputPorts: ["result"],
+    },
+    {
+      methodId: "propagate_state",
+      inputPorts: ["request"],
+      outputPorts: ["state"],
+    },
+  ];
+
+  for (const requirement of methodRequirements) {
+    const methodIndex = methods.findIndex(
+      (method) => method?.methodId === requirement.methodId,
+    );
+    if (methodIndex === -1) {
+      pushIssue(
+        issues,
+        "error",
+        "propagator-missing-canonical-method",
+        `Propagator plugins must declare canonical method "${requirement.methodId}".`,
+        `${sourceName}.methods`,
+      );
+      continue;
+    }
+    const method = methods[methodIndex];
+    const location = `${sourceName}.methods[${methodIndex}]`;
+    for (const portId of requirement.inputPorts) {
+      const port = Array.isArray(method.inputPorts)
+        ? method.inputPorts.find((entry) => entry?.portId === portId)
+        : null;
+      validateCanonicalDualFormatPort(
+        port,
+        issues,
+        `${location}.inputPorts`,
+        requirement.methodId,
+        portId,
+      );
+    }
+    for (const portId of requirement.outputPorts) {
+      const port = Array.isArray(method.outputPorts)
+        ? method.outputPorts.find((entry) => entry?.portId === portId)
+        : null;
+      validateCanonicalDualFormatPort(
+        port,
+        issues,
+        `${location}.outputPorts`,
+        requirement.methodId,
+        portId,
+      );
+    }
+  }
+}
+
 function validateStringField(issues, value, location, label) {
   if (!isNonEmptyString(value)) {
     pushIssue(issues, "error", "missing-string", `${label} must be a non-empty string.`, location);
@@ -1259,6 +1387,8 @@ export function validatePluginManifest(manifest, options = {}) {
       }
     });
 
+    validateCanonicalPropagatorContract(manifest, issues, sourceName);
+
     if (manifest.timers !== undefined && !Array.isArray(manifest.timers)) {
       pushIssue(
         issues,

package/src/index.d.ts

@@ -11,7 +11,7 @@ export type ProtocolRoleName = "handle" | "dial" | "both";
 
 export interface PayloadTypeRef {
   schemaName?: string;
-  fileIdentifier?: string;
+  fileIdentifier?: string | null;
   schemaHash?: string | number[] | Uint8Array;
   acceptsAnyFlatbuffer?: boolean;
   wireFormat?: PayloadWireFormat;
@@ -662,25 +662,12 @@ export type {
   HarnessInvokeScenario,
   HarnessRawScenario,
   ManifestHarnessPlan,
-  ModuleHarness,
-  ModuleHarnessRuntimeDescriptor,
-  PluginInvokeProcessClient,
-  PluginInvokeProcessLaunchPlan,
-  WasmEdgeRunnerBuildPlan,
 } from "./testing/index.js";
 
 export {
-  buildWasmEdgeEmscriptenPthreadRunner,
-  buildWasmEdgeSpawnEnv,
-  createModuleHarness,
-  createPluginInvokeProcessClient,
   describeCapabilityRuntimeSurface,
   generateManifestHarnessPlan,
   materializeHarnessScenario,
-  resolveModuleHarnessLaunchPlan,
-  resolveWasmEdgeRunnerBuildPlan,
-  resolveWasmEdgeRunnerSourcePath,
-  resolveWasmEdgePluginLaunchPlan,
   serializeHarnessPlan,
 } from "./testing/index.js";
 

package/src/invoke/codec.js

@@ -12,7 +12,7 @@ import { InvokeSurface } from "../generated/orbpro/manifest/invoke-surface.js";
 import { BufferMutability } from "../generated/orbpro/stream/buffer-mutability.js";
 import { BufferOwnership } from "../generated/orbpro/stream/buffer-ownership.js";
 import { FlatBufferTypeRefT } from "../generated/orbpro/stream/flat-buffer-type-ref.js";
-import { TypedArenaBufferT } from "../generated/orbpro/stream/typed-arena-buffer.js";
+import { TypedArenaBuffer, TypedArenaBufferT } from "../generated/orbpro/stream/typed-arena-buffer.js";
 import { toUint8Array } from "../runtime/bufferLike.js";
 
 function toByteBuffer(data) {
@@ -149,22 +149,20 @@ function normalizeArenaFrame(frame = {}, offset) {
 
 function packArenaFrames(frames = []) {
   const packedFrames = [];
-  const normalizedFrames = [];
+  const arena = [];
   let offset = 0;
   for (const frame of frames) {
     const normalized = normalizeArenaFrame(frame, offset);
+    for (let index = 0; index < normalized.padding; index += 1) {
+      arena.push(0);
+    }
+    arena.push(...normalized.payload);
     offset = normalized.buffer.offset + normalized.buffer.size;
     packedFrames.push(normalized.buffer);
-    normalizedFrames.push(normalized);
-  }
-
-  const arena = new Uint8Array(offset);
-  for (const normalized of normalizedFrames) {
-    arena.set(normalized.payload, normalized.buffer.offset);
   }
   return {
     frames: packedFrames,
-    arena,
+    arena: Uint8Array.from(arena),
   };
 }
 

package/src/testing/index.d.ts

@@ -57,69 +57,6 @@ export interface ManifestHarnessPlan {
   scenarios: Array<HarnessInvokeScenario | HarnessRawScenario>;
 }
 
-export interface PluginInvokeProcessLaunchPlan {
-  command: string;
-  args: string[];
-  env?: Record<string, string | undefined>;
-  cwd?: string;
-  wasmPath?: string;
-}
-
-export interface PluginInvokeProcessClient {
-  launchPlan: PluginInvokeProcessLaunchPlan;
-  invokeRaw(requestBytes: Uint8Array | ArrayBuffer | ArrayBufferView): Promise<Uint8Array>;
-  invoke(request: {
-    methodId?: string | null;
-    inputs?: HarnessInputFrame[];
-  }): Promise<{
-    statusCode: number;
-    errorCode?: string | null;
-    errorMessage?: string | null;
-    outputs: HarnessInputFrame[];
-  }>;
-  destroy(): Promise<void>;
-}
-
-export interface ModuleHarnessRuntimeDescriptor {
-  kind?: "process" | "wasmedge";
-  launchPlan?: PluginInvokeProcessLaunchPlan;
-  command?: string;
-  args?: string[];
-  env?: Record<string, string | undefined>;
-  cwd?: string;
-  wasmPath?: string;
-  wasmEdgeBinary?: string;
-  wasmEdgeRunnerBinary?: string;
-  enableThreads?: boolean;
-}
-
-export interface ModuleHarness {
-  runtime: ModuleHarnessRuntimeDescriptor & { kind: "process" | "wasmedge" };
-  launchPlan: PluginInvokeProcessLaunchPlan;
-  invokeRaw(requestBytes: Uint8Array | ArrayBuffer | ArrayBufferView): Promise<Uint8Array>;
-  invoke(request: {
-    methodId?: string | null;
-    inputs?: HarnessInputFrame[];
-  }): Promise<{
-    statusCode: number;
-    errorCode?: string | null;
-    errorMessage?: string | null;
-    outputs: HarnessInputFrame[];
-  }>;
-  destroy(): Promise<void>;
-}
-
-export interface WasmEdgeRunnerBuildPlan {
-  runnerSourcePath: string;
-  requestedIncludeDir: string;
-  wasmedgeIncludeDir: string;
-  wasmedgeLibDir: string;
-  wasmedgeSharedLibraryPath: string;
-  outputPath: string;
-  compilerCommand: string;
-  compilerArgs: string[];
-}
-
 export function describeCapabilityRuntimeSurface(
   capability: string,
 ): CapabilityRuntimeSurface;
@@ -147,49 +84,3 @@ export function materializeHarnessScenario(
 };
 
 export function serializeHarnessPlan(plan: ManifestHarnessPlan): unknown;
-
-export function buildWasmEdgeSpawnEnv(
-  baseEnv?: Record<string, string | undefined>,
-): Record<string, string | undefined>;
-
-export function resolveWasmEdgePluginLaunchPlan(options: {
-  wasmPath: string;
-  wasmEdgeBinary?: string;
-  wasmEdgeRunnerBinary?: string;
-  enableThreads?: boolean;
-  invokeArgs?: string[];
-  env?: Record<string, string | undefined>;
-}): PluginInvokeProcessLaunchPlan;
-
-export function createPluginInvokeProcessClient(options: {
-  launchPlan?: PluginInvokeProcessLaunchPlan;
-  command?: string;
-  args?: string[];
-  env?: Record<string, string | undefined>;
-  cwd?: string;
-}): Promise<PluginInvokeProcessClient>;
-
-export function resolveModuleHarnessLaunchPlan(options: {
-  runtime?: ModuleHarnessRuntimeDescriptor;
-} | ModuleHarnessRuntimeDescriptor): PluginInvokeProcessLaunchPlan;
-
-export function createModuleHarness(options: {
-  runtime?: ModuleHarnessRuntimeDescriptor;
-} | ModuleHarnessRuntimeDescriptor): Promise<ModuleHarness>;
-
-export function resolveWasmEdgeRunnerSourcePath(): string;
-
-export function resolveWasmEdgeRunnerBuildPlan(options: {
-  outputPath: string;
-  wasmedgeIncludeDir?: string;
-  wasmedgeLibDir?: string;
-  output?: string;
-}): WasmEdgeRunnerBuildPlan;
-
-export function buildWasmEdgeEmscriptenPthreadRunner(options: {
-  outputPath: string;
-  wasmedgeIncludeDir?: string;
-  wasmedgeLibDir?: string;
-  output?: string;
-  cwd?: string;
-}): Promise<string>;

package/src/testing/index.js

@@ -1,22 +1,6 @@
-import { Buffer } from "node:buffer";
-
 import { encodePluginInvokeRequest } from "../invoke/codec.js";
 import { normalizeInvokeSurfaces } from "../invoke/index.js";
 import { selectPreferredPayloadTypeRef } from "../manifest/typeRefs.js";
-export {
-  buildWasmEdgeSpawnEnv,
-  createPluginInvokeProcessClient,
-  resolveWasmEdgePluginLaunchPlan,
-} from "./processInvoke.js";
-export {
-  buildWasmEdgeEmscriptenPthreadRunner,
-  resolveWasmEdgeRunnerBuildPlan,
-  resolveWasmEdgeRunnerSourcePath,
-} from "./buildWasmEdgeRunner.js";
-export {
-  createModuleHarness,
-  resolveModuleHarnessLaunchPlan,
-} from "./moduleHarness.js";
 
 const CapabilitySurfaceMatrix = Object.freeze({
   logging: Object.freeze({

package/src/transport/records.js

@@ -277,27 +277,7 @@ function validateEncTable(table, buffer, label) {
     maxLength: 32,
   });
   assertOptionalStringField(buffer, tableMeta, 22, `${label} root type`);
-  const timestamp = table.TIMESTAMP();
-  const record = {
-    version: Number(table.VERSION()),
-    keyExchange:
-      KEY_EXCHANGE_NAME_BY_VALUE[table.KEY_EXCHANGE()] ??
-      String(table.KEY_EXCHANGE()),
-    symmetric:
-      SYMMETRIC_ALGO_NAME_BY_VALUE[table.SYMMETRIC()] ??
-      String(table.SYMMETRIC()),
-    keyDerivation:
-      KDF_NAME_BY_VALUE[table.KEY_DERIVATION()] ??
-      String(table.KEY_DERIVATION()),
-    ephemeralPublicKey: normalizeByteField(table.ephemeralPublicKeyArray()),
-    nonceStart: normalizeByteField(table.nonceStartArray()),
-    recipientKeyId: normalizeByteField(table.recipientKeyIdArray()),
-    context: normalizeStringField(table.CONTEXT()),
-    schemaHash: normalizeByteField(table.schemaHashArray()),
-    rootType: normalizeStringField(table.ROOT_TYPE()),
-    timestamp:
-      timestamp === undefined || timestamp === null ? 0 : Number(timestamp),
-  };
+  const record = normalizeEncTable(table.unpack());
   if (!record.ephemeralPublicKey?.length) {
     throw new Error(`${label} is missing the ephemeral public key.`);
   }
@@ -336,17 +316,7 @@ function validatePnmTable(table, buffer, label) {
   assertOptionalStringField(buffer, tableMeta, 16, `${label} timestamp signature`);
   assertOptionalStringField(buffer, tableMeta, 18, `${label} signature type`);
   assertOptionalStringField(buffer, tableMeta, 20, `${label} timestamp signature type`);
-  const record = {
-    multiformatAddress: normalizeStringField(table.MULTIFORMAT_ADDRESS()),
-    publishTimestamp: normalizeStringField(table.PUBLISH_TIMESTAMP()),
-    cid: normalizeStringField(table.CID()),
-    fileName: normalizeStringField(table.FILE_NAME()),
-    fileId: normalizeStringField(table.FILE_ID()),
-    signature: normalizeStringField(table.SIGNATURE()),
-    timestampSignature: normalizeStringField(table.TIMESTAMP_SIGNATURE()),
-    signatureType: normalizeStringField(table.SIGNATURE_TYPE()),
-    timestampSignatureType: normalizeStringField(table.TIMESTAMP_SIGNATURE_TYPE()),
-  };
+  const record = normalizePnmTable(table.unpack());
   if (
     !record.multiformatAddress &&
     !record.publishTimestamp &&
@@ -456,6 +426,48 @@ function pnmTableFromObject(record = {}) {
   );
 }
 
+function normalizeEncTable(table) {
+  if (!table) {
+    return null;
+  }
+  return {
+    version: Number(table.VERSION ?? 1),
+    keyExchange:
+      KEY_EXCHANGE_NAME_BY_VALUE[table.KEY_EXCHANGE] ?? String(table.KEY_EXCHANGE),
+    symmetric:
+      SYMMETRIC_ALGO_NAME_BY_VALUE[table.SYMMETRIC] ?? String(table.SYMMETRIC),
+    keyDerivation:
+      KDF_NAME_BY_VALUE[table.KEY_DERIVATION] ?? String(table.KEY_DERIVATION),
+    ephemeralPublicKey: normalizeByteField(table.EPHEMERAL_PUBLIC_KEY),
+    nonceStart: normalizeByteField(table.NONCE_START),
+    recipientKeyId: normalizeByteField(table.RECIPIENT_KEY_ID),
+    context: normalizeStringField(table.CONTEXT),
+    schemaHash: normalizeByteField(table.SCHEMA_HASH),
+    rootType: normalizeStringField(table.ROOT_TYPE),
+    timestamp:
+      table.TIMESTAMP === undefined || table.TIMESTAMP === null
+        ? 0
+        : Number(table.TIMESTAMP),
+  };
+}
+
+function normalizePnmTable(table) {
+  if (!table) {
+    return null;
+  }
+  return {
+    multiformatAddress: normalizeStringField(table.MULTIFORMAT_ADDRESS),
+    publishTimestamp: normalizeStringField(table.PUBLISH_TIMESTAMP),
+    cid: normalizeStringField(table.CID),
+    fileName: normalizeStringField(table.FILE_NAME),
+    fileId: normalizeStringField(table.FILE_ID),
+    signature: normalizeStringField(table.SIGNATURE),
+    timestampSignature: normalizeStringField(table.TIMESTAMP_SIGNATURE),
+    signatureType: normalizeStringField(table.SIGNATURE_TYPE),
+    timestampSignatureType: normalizeStringField(table.TIMESTAMP_SIGNATURE_TYPE),
+  };
+}
+
 function readFooterLength(bytes) {
   const view = toUint8Array(bytes);
   if (view.length < TRAILER_FOOTER_LENGTH) {
@@ -589,6 +601,7 @@ export function decodePublicationRecordCollection(bytes) {
   if (recordTables.length === 0) {
     throw new Error("REC trailer does not contain any records.");
   }
+  const collection = collectionTable.unpack();
   const records = [];
   let enc = null;
   let pnm = null;
@@ -609,18 +622,10 @@ export function decodePublicationRecordCollection(bytes) {
       8,
       `REC trailer record ${index} standard`,
     );
-    const recordType =
-      typeof recordTable.valueType === "function"
-        ? recordTable.valueType()
-        : typeof recordTable.value_type === "function"
-          ? recordTable.value_type()
-          : (() => {
-              throw new TypeError(
-                "REC Record wrapper is missing both valueType() and value_type() accessors.",
-              );
-            })();
+    const unpackedRecord = collection.RECORDS[index];
+    const recordType = recordTable.value_type();
     const standard =
-      normalizeStringField(recordTable.standard()) ??
+      normalizeStringField(unpackedRecord?.standard) ??
       STANDARD_BY_RECORD_TYPE[recordType] ??
       null;
     const expectedStandard =
@@ -639,7 +644,10 @@ export function decodePublicationRecordCollection(bytes) {
     if (!valueMeta) {
       throw new Error(`REC trailer record ${index} is missing a value.`);
     }
-    let value = null;
+    let value =
+      standard === "ENC" || standard === "PNM"
+        ? null
+        : unpackedRecord?.value ?? null;
     if (standard === "ENC") {
       const encTable = recordTable.value(new ENC());
       if (!encTable) {
@@ -676,9 +684,7 @@ export function decodePublicationRecordCollection(bytes) {
     });
   }
   return {
-    version:
-      normalizeStringField(collectionTable.version()) ??
-      DEFAULT_RECORD_COLLECTION_VERSION,
+    version: normalizeStringField(collection.version) ?? DEFAULT_RECORD_COLLECTION_VERSION,
     records,
     enc,
     pnm,