space-data-module-sdk 0.5.9 → 0.5.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "space-data-module-sdk",
-  "version": "0.5.9",
+  "version": "0.5.13",
   "description": "Module SDK for building, validating, signing, and deploying WebAssembly modules on the Space Data Network.",
   "type": "module",
   "types": "./src/index.d.ts",
@@ -40,6 +40,9 @@
     "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 } from "node:fs/promises";
+import { readFile, readdir, stat } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 
 import { FlatcRunner } from "flatc-wasm";
@@ -18,6 +18,48 @@ 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",
@@ -36,8 +78,10 @@ async function loadInvokeSchemaFiles() {
 export async function getFlatbuffersCppRuntimeHeaders() {
   if (!flatbuffersCppRuntimeHeadersPromise) {
     flatbuffersCppRuntimeHeadersPromise = (async () => {
-      const flatc = await loadFlatcRunner();
-      return flatc.getEmbeddedRuntime("cpp");
+      const includeRoot = await findFlatbuffersIncludeRoot();
+      return Object.fromEntries(
+        await readDirectoryTree(includeRoot, path.join(includeRoot, "flatbuffers")),
+      );
     })();
   }
   return flatbuffersCppRuntimeHeadersPromise;

package/src/compliance/pluginCompliance.js

@@ -366,7 +366,7 @@ function validateAllowedType(type, issues, location) {
       "Allowed type fixedStringLength",
       { min: 0 },
     );
-    validateIntegerField(
+    validateOptionalIntegerField(
       issues,
       type.byteLength,
       `${location}.byteLength`,

package/src/manifest/typeRefs.js

@@ -1,31 +1,62 @@
 function cloneSchemaHash(value) {
   if (value instanceof Uint8Array) {
-    return new Uint8Array(value);
+    return value.byteLength > 0 ? new Uint8Array(value) : undefined;
   }
   if (Array.isArray(value)) {
-    return [...value];
+    return value.length > 0 ? [...value] : undefined;
   }
   return value ?? undefined;
 }
 
+function normalizeNullableString(value) {
+  if (value === undefined || value === null) {
+    return null;
+  }
+  const normalized = String(value).trim();
+  return normalized.length > 0 ? normalized : null;
+}
+
+function normalizeAlignedMetadataScalar(value) {
+  if (value === undefined || value === null || value === "") {
+    return undefined;
+  }
+  const numeric = Number(value);
+  if (Number.isFinite(numeric)) {
+    return numeric === 0 ? undefined : numeric;
+  }
+  return value;
+}
+
 export function clonePayloadTypeRef(value = null) {
   if (!value || typeof value !== "object") {
-    return { acceptsAnyFlatbuffer: true };
+    return { acceptsAnyFlatbuffer: true, fileIdentifier: null };
   }
   return {
-    schemaName: value.schemaName ?? value.schema_name ?? undefined,
-    fileIdentifier: value.fileIdentifier ?? value.file_identifier ?? undefined,
+    schemaName: normalizeNullableString(
+      value.schemaName ?? value.schema_name,
+    ),
+    fileIdentifier: normalizeNullableString(
+      value.fileIdentifier ?? value.file_identifier,
+    ),
     schemaHash: cloneSchemaHash(value.schemaHash ?? value.schema_hash),
     acceptsAnyFlatbuffer: Boolean(
       value.acceptsAnyFlatbuffer ?? value.accepts_any_flatbuffer ?? false,
     ),
-    wireFormat: value.wireFormat ?? value.wire_format ?? undefined,
-    rootTypeName: value.rootTypeName ?? value.root_type_name ?? undefined,
-    fixedStringLength:
-      value.fixedStringLength ?? value.fixed_string_length ?? undefined,
-    byteLength: value.byteLength ?? value.byte_length ?? undefined,
-    requiredAlignment:
-      value.requiredAlignment ?? value.required_alignment ?? undefined,
+    wireFormat: normalizePayloadWireFormatName(
+      value.wireFormat ?? value.wire_format,
+    ),
+    rootTypeName: normalizeNullableString(
+      value.rootTypeName ?? value.root_type_name,
+    ),
+    fixedStringLength: normalizeAlignedMetadataScalar(
+      value.fixedStringLength ?? value.fixed_string_length,
+    ),
+    byteLength: normalizeAlignedMetadataScalar(
+      value.byteLength ?? value.byte_length,
+    ),
+    requiredAlignment: normalizeAlignedMetadataScalar(
+      value.requiredAlignment ?? value.required_alignment,
+    ),
   };
 }
 
@@ -33,6 +64,12 @@ export function normalizePayloadWireFormatName(value) {
   if (value === undefined || value === null || value === "") {
     return null;
   }
+  if (value === 1 || value === "1") {
+    return "aligned-binary";
+  }
+  if (value === 0 || value === "0") {
+    return "flatbuffer";
+  }
   const normalized = String(value).trim().toLowerCase().replace(/_/g, "-");
   if (normalized === "aligned-binary") {
     return "aligned-binary";

package/src/transport/records.js

@@ -277,7 +277,27 @@ function validateEncTable(table, buffer, label) {
     maxLength: 32,
   });
   assertOptionalStringField(buffer, tableMeta, 22, `${label} root type`);
-  const record = normalizeEncTable(table.unpack());
+  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),
+  };
   if (!record.ephemeralPublicKey?.length) {
     throw new Error(`${label} is missing the ephemeral public key.`);
   }
@@ -316,7 +336,17 @@ 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 = normalizePnmTable(table.unpack());
+  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()),
+  };
   if (
     !record.multiformatAddress &&
     !record.publishTimestamp &&
@@ -426,48 +456,6 @@ 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) {
@@ -601,7 +589,6 @@ 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;
@@ -622,10 +609,18 @@ export function decodePublicationRecordCollection(bytes) {
       8,
       `REC trailer record ${index} standard`,
     );
-    const unpackedRecord = collection.RECORDS[index];
-    const recordType = recordTable.value_type();
+    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 standard =
-      normalizeStringField(unpackedRecord?.standard) ??
+      normalizeStringField(recordTable.standard()) ??
       STANDARD_BY_RECORD_TYPE[recordType] ??
       null;
     const expectedStandard =
@@ -644,10 +639,7 @@ export function decodePublicationRecordCollection(bytes) {
     if (!valueMeta) {
       throw new Error(`REC trailer record ${index} is missing a value.`);
     }
-    let value =
-      standard === "ENC" || standard === "PNM"
-        ? null
-        : unpackedRecord?.value ?? null;
+    let value = null;
     if (standard === "ENC") {
       const encTable = recordTable.value(new ENC());
       if (!encTable) {
@@ -684,7 +676,9 @@ export function decodePublicationRecordCollection(bytes) {
     });
   }
   return {
-    version: normalizeStringField(collection.version) ?? DEFAULT_RECORD_COLLECTION_VERSION,
+    version:
+      normalizeStringField(collectionTable.version()) ??
+      DEFAULT_RECORD_COLLECTION_VERSION,
     records,
     enc,
     pnm,