space-data-module-sdk 0.5.8 → 0.5.10

package/README.md

@@ -1,9 +1,9 @@
 # Space Data Module SDK
 
-`space-data-module-sdk` defines the canonical module artifact for the Space Data
-stack: WebAssembly code, an embedded FlatBuffer manifest, a stable capability
-vocabulary, a single-file bundle format, and the signing and transport records
-used to move modules between hosts.
+`space-data-module-sdk` defines the canonical Space Data module architecture for
+WebAssembly artifacts: an embedded FlatBuffer manifest, canonical ABI exports,
+a stable capability vocabulary, single-file packaging, and the signing and
+transport records used to move modules between hosts.
 
 This repository is the source of truth for module-level concerns:
 
@@ -11,17 +11,34 @@ This repository is the source of truth for module-level concerns:
 - embedded manifest exports inside `.wasm` modules
 - standards-aware compliance and capability validation
 - module compilation and protection
-- the `sds.bundle` single-file custom section
+- 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>
 
-## Artifact Model
+## Shared Harness Ownership
 
-A module built with this SDK is a `.wasm` artifact with:
+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:
 
 - an embedded `PluginManifest.fbs`
 - exported manifest accessors:
@@ -37,10 +54,15 @@ A module built with this SDK is a `.wasm` artifact with:
   - resolved deployment plans and input bindings
   - deployment authorization
   - auxiliary FlatBuffer or raw payloads
-- optional appended SDS `REC` publication trailers carrying:
+- optional appended SDS FlatBuffer publication records in a trailing `REC`
+  container carrying:
   - `PNM` digital-signature/publication metadata
   - `ENC` encrypted-delivery metadata
-- auxiliary FlatBuffer or raw payloads
+
+Single-file bundling does not append arbitrary bytes to the end of the wasm
+module. The one-file module container is `sds.bundle`, stored as a standard
+wasm custom section. Appended bytes are reserved for SDS publication records
+such as `PNM` and `ENC`, wrapped in a trailing `REC` FlatBuffer collection.
 
 The module contract stays the same whether the artifact is loaded directly,
 wrapped in a deployment envelope, or shipped as one bundled `.wasm` file.
@@ -65,7 +87,7 @@ same request bytes from guest memory and returns response bytes in guest
 memory.
 
 For simple single-input / single-output methods, command mode also supports a
-degenerate raw shortcut:
+raw shortcut:
 
 ```bash
 wasmedge module.wasm --method echo < input.fb > output.fb
@@ -101,8 +123,8 @@ anywhere it can:
 - read FlatBuffers
 - honor the module capability and host ABI contract
 
-That target set matches the WebAssembly and FlatBuffers runtime families already
-used in the companion `flatbuffers/wasm` work:
+That architecture is intended to stay portable across the common WebAssembly
+and FlatBuffer host environments:
 
 - browser
 - Node.js
@@ -126,26 +148,11 @@ This repo currently includes:
 - a reference Node host and sync `sdn_host` bridge for the first hostcall
   surface
 
-## Testing
-
-This repo now exposes a manifest-driven harness generator from
-`space-data-module-sdk/testing` and two complementary integration suites:
-
-- `npm run test:runtime-matrix`
-  - cross-language runtime smoke across the same WASM in Node.js, Go, Python,
-    Rust, Java, C#, and Swift
-  - covers method calling, aligned-binary envelope metadata preservation,
-    stdin/stdout/stderr, args, env, preopened filesystem access, and basic WASI
-    clock/time smoke
-- `npm run test:host-surfaces`
-  - authoritative Node-host coverage for HTTP, TCP, UDP, TLS, WebSocket, MQTT,
-    process execution, timers, filesystem, and the sync `sdn_host` ABI
+## Runtime Targets
 
-The detailed edge cases and the current WASI-vs-host portability boundary are
-documented in
-[`docs/testing-harness.md`](./docs/testing-harness.md).
+Manifests can declare coarse runtime targets in `manifest.runtimeTargets`.
 
-If a manifest declares `runtimeTargets: ["wasi"]`, this SDK now treats that as
+If a manifest declares `runtimeTargets: ["wasi"]`, this SDK treats that as
 "standalone WASI, no host wrapper required." In practice that currently means:
 
 - the artifact must declare the `command` invoke surface
@@ -153,15 +160,14 @@ If a manifest declares `runtimeTargets: ["wasi"]`, this SDK now treats that as
   `logging`, `clock`, `random`, `filesystem`, `pipe`
 - hosted protocols may only use `wasi-pipe` transport
 
-For maximum server-side portability with guest-owned network services, use
-`runtimeTargets: ["wasmedge"]`. That target is intended for WasmEdge
-environments with socket/TLS extensions, while plain `wasi` remains the strict
-no-wrapper baseline. The Node-RED-oriented parity map lives in
-[`docs/node-red-default-node-parity.md`](./docs/node-red-default-node-parity.md).
+If a manifest declares `runtimeTargets: ["wasmedge"]`, this SDK treats that as
+the preferred server-side target when the guest needs network-oriented runtime
+features such as sockets or TLS. Plain `wasi` remains the strict portability
+baseline; `wasmedge` is the practical higher-capability target.
 
 ## WasmEdge Pthreads
 
-`space-data-module-sdk` is the source of truth for module thread-model
+`space-data-module-sdk` is also the source of truth for module thread-model
 selection.
 
 - `compileModuleFromSource({ threadModel })` accepts an explicit thread model.
@@ -174,10 +180,39 @@ toolchain. They require a real system Emscripten installation on `PATH`, and
 the compiler result plus guest-link bundle metadata preserve the selected
 `threadModel`.
 
-This SDK does not treat Cesium `TaskProcessor`, ad hoc JS worker pools, or
-host-side fake orchestration as a substitute for guest pthread support. If a
-runtime cannot interoperate with the guest contract directly, document that as a
-wrapper requirement instead of changing the guest artifact semantics.
+As emitted by current Emscripten, these pthread artifacts still import
+Emscripten `env.*` host functions plus imported shared memory. That means a
+bare `wasmedge` CLI invocation is not yet the direct execution path for them;
+they currently require a WasmEdge-side host shim that satisfies the Emscripten
+pthread contract.
+
+If a runtime cannot interoperate with the guest pthread contract directly,
+document that as a wrapper requirement instead of changing the guest artifact
+semantics.
+
+## Testing
+
+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
+  - covers method calling, aligned-binary envelope metadata preservation,
+    stdin/stdout/stderr, args, env, preopened filesystem access, and basic WASI
+    clock/time smoke
+- `npm run test:host-surfaces`
+  - authoritative Node-host coverage for HTTP, TCP, UDP, TLS, WebSocket, MQTT,
+    process execution, timers, filesystem, and the sync `sdn_host` ABI
+
+The detailed edge cases and the current WASI-vs-host portability boundary are
+documented in
+[`docs/testing-harness.md`](./docs/testing-harness.md).
 
 ## Install
 
@@ -196,6 +231,8 @@ import {
   validateManifestWithStandards,
 } from "space-data-module-sdk";
 
+manifest.runtimeTargets = ["wasmedge"];
+
 const manifestBytes = encodePluginManifest(manifest);
 const validation = await validateManifestWithStandards(manifest);
 if (!validation.ok) {
@@ -265,10 +302,11 @@ The full contract split is documented in
 
 `sds.bundle` keeps module delivery to one file without changing WebAssembly
 loadability for the runtime payload itself. The SDK writes the bundle as a
-standard custom section inside the wasm module and, when the artifact is
-signed or encrypted for publication, appends an SDS `REC` trailer after the
-wasm bytes. Loaders must scan and strip that trailer before handing bytes to a
-runtime such as WasmEdge.
+standard custom section inside the wasm module. When the artifact is signed or
+encrypted for publication, SDS appends FlatBuffer publication records after the
+wasm bytes in a trailing `REC` container. Loaders must scan from the end,
+resolve `PNM` / `ENC`, strip or decrypt as needed, and only then hand the
+remaining raw wasm bytes to a runtime such as WasmEdge.
 
 The reference path lives in
 [`examples/single-file-bundle`](./examples/single-file-bundle):
@@ -285,7 +323,7 @@ for resolved protocol installations and producer input bindings.
 
 ## Module Publication
 
-Packages that publish SDN modules now use the canonical `sdn-module`
+Packages that publish Space Data modules use the canonical `sdn-module`
 publication descriptor. That descriptor covers:
 
 - standalone module packages
@@ -345,7 +383,7 @@ includes:
 
 Manifests can also declare coarse runtime targets for planning and compliance:
 
-`node` `browser` `wasi` `server` `desktop` `edge`
+`node` `browser` `wasi` `wasmedge` `server` `desktop` `edge`
 
 ## Environment Notes
 
@@ -401,7 +439,8 @@ npm run check:compliance
 ```
 
 Node.js `>=20` is required. The compiler uses `sdn-emception` and `flatc-wasm`
-by default.
+by default for the embedded toolchain path. WasmEdge pthread builds require a
+system Emscripten toolchain on `PATH`.
 
 If another repo needs the same compiler runtime, the package also exposes a
 shared emception session at `space-data-module-sdk/compiler/emception` with

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "space-data-module-sdk",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "description": "Module SDK for building, validating, signing, and deploying WebAssembly modules on the Space Data Network.",
   "type": "module",
   "types": "./src/index.d.ts",

package/src/index.d.ts

@@ -662,12 +662,25 @@ 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 { TypedArenaBuffer, TypedArenaBufferT } from "../generated/orbpro/stream/typed-arena-buffer.js";
+import { TypedArenaBufferT } from "../generated/orbpro/stream/typed-arena-buffer.js";
 import { toUint8Array } from "../runtime/bufferLike.js";
 
 function toByteBuffer(data) {
@@ -149,20 +149,22 @@ function normalizeArenaFrame(frame = {}, offset) {
 
 function packArenaFrames(frames = []) {
   const packedFrames = [];
-  const arena = [];
+  const normalizedFrames = [];
   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: Uint8Array.from(arena),
+    arena,
   };
 }
 

package/src/testing/buildWasmEdgeRunner.js

@@ -0,0 +1,214 @@
+import { accessSync, existsSync } from "node:fs";
+import { execFile } from "node:child_process";
+import path from "node:path";
+import process from "node:process";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+
+const execFileAsync = promisify(execFile);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function normalizeResolvedPath(value) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return null;
+  }
+  return path.resolve(value);
+}
+
+function ensureReadableSync(targetPath, label) {
+  try {
+    accessSync(targetPath);
+  } catch {
+    throw new Error(`${label} not found: ${targetPath}`);
+  }
+}
+
+function resolveWasmEdgeSharedLibraryFilename() {
+  if (process.platform === "darwin") {
+    return "libwasmedge.0.dylib";
+  }
+  if (process.platform === "win32") {
+    return "wasmedge.dll";
+  }
+  return "libwasmedge.so.0";
+}
+
+function resolveGeneratedIncludeDir(requestedIncludeDir) {
+  const directHeaderPath = path.join(
+    requestedIncludeDir,
+    "wasmedge",
+    "enum_configure.h",
+  );
+  if (existsSync(directHeaderPath)) {
+    return requestedIncludeDir;
+  }
+
+  const repoRoot = path.resolve(requestedIncludeDir, "..", "..");
+  const generatedDir = path.join(repoRoot, "build", "include", "api");
+  if (existsSync(path.join(generatedDir, "wasmedge", "enum_configure.h"))) {
+    return generatedDir;
+  }
+
+  throw new Error(
+    `WasmEdge include directory does not contain wasmedge/enum_configure.h: ${requestedIncludeDir}`,
+  );
+}
+
+export function resolveWasmEdgeRunnerSourcePath() {
+  return path.resolve(
+    __dirname,
+    "native",
+    "wasmedge_emscripten_pthread_runner.c",
+  );
+}
+
+export function resolveWasmEdgeRunnerBuildPlan(options = {}) {
+  const requestedIncludeDir = normalizeResolvedPath(
+    options.wasmedgeIncludeDir ?? process.env.WASMEDGE_INCLUDE_DIR,
+  );
+  const wasmedgeLibDir = normalizeResolvedPath(
+    options.wasmedgeLibDir ?? process.env.WASMEDGE_LIB_DIR,
+  );
+  const outputPath = normalizeResolvedPath(
+    options.outputPath ?? options.output,
+  );
+
+  if (!requestedIncludeDir) {
+    throw new Error(
+      "Missing WasmEdge include directory. Set wasmedgeIncludeDir, --wasmedge-include-dir, or WASMEDGE_INCLUDE_DIR.",
+    );
+  }
+  if (!wasmedgeLibDir) {
+    throw new Error(
+      "Missing WasmEdge library directory. Set wasmedgeLibDir, --wasmedge-lib-dir, or WASMEDGE_LIB_DIR.",
+    );
+  }
+  if (!outputPath) {
+    throw new Error("Missing runner outputPath.");
+  }
+
+  const runnerSourcePath = resolveWasmEdgeRunnerSourcePath();
+  const wasmedgeSharedLibraryPath = path.join(
+    wasmedgeLibDir,
+    resolveWasmEdgeSharedLibraryFilename(),
+  );
+
+  return {
+    runnerSourcePath,
+    requestedIncludeDir,
+    wasmedgeIncludeDir: requestedIncludeDir,
+    wasmedgeLibDir,
+    wasmedgeSharedLibraryPath,
+    outputPath,
+    compilerCommand:
+      process.platform === "darwin" ? "xcrun" : process.env.CC ?? "cc",
+    compilerArgs:
+      process.platform === "darwin"
+        ? [
+            "clang",
+            runnerSourcePath,
+            "-std=c11",
+            "-O2",
+            "-pthread",
+            "-Wall",
+            "-Wextra",
+            "-Werror",
+            "-Wno-unused-parameter",
+            "-Wno-error=visibility",
+            `-I${requestedIncludeDir}`,
+            `-L${wasmedgeLibDir}`,
+            "-lwasmedge",
+            `-Wl,-rpath,${wasmedgeLibDir}`,
+            "-o",
+            outputPath,
+          ]
+        : [
+            runnerSourcePath,
+            "-std=c11",
+            "-O2",
+            "-pthread",
+            "-Wall",
+            "-Wextra",
+            "-Werror",
+            "-Wno-unused-parameter",
+            "-Wno-error=visibility",
+            `-I${requestedIncludeDir}`,
+            `-L${wasmedgeLibDir}`,
+            "-lwasmedge",
+            `-Wl,-rpath,${wasmedgeLibDir}`,
+            "-o",
+            outputPath,
+          ],
+  };
+}
+
+export async function buildWasmEdgeEmscriptenPthreadRunner(options = {}) {
+  const basePlan = resolveWasmEdgeRunnerBuildPlan(options);
+  const wasmedgeIncludeDir = resolveGeneratedIncludeDir(
+    basePlan.requestedIncludeDir,
+  );
+  const compilerArgs =
+    process.platform === "darwin"
+      ? [
+          "clang",
+          basePlan.runnerSourcePath,
+          "-std=c11",
+          "-O2",
+          "-pthread",
+          "-Wall",
+          "-Wextra",
+          "-Werror",
+          "-Wno-unused-parameter",
+          "-Wno-error=visibility",
+          `-I${wasmedgeIncludeDir}`,
+          `-L${basePlan.wasmedgeLibDir}`,
+          "-lwasmedge",
+          `-Wl,-rpath,${basePlan.wasmedgeLibDir}`,
+          "-o",
+          basePlan.outputPath,
+        ]
+      : [
+          basePlan.runnerSourcePath,
+          "-std=c11",
+          "-O2",
+          "-pthread",
+          "-Wall",
+          "-Wextra",
+          "-Werror",
+          "-Wno-unused-parameter",
+          "-Wno-error=visibility",
+          `-I${wasmedgeIncludeDir}`,
+          `-L${basePlan.wasmedgeLibDir}`,
+          "-lwasmedge",
+          `-Wl,-rpath,${basePlan.wasmedgeLibDir}`,
+          "-o",
+          basePlan.outputPath,
+        ];
+  const plan = {
+    ...basePlan,
+    wasmedgeIncludeDir,
+    compilerArgs,
+  };
+
+  ensureReadableSync(plan.runnerSourcePath, "Runner source");
+  ensureReadableSync(plan.wasmedgeIncludeDir, "WasmEdge include directory");
+  ensureReadableSync(plan.wasmedgeLibDir, "WasmEdge library directory");
+  ensureReadableSync(
+    plan.wasmedgeSharedLibraryPath,
+    "WasmEdge shared library",
+  );
+
+  await execFileAsync(plan.compilerCommand, plan.compilerArgs, {
+    cwd: options.cwd ?? process.cwd(),
+  });
+  if (process.platform === "darwin") {
+    await execFileAsync("install_name_tool", [
+      "-change",
+      "@rpath/libwasmedge.0.dylib",
+      plan.wasmedgeSharedLibraryPath,
+      plan.outputPath,
+    ]);
+  }
+  return plan.outputPath;
+}

package/src/testing/index.d.ts

@@ -57,6 +57,69 @@ 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;
@@ -84,3 +147,49 @@ 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,6 +1,22 @@
+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({