space-data-module-sdk 0.8.7 → 0.8.8

package/src/standards/catalogCore.js

@@ -0,0 +1,290 @@
+/**
+ * Standards catalog — the runtime-independent half.
+ *
+ * Parsing, freshness validation, type-ref resolution and manifest checking are
+ * identical everywhere. Only HOW the `spacedatastandards.org` manifest is
+ * OBTAINED differs: Node reads it off disk (`./index.js`), a browser is handed
+ * it or fetches it (`./browser.js`). The package's `browser` export condition
+ * picks the leg, so a browser bundle never statically resolves
+ * node:fs/promises, node:path or node:module
+ * (`module-sdk-browser-entry-node-builtins`).
+ */
+
+import { sharedModuleCatalog } from "./sharedCatalog.js";
+import { normalizePayloadSchemaHash } from "../manifest/typeRefs.js";
+const requiredCurrentScvTokens = Object.freeze([
+  "SENSOR_LOCAL",
+  "table SCVResult",
+  "table SCVSensorShapeContract",
+  "SAR_ANNULAR_SECTOR",
+  "enum scvSensorRangeBoundaryKind",
+  "table SCVAggregateStatistics",
+  "AGGREGATE_STATISTICS:SCVAggregateStatistics",
+  "table SCVPackedRasterProducts",
+  "table SCVPackedRasterBand",
+  "RASTER_PRODUCTS:SCVPackedRasterProducts",
+  "enum scvRasterProductKind",
+]);
+const currentScvResultFields = Object.freeze(
+  new Set([
+    "JOB_ID",
+    "TRACE_ID",
+    "STATUS",
+    "TIME_GRID",
+    "TARGET_BODY",
+    "TOTAL_SENSORS",
+    "TOTAL_WINDOWS",
+    "CELL_STATS",
+    "INTERVALS",
+    "LATITUDE_BANDS",
+    "TIME_SERIES",
+    "HISTOGRAMS",
+    "CONTRIBUTIONS",
+    "GEOMETRY",
+    "RASTER_PRODUCTS",
+    "MESSAGE",
+    "AGGREGATE_STATISTICS",
+    "TARGET_RESULTS",
+  ]),
+);
+
+function collectFlatbufferTableFields(idl, tableName) {
+  const match = String(idl ?? "").match(
+    new RegExp(`\\btable\\s+${tableName}\\s*\\{([\\s\\S]*?)\\n\\}`, "m"),
+  );
+  if (!match) {
+    return [];
+  }
+  return match[1]
+    .split("\n")
+    .map((line) => line.replace(/\/\/.*$/, "").trim())
+    .map((line) => line.match(/^([A-Z0-9_]+)\s*:/)?.[1] ?? null)
+    .filter(Boolean);
+}
+
+function normalizeSchemaName(value) {
+  return value === undefined || value === null ? "" : String(value);
+}
+
+function normalizeFileIdentifier(value) {
+  return value === undefined || value === null ? "" : String(value);
+}
+
+function parseStandardsEntry([schemaCode, entry]) {
+  const idl = String(entry?.IDL ?? "");
+  const fileIdentifierMatch = idl.match(/file_identifier\s+"([^"]+)"/i);
+  const hashMatch = idl.match(/\/\/ Hash:\s*([a-f0-9]+)/i);
+  const versionMatch = idl.match(/\/\/ Version:\s*([^\n]+)/i);
+  const rootTypeMatch = idl.match(/root_type\s+([A-Za-z_][A-Za-z0-9_.]*)\s*;/i);
+  return {
+    schemaCode: schemaCode.toUpperCase(),
+    schemaName: `${schemaCode.toUpperCase()}.fbs`,
+    fileIdentifier: fileIdentifierMatch
+      ? normalizeFileIdentifier(fileIdentifierMatch[1])
+      : null,
+    hash: hashMatch ? hashMatch[1].toLowerCase() : null,
+    rootTypeName: rootTypeMatch ? rootTypeMatch[1] : null,
+    idl,
+    version: versionMatch ? versionMatch[1].trim() : null,
+    files: Array.isArray(entry?.files) ? entry.files : [],
+  };
+}
+
+function validateStandardsCatalogFreshness(catalog, sourceName) {
+  const issues = [];
+  const scvEntry = catalog.find((entry) => entry.schemaCode === "SCV");
+  if (!scvEntry) {
+    return issues;
+  }
+  const missingTokens = requiredCurrentScvTokens.filter(
+    (token) => !scvEntry.idl.includes(token),
+  );
+  if (missingTokens.length > 0) {
+    issues.push({
+      severity: "error",
+      code: "stale-scv-contract",
+      message:
+        "The loaded spacedatastandards.org SCV catalog is stale and does not " +
+        `include required current coverage fields: ${missingTokens.join(", ")}.`,
+      location: `${sourceName}.standards.SCV`,
+    });
+  }
+  const unsupportedResultFields = collectFlatbufferTableFields(
+    scvEntry.idl,
+    "SCVResult",
+  ).filter((field) => !currentScvResultFields.has(field));
+  if (unsupportedResultFields.length > 0) {
+    issues.push({
+      severity: "error",
+      code: "stale-scv-contract",
+      message:
+        "The loaded spacedatastandards.org SCV catalog contains unsupported " +
+        `SCVResult fields that are not part of the current contract: ${unsupportedResultFields.join(", ")}.`,
+      location: `${sourceName}.standards.SCV`,
+    });
+  }
+  return issues;
+}
+
+/**
+ * Build the standards catalog from an already-parsed manifest object. Same
+ * bytes in, same catalog out, in every runtime.
+ *
+ * @param {object} manifest - the parsed `spacedatastandards.org` manifest.json
+ * @returns {Array} sorted standards catalog
+ */
+export function buildStandardsCatalog(manifest) {
+  return Object.entries(manifest?.STANDARDS ?? {})
+    .map(parseStandardsEntry)
+    .sort((left, right) => left.schemaCode.localeCompare(right.schemaCode));
+}
+
+/**
+ * Append the SDK's own shared-module catalog to a standards catalog.
+ *
+ * @param {Array} catalog
+ * @returns {Array}
+ */
+export function withSharedModuleCatalog(catalog) {
+  return [...catalog, ...sharedModuleCatalog];
+}
+
+export function resolveStandardsTypeRef(typeRef, catalog = []) {
+  const schemaName = normalizeSchemaName(typeRef?.schemaName);
+  const fileIdentifier = normalizeFileIdentifier(typeRef?.fileIdentifier);
+  if (!schemaName && !fileIdentifier) {
+    return null;
+  }
+  return (
+    catalog.find(
+      (entry) =>
+        (!schemaName || normalizeSchemaName(entry.schemaName) === schemaName) &&
+        (!fileIdentifier ||
+          normalizeFileIdentifier(entry.fileIdentifier) === fileIdentifier),
+    ) ?? null
+  );
+}
+
+function schemaHashMatchesCatalog(typeRefHash, catalogHash) {
+  if (typeRefHash === undefined || typeRefHash === null) return true;
+  const declared = normalizePayloadSchemaHash(typeRefHash);
+  if (!declared) return true;
+  const canonical = normalizePayloadSchemaHash(catalogHash);
+  if (!canonical || declared.length !== canonical.length) {
+    return false;
+  }
+  return declared.every((byte, index) => byte === canonical[index]);
+}
+
+function collectTypeRefs(manifest) {
+  const refs = [];
+  for (const method of Array.isArray(manifest?.methods) ? manifest.methods : []) {
+    for (const portsKey of ["inputPorts", "outputPorts"]) {
+      for (const port of Array.isArray(method?.[portsKey]) ? method[portsKey] : []) {
+        for (const typeSet of Array.isArray(port?.acceptedTypeSets)
+          ? port.acceptedTypeSets
+          : []) {
+          for (const allowedType of Array.isArray(typeSet?.allowedTypes)
+            ? typeSet.allowedTypes
+            : []) {
+            refs.push({
+              source: `${method?.methodId ?? "method"}.${port?.portId ?? "port"}`,
+              typeRef: allowedType,
+            });
+          }
+        }
+      }
+    }
+  }
+  for (const typeRef of Array.isArray(manifest?.schemasUsed)
+    ? manifest.schemasUsed
+    : []) {
+    refs.push({
+      source: "schemasUsed",
+      typeRef,
+    });
+  }
+  return refs;
+}
+
+/**
+ * Validate a module manifest against an ALREADY-RESOLVED catalog.
+ *
+ * Both legs of `./standards` funnel into this, so the verdicts cannot diverge
+ * between runtimes; only catalog acquisition differs.
+ *
+ * @param {Array} catalog
+ * @param {object} manifest
+ * @param {object} [options]
+ * @returns {{catalog: Array, issues: Array}}
+ */
+export function validateManifestAgainstCatalog(catalog, manifest, options = {}) {
+  const sourceName = options.sourceName ?? "manifest";
+  const issues = validateStandardsCatalogFreshness(catalog, sourceName);
+  for (const { source, typeRef } of collectTypeRefs(manifest)) {
+    if (typeRef?.acceptsAnyFlatbuffer === true) {
+      continue;
+    }
+    const resolved = resolveStandardsTypeRef(typeRef, catalog);
+    if (!resolved) {
+      const schemaName = normalizeSchemaName(typeRef?.schemaName);
+      const fileIdentifier = normalizeFileIdentifier(typeRef?.fileIdentifier);
+      const partiallyKnown = catalog.some(
+        (entry) =>
+          (schemaName && normalizeSchemaName(entry.schemaName) === schemaName) ||
+          (fileIdentifier &&
+            normalizeFileIdentifier(entry.fileIdentifier) === fileIdentifier),
+      );
+      issues.push({
+        severity: "error",
+        code: partiallyKnown
+          ? "standards-type-identity-mismatch"
+          : "unresolved-standards-type",
+        message: partiallyKnown
+          ? `Type reference from ${source} mixes a known schemaName or exact four-byte fileIdentifier with a different standards entry.`
+          : `Type reference from ${source} does not resolve to a known shared-module or \`spacedatastandards.org\` schema by its exact schemaName and fileIdentifier.`,
+        location: `${sourceName}.${source}`,
+      });
+      continue;
+    }
+    if (
+      typeRef?.rootTypeName &&
+      resolved.rootTypeName &&
+      typeRef.rootTypeName !== resolved.rootTypeName
+    ) {
+      issues.push({
+        severity: "error",
+        code: "standards-root-type-mismatch",
+        message: `Type reference from ${source} declares rootTypeName ${JSON.stringify(typeRef.rootTypeName)} but the canonical SDS root is ${JSON.stringify(resolved.rootTypeName)}.`,
+        location: `${sourceName}.${source}`,
+      });
+    }
+    if (
+      typeRef?.schemaVersion &&
+      resolved.version &&
+      typeRef.schemaVersion !== resolved.version
+    ) {
+      issues.push({
+        severity: "error",
+        code: "standards-schema-version-mismatch",
+        message: `Type reference from ${source} declares schemaVersion ${JSON.stringify(typeRef.schemaVersion)} but the canonical SDS version is ${JSON.stringify(resolved.version)}.`,
+        location: `${sourceName}.${source}`,
+      });
+    }
+    if (
+      resolved.hash &&
+      !schemaHashMatchesCatalog(typeRef?.schemaHash, resolved.hash)
+    ) {
+      issues.push({
+        severity: "error",
+        code: "standards-schema-hash-mismatch",
+        message: `Type reference from ${source} declares a schemaHash that differs from the canonical SDS schema hash.`,
+        location: `${sourceName}.${source}`,
+      });
+    }
+  }
+  return {
+    catalog,
+    issues,
+  };
+}

package/src/standards/index.js

@@ -1,62 +1,32 @@
+/**
+ * Standards catalog — NODE leg (the `default` condition of `./standards`).
+ *
+ * Reads the pinned `spacedatastandards.org` manifest off disk. Everything the
+ * catalog is then USED for lives in `catalogCore.js` and is shared with the
+ * browser leg, so a manifest validated here and a manifest validated in a
+ * browser produce the same issues in the same order.
+ */
+
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { createRequire } from "node:module";
 
-import { sharedModuleCatalog } from "./sharedCatalog.js";
-import { normalizePayloadSchemaHash } from "../manifest/typeRefs.js";
+import {
+  buildStandardsCatalog,
+  validateManifestAgainstCatalog,
+  withSharedModuleCatalog,
+} from "./catalogCore.js";
+
+export {
+  buildStandardsCatalog,
+  resolveStandardsTypeRef,
+  validateManifestAgainstCatalog,
+  withSharedModuleCatalog,
+} from "./catalogCore.js";
 
 const require = createRequire(import.meta.url);
 const standardsCatalogPromises = new Map();
 const knownTypeCatalogPromises = new Map();
-const requiredCurrentScvTokens = Object.freeze([
-  "SENSOR_LOCAL",
-  "table SCVResult",
-  "table SCVSensorShapeContract",
-  "SAR_ANNULAR_SECTOR",
-  "enum scvSensorRangeBoundaryKind",
-  "table SCVAggregateStatistics",
-  "AGGREGATE_STATISTICS:SCVAggregateStatistics",
-  "table SCVPackedRasterProducts",
-  "table SCVPackedRasterBand",
-  "RASTER_PRODUCTS:SCVPackedRasterProducts",
-  "enum scvRasterProductKind",
-]);
-const currentScvResultFields = Object.freeze(
-  new Set([
-    "JOB_ID",
-    "TRACE_ID",
-    "STATUS",
-    "TIME_GRID",
-    "TARGET_BODY",
-    "TOTAL_SENSORS",
-    "TOTAL_WINDOWS",
-    "CELL_STATS",
-    "INTERVALS",
-    "LATITUDE_BANDS",
-    "TIME_SERIES",
-    "HISTOGRAMS",
-    "CONTRIBUTIONS",
-    "GEOMETRY",
-    "RASTER_PRODUCTS",
-    "MESSAGE",
-    "AGGREGATE_STATISTICS",
-    "TARGET_RESULTS",
-  ]),
-);
-
-function collectFlatbufferTableFields(idl, tableName) {
-  const match = String(idl ?? "").match(
-    new RegExp(`\\btable\\s+${tableName}\\s*\\{([\\s\\S]*?)\\n\\}`, "m"),
-  );
-  if (!match) {
-    return [];
-  }
-  return match[1]
-    .split("\n")
-    .map((line) => line.replace(/\/\/.*$/, "").trim())
-    .map((line) => line.match(/^([A-Z0-9_]+)\s*:/)?.[1] ?? null)
-    .filter(Boolean);
-}
 
 function resolveStandardsManifestPath(options = {}) {
   const standardsRoot =
@@ -69,81 +39,15 @@ function resolveStandardsManifestPath(options = {}) {
   return path.join(path.dirname(packageEntry), "dist", "manifest.json");
 }
 
-function normalizeSchemaName(value) {
-  return value === undefined || value === null ? "" : String(value);
-}
-
-function normalizeFileIdentifier(value) {
-  return value === undefined || value === null ? "" : String(value);
-}
-
-function parseStandardsEntry([schemaCode, entry]) {
-  const idl = String(entry?.IDL ?? "");
-  const fileIdentifierMatch = idl.match(/file_identifier\s+"([^"]+)"/i);
-  const hashMatch = idl.match(/\/\/ Hash:\s*([a-f0-9]+)/i);
-  const versionMatch = idl.match(/\/\/ Version:\s*([^\n]+)/i);
-  const rootTypeMatch = idl.match(/root_type\s+([A-Za-z_][A-Za-z0-9_.]*)\s*;/i);
-  return {
-    schemaCode: schemaCode.toUpperCase(),
-    schemaName: `${schemaCode.toUpperCase()}.fbs`,
-    fileIdentifier: fileIdentifierMatch
-      ? normalizeFileIdentifier(fileIdentifierMatch[1])
-      : null,
-    hash: hashMatch ? hashMatch[1].toLowerCase() : null,
-    rootTypeName: rootTypeMatch ? rootTypeMatch[1] : null,
-    idl,
-    version: versionMatch ? versionMatch[1].trim() : null,
-    files: Array.isArray(entry?.files) ? entry.files : [],
-  };
-}
-
-function validateStandardsCatalogFreshness(catalog, sourceName) {
-  const issues = [];
-  const scvEntry = catalog.find((entry) => entry.schemaCode === "SCV");
-  if (!scvEntry) {
-    return issues;
-  }
-  const missingTokens = requiredCurrentScvTokens.filter(
-    (token) => !scvEntry.idl.includes(token),
-  );
-  if (missingTokens.length > 0) {
-    issues.push({
-      severity: "error",
-      code: "stale-scv-contract",
-      message:
-        "The loaded spacedatastandards.org SCV catalog is stale and does not " +
-        `include required current coverage fields: ${missingTokens.join(", ")}.`,
-      location: `${sourceName}.standards.SCV`,
-    });
-  }
-  const unsupportedResultFields = collectFlatbufferTableFields(
-    scvEntry.idl,
-    "SCVResult",
-  ).filter((field) => !currentScvResultFields.has(field));
-  if (unsupportedResultFields.length > 0) {
-    issues.push({
-      severity: "error",
-      code: "stale-scv-contract",
-      message:
-        "The loaded spacedatastandards.org SCV catalog contains unsupported " +
-        `SCVResult fields that are not part of the current contract: ${unsupportedResultFields.join(", ")}.`,
-      location: `${sourceName}.standards.SCV`,
-    });
-  }
-  return issues;
-}
-
 export async function loadStandardsCatalog(options = {}) {
   const manifestPath = resolveStandardsManifestPath(options);
   if (!standardsCatalogPromises.has(manifestPath)) {
     standardsCatalogPromises.set(
       manifestPath,
-      (async () => {
-        const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
-        return Object.entries(manifest?.STANDARDS ?? {})
-          .map(parseStandardsEntry)
-          .sort((left, right) => left.schemaCode.localeCompare(right.schemaCode));
-      })(),
+      (async () =>
+        buildStandardsCatalog(
+          JSON.parse(await readFile(manifestPath, "utf8")),
+        ))(),
     );
   }
   return standardsCatalogPromises.get(manifestPath);
@@ -154,144 +58,16 @@ export async function loadKnownTypeCatalog(options = {}) {
   if (!knownTypeCatalogPromises.has(manifestPath)) {
     knownTypeCatalogPromises.set(
       manifestPath,
-      loadStandardsCatalog(options).then((catalog) => [
-        ...catalog,
-        ...sharedModuleCatalog,
-      ]),
+      loadStandardsCatalog(options).then(withSharedModuleCatalog),
     );
   }
   return knownTypeCatalogPromises.get(manifestPath);
 }
 
-export function resolveStandardsTypeRef(typeRef, catalog = []) {
-  const schemaName = normalizeSchemaName(typeRef?.schemaName);
-  const fileIdentifier = normalizeFileIdentifier(typeRef?.fileIdentifier);
-  if (!schemaName && !fileIdentifier) {
-    return null;
-  }
-  return (
-    catalog.find(
-      (entry) =>
-        (!schemaName || normalizeSchemaName(entry.schemaName) === schemaName) &&
-        (!fileIdentifier ||
-          normalizeFileIdentifier(entry.fileIdentifier) === fileIdentifier),
-    ) ?? null
-  );
-}
-
-function schemaHashMatchesCatalog(typeRefHash, catalogHash) {
-  if (typeRefHash === undefined || typeRefHash === null) return true;
-  const declared = normalizePayloadSchemaHash(typeRefHash);
-  if (!declared) return true;
-  const canonical = normalizePayloadSchemaHash(catalogHash);
-  if (!canonical || declared.length !== canonical.length) {
-    return false;
-  }
-  return declared.every((byte, index) => byte === canonical[index]);
-}
-
-function collectTypeRefs(manifest) {
-  const refs = [];
-  for (const method of Array.isArray(manifest?.methods) ? manifest.methods : []) {
-    for (const portsKey of ["inputPorts", "outputPorts"]) {
-      for (const port of Array.isArray(method?.[portsKey]) ? method[portsKey] : []) {
-        for (const typeSet of Array.isArray(port?.acceptedTypeSets)
-          ? port.acceptedTypeSets
-          : []) {
-          for (const allowedType of Array.isArray(typeSet?.allowedTypes)
-            ? typeSet.allowedTypes
-            : []) {
-            refs.push({
-              source: `${method?.methodId ?? "method"}.${port?.portId ?? "port"}`,
-              typeRef: allowedType,
-            });
-          }
-        }
-      }
-    }
-  }
-  for (const typeRef of Array.isArray(manifest?.schemasUsed)
-    ? manifest.schemasUsed
-    : []) {
-    refs.push({
-      source: "schemasUsed",
-      typeRef,
-    });
-  }
-  return refs;
-}
-
 export async function validateManifestAgainstStandardsCatalog(
   manifest,
   options = {},
 ) {
   const catalog = options.catalog ?? (await loadKnownTypeCatalog(options));
-  const sourceName = options.sourceName ?? "manifest";
-  const issues = validateStandardsCatalogFreshness(catalog, sourceName);
-  for (const { source, typeRef } of collectTypeRefs(manifest)) {
-    if (typeRef?.acceptsAnyFlatbuffer === true) {
-      continue;
-    }
-    const resolved = resolveStandardsTypeRef(typeRef, catalog);
-    if (!resolved) {
-      const schemaName = normalizeSchemaName(typeRef?.schemaName);
-      const fileIdentifier = normalizeFileIdentifier(typeRef?.fileIdentifier);
-      const partiallyKnown = catalog.some(
-        (entry) =>
-          (schemaName && normalizeSchemaName(entry.schemaName) === schemaName) ||
-          (fileIdentifier &&
-            normalizeFileIdentifier(entry.fileIdentifier) === fileIdentifier),
-      );
-      issues.push({
-        severity: "error",
-        code: partiallyKnown
-          ? "standards-type-identity-mismatch"
-          : "unresolved-standards-type",
-        message: partiallyKnown
-          ? `Type reference from ${source} mixes a known schemaName or exact four-byte fileIdentifier with a different standards entry.`
-          : `Type reference from ${source} does not resolve to a known shared-module or \`spacedatastandards.org\` schema by its exact schemaName and fileIdentifier.`,
-        location: `${sourceName}.${source}`,
-      });
-      continue;
-    }
-    if (
-      typeRef?.rootTypeName &&
-      resolved.rootTypeName &&
-      typeRef.rootTypeName !== resolved.rootTypeName
-    ) {
-      issues.push({
-        severity: "error",
-        code: "standards-root-type-mismatch",
-        message: `Type reference from ${source} declares rootTypeName ${JSON.stringify(typeRef.rootTypeName)} but the canonical SDS root is ${JSON.stringify(resolved.rootTypeName)}.`,
-        location: `${sourceName}.${source}`,
-      });
-    }
-    if (
-      typeRef?.schemaVersion &&
-      resolved.version &&
-      typeRef.schemaVersion !== resolved.version
-    ) {
-      issues.push({
-        severity: "error",
-        code: "standards-schema-version-mismatch",
-        message: `Type reference from ${source} declares schemaVersion ${JSON.stringify(typeRef.schemaVersion)} but the canonical SDS version is ${JSON.stringify(resolved.version)}.`,
-        location: `${sourceName}.${source}`,
-      });
-    }
-    if (
-      resolved.hash &&
-      !schemaHashMatchesCatalog(typeRef?.schemaHash, resolved.hash)
-    ) {
-      issues.push({
-        severity: "error",
-        code: "standards-schema-hash-mismatch",
-        message: `Type reference from ${source} declares a schemaHash that differs from the canonical SDS schema hash.`,
-        location: `${sourceName}.${source}`,
-      });
-    }
-  }
-  return {
-    catalog,
-    issues,
-  };
+  return validateManifestAgainstCatalog(catalog, manifest, options);
 }

package/src/testing/AGENTS.md

@@ -22,10 +22,33 @@ author-facing harnesses and streaming helpers.
 - Avoid hiding stateful behavior inside one-off demos; if a harness contract is
   real, test it here.
 
+## Browser-Facing Code Does NOT Live Here (ruling 2026-08-07)
+
+`src/testing/**` is HARNESS surface: it spawns WasmEdge, shells out, and opens
+files. NOTHING browser-facing may resolve into it, because a browser bundler
+resolves every branch statically and emits `node:` specifiers the browser then
+tries to FETCH — that is how all 275 OrbPro gallery demos went dark
+(`orbpro-engine-bundle-ships-node-builtins`).
+
+The browser runtime surfaces moved OUT of here and into `src/host/`:
+
+| was | is |
+| --- | --- |
+| `testing/browserModuleHarness.js` | `host/browserModuleHarness.js` (`./host/browser-module`) |
+| `testing/workerModuleHarness.js` | `host/workerModuleHarness.js` (`./host/worker-module`) |
+| `testing/moduleFlatbufferStreamPump.js` | `host/moduleFlatbufferStreamPump.js` |
+| `toLoadableWasmBytes` | `bundle/artifactBytes.js` (`./bundle`) |
+
+`./testing/browser` survives as `browser.js`, a pure re-export shim of those
+runtime surfaces and nothing else. Both guards
+(`test/browser-reachable-node-builtins.test.js`,
+`test/browser-bundle-node-builtins.test.js`) enforce this with no exception
+list; the second one bundles the artifact and greps it.
+
 ## Key Files To Read
 
-- `browserModuleHarness.js`
-- `moduleFlatbufferStreamPump.js`
+- `moduleHarness.js`
+- `parityHarness.js`
 - `processInvoke.js`
 
 ## Note

package/src/testing/browser.js

@@ -0,0 +1,32 @@
+/**
+ * `space-data-module-sdk/testing/browser` — browser-safe alias, kept honest.
+ *
+ * RULING 2026-08-07 (`orbpro-engine-bundle-ships-node-builtins`): `testing/*`
+ * is HARNESS surface. Production browser code must NOT reach for it to load a
+ * module. The two things callers actually wanted moved to runtime surfaces:
+ *
+ *   toLoadableWasmBytes, ... -> space-data-module-sdk/bundle
+ *   createBrowserModuleHarness,
+ *   createWorkerModuleHarness,
+ *   detectArtifactProfile,
+ *   zeroWasmBytes             -> space-data-module-sdk/host/browser-module
+ *
+ * This file exists so that subpath stays browser-SAFE for the tests and
+ * consumers still pointed at it: it re-exports the runtime surfaces and nothing
+ * else. It can never reach a Node harness again — the whole `src/testing/`
+ * neighbourhood is off the browser graph now, and
+ * test/browser-reachable-node-builtins.test.js plus
+ * test/browser-bundle-node-builtins.test.js enforce that at module level AND at
+ * bundled-artifact level, with no exception list.
+ *
+ * New browser code: import from the runtime subpaths above.
+ */
+
+export {
+  createBrowserModuleHarness,
+  detectArtifactProfile,
+  toLoadableWasmBytes,
+  zeroWasmBytes,
+  isSharedArrayBufferLike,
+} from "../host/browserModuleHarness.js";
+export { createWorkerModuleHarness } from "../host/workerModuleHarness.js";

package/src/testing/index.js

@@ -10,8 +10,8 @@ export {
 export {
   createBrowserModuleHarness,
   detectArtifactProfile,
-} from "./browserModuleHarness.js";
-export { createWorkerModuleHarness } from "./workerModuleHarness.js";
+} from "../host/browserModuleHarness.js";
+export { createWorkerModuleHarness } from "../host/workerModuleHarness.js";
 export {
   buildWasmEdgeSpawnEnv,
   createPluginInvokeProcessClient,
@@ -27,7 +27,7 @@ export {
   createModuleHarness,
   resolveModuleHarnessLaunchPlan,
 } from "./moduleHarness.js";
-export { createModuleFlatBufferStreamPump } from "./moduleFlatbufferStreamPump.js";
+export { createModuleFlatBufferStreamPump } from "../host/moduleFlatbufferStreamPump.js";
 export {
   PARITY_LANES,
   ExitClass as ParityExitClass,