space-data-module-sdk 0.8.20 → 0.8.21

package/docs/isomorphic-pthreads.html

@@ -146,6 +146,16 @@
 <div class="codeblock"><div class="codeblock-head">sh</div><pre><code>SPACE_DATA_MODULE_SDK_ENABLE_WASMEDGE_PARITY=1 \
 SPACE_DATA_MODULE_SDK_ENABLE_TRI_RUNTIME_PARITY=1 \
 node --test test/wasi-threads-command.test.js</code></pre></div>
+<h3 id="sdk-0821-constructors-on-the-direct-surface"><a class="anchor" href="#sdk-0821-constructors-on-the-direct-surface" aria-hidden="true">#</a>SDK 0.8.21: constructors on the direct surface</h3>
+<p>An artifact built with both the <code>direct</code> and the <code>command</code> surface links the WASI command runtime. Its <code>_start</code> sets up the main thread's pthread descriptor, runs the global constructors, then runs <code>main</code>, which reads stdin. A host that serves the direct surface never enters <code>_start</code>. From 0.8.21 such an artifact also exports <code>__wasm_call_ctors</code>: the same descriptor setup and constructors, without <code>main</code>, at most once per instance. Reactors keep <code>_initialize</code>.</p>
+<p>A direct host runs <code>_initialize</code> if the module exports it, otherwise <code>__wasm_call_ctors</code>, once per instance, before the first direct call. The browser harness does this for <code>surface: &quot;direct&quot;</code>; a command instance only enters <code>_start</code>. The wasi-threads runner serves the direct surface of a command artifact with <code>--sdm-direct</code>, selected by <code>createStandaloneHarness(&quot;wasmedge&quot;, path, { surface: &quot;direct&quot; })</code> and by <code>runParityHarness({ surface: &quot;direct&quot; })</code>. The SDN node uses the same order.</p>
+<p>Artifacts built with 0.8.20 or earlier have no such export. On their direct surface the constructors never run, in every runtime, and a threaded artifact's main thread has no pthread descriptor, so a recursive mutex held by the main thread does not exclude other threads. Rebuild them with 0.8.21.</p>
+<div class="codeblock"><div class="codeblock-head">sh</div><pre><code>SPACE_DATA_MODULE_SDK_ENABLE_WASMEDGE_PARITY=1 \
+SPACE_DATA_MODULE_SDK_ENABLE_TRI_RUNTIME_PARITY=1 \
+node --test test/direct-call-constructors.test.js</code></pre></div>
+<h3 id="guest-thread-faults"><a class="anchor" href="#guest-thread-faults" aria-hidden="true">#</a>Guest thread faults</h3>
+<p>A guest thread that traps never finishes the pthread exit protocol. WasmEdge cancels the whole command. In the browser and Node harnesses the joining thread stays blocked inside the guest and cannot run the worker's error event, so the worker itself writes <code>[wasi-thread] guest thread N trapped: ...</code> to stderr (Node) or the console (browser). The call still does not return.</p>
+<p>V8 (Node 20 to 25) checks bulk memory operations, and every access when the WebAssembly trap handler is off (Node on Linux arm64), against a per-instance copy of a shared memory's size. That copy is refreshed asynchronously after another thread grows the memory, so a thread that writes into memory another thread has just grown can trap with &quot;memory access out of bounds&quot;, even after synchronizing with the growing thread. The guest's allocator uses the heap the artifact was linked with and then grows the memory, so a larger imported initial memory does not prevent it.</p>
 <p>The old source path <code>src/testing/browserModuleHarness.js</code> remains a pure compatibility re-export. New browser consumers should use the public <code>space-data-module-sdk/host/browser-module</code> entry point.</p>
 <h2 id="4-integrators-the-browser-worker-anchor-required-when-you-bundle"><a class="anchor" href="#4-integrators-the-browser-worker-anchor-required-when-you-bundle" aria-hidden="true">#</a>4. Integrators: the browser worker anchor (REQUIRED when you bundle)</h2>
 <p>The browser leg of the wasi-threads host runs each guest pthread on a pooled module <code>Worker</code>. That worker is a <strong>served asset</strong>, and the SDK cannot guess where your build published it.</p>
@@ -204,6 +214,8 @@ setBrowserWasiThreadWorkerBase(&quot;js/vendor/space-data-module-sdk/src/host/&q
 <li><a class="depth-2" href="#guest-link-symbol-namespacing-collision-proof-metadata-authoritative">Guest-link symbol namespacing (collision-proof, metadata-authoritative)</a></li>
 <li><a class="depth-2" href="#3-compile-time-vs-runtime-an-honest-boundary">3. Compile-Time vs. Runtime: an honest boundary</a></li>
 <li><a class="depth-3" href="#sdk-0820-command-hosts">SDK 0.8.20 command hosts</a></li>
+<li><a class="depth-3" href="#sdk-0821-constructors-on-the-direct-surface">SDK 0.8.21: constructors on the direct surface</a></li>
+<li><a class="depth-3" href="#guest-thread-faults">Guest thread faults</a></li>
 <li><a class="depth-2" href="#4-integrators-the-browser-worker-anchor-required-when-you-bundle">4. Integrators: the browser worker anchor (REQUIRED when you bundle)</a></li>
 <li><a class="depth-2" href="#tests">Tests</a></li>
 <li><a class="depth-2" href="#see-also">See also</a></li></ul></nav>

package/docs/isomorphic-pthreads.md

@@ -216,6 +216,51 @@ SPACE_DATA_MODULE_SDK_ENABLE_TRI_RUNTIME_PARITY=1 \
 node --test test/wasi-threads-command.test.js
 ```
 
+### SDK 0.8.21: constructors on the direct surface
+
+An artifact built with both the `direct` and the `command` surface links the
+WASI command runtime. Its `_start` sets up the main thread's pthread descriptor,
+runs the global constructors, then runs `main`, which reads stdin. A host that
+serves the direct surface never enters `_start`. From 0.8.21 such an artifact
+also exports `__wasm_call_ctors`: the same descriptor setup and constructors,
+without `main`, at most once per instance. Reactors keep `_initialize`.
+
+A direct host runs `_initialize` if the module exports it, otherwise
+`__wasm_call_ctors`, once per instance, before the first direct call. The
+browser harness does this for `surface: "direct"`; a command instance only
+enters `_start`. The wasi-threads runner serves the direct surface of a command
+artifact with `--sdm-direct`, selected by
+`createStandaloneHarness("wasmedge", path, { surface: "direct" })` and by
+`runParityHarness({ surface: "direct" })`. The SDN node uses the same order.
+
+Artifacts built with 0.8.20 or earlier have no such export. On their direct
+surface the constructors never run, in every runtime, and a threaded artifact's
+main thread has no pthread descriptor, so a recursive mutex held by the main
+thread does not exclude other threads. Rebuild them with 0.8.21.
+
+```sh
+SPACE_DATA_MODULE_SDK_ENABLE_WASMEDGE_PARITY=1 \
+SPACE_DATA_MODULE_SDK_ENABLE_TRI_RUNTIME_PARITY=1 \
+node --test test/direct-call-constructors.test.js
+```
+
+### Guest thread faults
+
+A guest thread that traps never finishes the pthread exit protocol. WasmEdge
+cancels the whole command. In the browser and Node harnesses the joining thread
+stays blocked inside the guest and cannot run the worker's error event, so the
+worker itself writes `[wasi-thread] guest thread N trapped: ...` to stderr
+(Node) or the console (browser). The call still does not return.
+
+V8 (Node 20 to 25) checks bulk memory operations, and every access when the
+WebAssembly trap handler is off (Node on Linux arm64), against a per-instance
+copy of a shared memory's size. That copy is refreshed asynchronously after
+another thread grows the memory, so a thread that writes into memory another
+thread has just grown can trap with "memory access out of bounds", even after
+synchronizing with the growing thread. The guest's allocator uses the heap the
+artifact was linked with and then grows the memory, so a larger imported initial
+memory does not prevent it.
+
 The old source path `src/testing/browserModuleHarness.js` remains a pure
 compatibility re-export. New browser consumers should use the public
 `space-data-module-sdk/host/browser-module` entry point.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "space-data-module-sdk",
-  "version": "0.8.20",
+  "version": "0.8.21",
   "license": "Apache-2.0",
   "description": "Module SDK for building, validating, signing, and deploying WebAssembly modules on the Space Data Network.",
   "type": "module",

package/src/compiler/invokeGlue.js

@@ -302,6 +302,43 @@ function renderMethodDescriptors(methods) {
     .join("\n");
 }
 
+// Direct-surface initializer for command-model artifacts (wasi toolchains).
+//
+// A command artifact links crt1-command: its _start sets up the main-thread
+// descriptor (__wasi_init_tp, threads sysroot) and runs the global
+// constructors, then main. A host that serves the direct surface never enters
+// _start, so without this entry namespace-scope C++ objects stay zero-filled
+// and the main thread has no pthread descriptor. It is exported under the
+// conventional __wasm_call_ctors name that direct hosts call when a module has
+// no reactor _initialize. It runs once per instance and is a no-op on an
+// instance whose constructors have already run.
+const COMMAND_DIRECT_INITIALIZER_SOURCE = `#if defined(__wasi__)
+extern "C" void __wasm_call_ctors(void);
+extern "C" __attribute__((weak)) void __wasi_init_tp(void);
+
+namespace {
+// volatile: the optimizer would otherwise evaluate the marking constructor at
+// compile time and emit the flag as already set.
+volatile int g_sdm_constructors_ran = 0;
+
+__attribute__((constructor)) void MarkConstructorsRan() {
+  __atomic_store_n(&g_sdm_constructors_ran, 1, __ATOMIC_SEQ_CST);
+}
+}  // namespace
+
+extern "C" __attribute__((export_name("__wasm_call_ctors")))
+void sdm_command_direct_initialize(void) {
+  if (__atomic_exchange_n(&g_sdm_constructors_ran, 1, __ATOMIC_SEQ_CST) != 0) {
+    return;
+  }
+  if (__wasi_init_tp) {
+    __wasi_init_tp();
+  }
+  __wasm_call_ctors();
+}
+#endif
+`;
+
 export function generateInvokeSupportSource({ manifest = {}, includeCommandMain = true } = {}) {
   const methods = Array.isArray(manifest.methods) ? manifest.methods : [];
   return `#include <algorithm>
@@ -1812,6 +1849,7 @@ extern "C" uint32_t plugin_invoke_stream(
   return response_ptr;
 }
 
+${includeCommandMain ? COMMAND_DIRECT_INITIALIZER_SOURCE : ""}
 ${includeCommandMain
     ? `int main(int argc, char **argv) {
   const char *shortcut_method = nullptr;

package/src/host/browserModuleHarness.js

@@ -297,6 +297,28 @@ function resolveManifestSurface(manifest) {
   return null;
 }
 
+// Run the module's initializer, once per instance, before any direct call.
+// A reactor exports `_initialize` (constructors + WASI init) and runs it on
+// every instance, as before. A command artifact runs its constructors inside
+// `_start`, which then runs main and consumes stdin, so a command instance
+// only ever enters `_start`. An instance that serves the DIRECT surface of a
+// command artifact runs the artifact's `__wasm_call_ctors` export instead:
+// constructors (and main-thread setup) without main. Artifacts built before
+// that export existed have no constructor entry a host can call without main;
+// their direct surface stays uninitialized in every runtime alike.
+function initializeInstance(instance, directSurface) {
+  const exports = instance.exports;
+  const reactorInitialize = exports[DefaultInvokeExports.reactorInitializeSymbol];
+  if (typeof reactorInitialize === "function") {
+    reactorInitialize();
+    return;
+  }
+  const constructors = exports[DefaultInvokeExports.constructorsSymbol];
+  if (directSurface && typeof constructors === "function") {
+    constructors();
+  }
+}
+
 async function instantiateBrowserModule(options = {}) {
   let providedMemory = options.wasmMemory ?? options.memory ?? null;
   if (
@@ -412,11 +434,7 @@ async function instantiateBrowserModule(options = {}) {
       }
       wasi.setMemory(memory);
     }
-    if (instance.exports._initialize) {
-      instance.exports._initialize();
-    }
-    // Command exports initialize their CRT on entry. Calling _start here would
-    // consume stdin before invocation; direct-only modules use _initialize.
+    initializeInstance(instance, options.directSurface === true);
   } catch (error) {
     await threadHost?.terminateAll();
     throw error;
@@ -543,6 +561,7 @@ export async function createBrowserModuleHarness(options = {}) {
 
   const activeContext = await instantiateBrowserModule({
     wasmModule,
+    directSurface: surface === "direct",
     host,
     hostcallDispatch: options.hostcallDispatch,
     args: options.args,

package/src/host/isomorphicLoader.js

@@ -67,8 +67,15 @@ async function createWasmEdgeCommandHarness(options = {}) {
 
   const threaded = inspection.imports.some((entry) =>
     entry.module === "wasi" && entry.name === "thread-spawn");
-  const surface = inspection.exports.includes(DefaultInvokeExports.commandSymbol) ? "command" : "direct";
-  if (surface === "direct" && (!threaded || !inspection.exports.includes(DefaultInvokeExports.invokeSymbol))) {
+  const hasCommand = inspection.exports.includes(DefaultInvokeExports.commandSymbol);
+  const hasDirect = inspection.exports.includes(DefaultInvokeExports.invokeSymbol);
+  // The one-shot wasi-threads runner serves the direct surface of a reactor,
+  // and of a command artifact when the caller asks for it (--sdm-direct): the
+  // module's constructors then run through its initializer export, never main.
+  const surface = hasCommand && !(options.surface === "direct" && threaded && hasDirect)
+    ? "command"
+    : "direct";
+  if (surface === "direct" && (!threaded || !hasDirect)) {
     throw new Error(
       "Standalone WasmEdge loading requires a command-surface artifact with the _start export.",
     );
@@ -91,6 +98,7 @@ async function createWasmEdgeCommandHarness(options = {}) {
   }
 
   const args = [
+    ...(surface === "direct" && hasCommand ? ["--sdm-direct"] : []),
     ...(options.enableThreads === false ? [] : ["--enable-threads"]),
     ...Object.entries(options.env ?? {}).flatMap(([key, value]) => ["--env", `${key}=${value}`]),
     launchWasmPath,

package/src/host/wasiThreadBrowserWorker.mjs

@@ -38,6 +38,9 @@ self.onmessage = (event) => {
     instance.exports.wasi_thread_start(message.tid, message.startArg);
   } catch (error) {
     if (!(error && error.name === "WasiExitError")) {
+      // The thread that joins this one may be blocked in the guest and never
+      // handle the message below; report the fault from this worker as well.
+      console.error(`[wasi-thread] guest thread ${message.tid} trapped:`, error);
       self.postMessage({
         t: "error",
         tid: message.tid,

package/src/host/wasiThreadHost.js

@@ -400,8 +400,9 @@ export async function createWasiThreadSpawn({
           osThreadIds.add(worker.threadId);
         }
         worker.on("error", (error) => {
-          // A worker crash cannot be surfaced to the guest synchronously; log it
-          // so a hung pthread_join is diagnosable rather than silent.
+          // A worker crash cannot be surfaced to the guest synchronously. The
+          // worker itself writes the fault to stderr first, because this
+          // handler never runs while this thread is blocked in pthread_join.
           // eslint-disable-next-line no-console
           console.error("[wasi-thread] worker error:", error);
         });

package/src/host/wasiThreadWorker.mjs

@@ -8,24 +8,46 @@
 // memory atomics (memory.atomic.wait/notify emitted by the guest) — no
 // messages are needed for correctness.
 
+import { writeSync } from "node:fs";
 import { workerData } from "node:worker_threads";
 
 import { createWasiThreadWorkerRuntime } from "./wasiThreadWorkerRuntime.js";
 
 const { wasmModule, memory, tid, startArg, hostcallChannel, processState } = workerData;
+
+// A thread that faults never completes the pthread exit protocol, so the
+// thread joining it blocks for good inside the guest. When that joiner is the
+// thread that owns this worker, it can never run this worker's "error" event.
+// Write the fault to stderr from here, synchronously, so it is always seen.
+function reportGuestThreadFault(what, error) {
+  try {
+    writeSync(2, `[wasi-thread] guest thread ${tid} ${what}: ${error?.stack ?? error}\n`);
+  } catch {
+    // stderr unavailable; the worker error event still carries the fault
+  }
+}
+
 const runtime = createWasiThreadWorkerRuntime({
   wasmModule,
   memory,
   hostcallChannel,
   processState,
 });
-const instance = runtime.instantiate();
+let instance;
+try {
+  instance = runtime.instantiate();
+} catch (error) {
+  reportGuestThreadFault("failed to instantiate", error);
+  runtime.close();
+  throw error;
+}
 
 try {
   instance.exports.wasi_thread_start(tid, startArg);
 } catch (error) {
   // WASI proc_exit surfaces as WasiExitError; a clean thread return is normal.
   if (!(error && error.name === "WasiExitError")) {
+    reportGuestThreadFault("trapped", error);
     throw error;
   }
 } finally {

package/src/index.d.ts

@@ -2790,6 +2790,8 @@ export const DefaultInvokeExports: {
   allocSymbol: string;
   freeSymbol: string;
   commandSymbol: string;
+  reactorInitializeSymbol: string;
+  constructorsSymbol: string;
 };
 
 export const DrainPolicy: {

package/src/runtime/constants.js

@@ -74,4 +74,10 @@ export const DefaultInvokeExports = Object.freeze({
   allocSymbol: "plugin_alloc",
   freeSymbol: "plugin_free",
   commandSymbol: "_start",
+  // Direct-surface initialization. A reactor exports `_initialize`; a command
+  // artifact that also serves the direct surface exports `__wasm_call_ctors`
+  // (its `_start` would run main). A direct host calls the first one present,
+  // once per instance, before the first direct call.
+  reactorInitializeSymbol: "_initialize",
+  constructorsSymbol: "__wasm_call_ctors",
 });

package/src/testing/native/wasmedge_wasi_threads_runner.c

@@ -150,9 +150,12 @@ static WasmEdge_ModuleInstanceContext *memory_import(Threads *g) {
   return env;
 }
 
-// Reactor artifacts use the same PIV request/response bytes as commands. Stage
-// the request through the public allocator, then monitor the direct call with
-// the same worker-group lifecycle as _start. No guest ABI is reimplemented.
+// Direct calls use the same PIV request/response bytes as commands. Stage the
+// request through the public allocator, then monitor the direct call with the
+// same worker-group lifecycle as _start. No guest ABI is reimplemented. The
+// module initializes first, once: a reactor through _initialize, a command
+// artifact serving the direct surface through __wasm_call_ctors (its _start
+// would run main).
 static uint32_t stage_direct_request(Threads *g,
     WasmEdge_ModuleInstanceContext *instance,
     WasmEdge_MemoryInstanceContext *memory, WasmEdge_Value args[3]) {
@@ -171,6 +174,7 @@ static uint32_t stage_direct_request(Threads *g,
   }
   const WasmEdge_FunctionInstanceContext *init =
       WasmEdge_ModuleInstanceFindFunction(instance, name("_initialize"));
+  if (!init) init = WasmEdge_ModuleInstanceFindFunction(instance, name("__wasm_call_ctors"));
   if (init) require_result("initialize", WasmEdge_ExecutorInvoke(g->executor, init, NULL, 0, NULL, 0));
   const WasmEdge_FunctionInstanceContext *alloc =
       WasmEdge_ModuleInstanceFindFunction(instance, name("plugin_alloc"));
@@ -224,10 +228,12 @@ int main(int argc, char **argv) {
   if (!envs) return 1;
   uint32_t env_count = 0;
   bool stats = false;
+  bool force_direct = false;
   int first = 1;
   for (; first < argc; ++first) {
     if (strcmp(argv[first], "--enable-threads") == 0) continue;
     if (strcmp(argv[first], "--sdm-thread-stats") == 0) { stats = true; continue; }
+    if (strcmp(argv[first], "--sdm-direct") == 0) { force_direct = true; continue; }
     if (strcmp(argv[first], "--env") == 0 && first + 1 < argc) {
       envs[env_count++] = argv[++first];
       continue;
@@ -235,7 +241,7 @@ int main(int argc, char **argv) {
     break;
   }
   if (first >= argc || argv[first][0] == '-') {
-    fprintf(stderr, "usage: %s [--env NAME=VALUE] module.wasm [args...]\n", argv[0]);
+    fprintf(stderr, "usage: %s [--sdm-direct] [--env NAME=VALUE] module.wasm [args...]\n", argv[0]);
     free(envs);
     return 2;
   }
@@ -269,7 +275,9 @@ int main(int argc, char **argv) {
   WasmEdge_ModuleInstanceContext *instance = NULL;
   require_result("instantiate", WasmEdge_ExecutorInstantiate(
       g.executor, &instance, g.store, g.ast));
-  const WasmEdge_FunctionInstanceContext *start =
+  // --sdm-direct serves the direct surface of an artifact that also has a
+  // command entry; a reactor (no _start) is always served directly.
+  const WasmEdge_FunctionInstanceContext *start = force_direct ? NULL :
       WasmEdge_ModuleInstanceFindFunction(instance, name("_start"));
   bool direct = start == NULL;
   WasmEdge_Value direct_args[3], response_pointer;

package/src/testing/parityHarness.js

@@ -499,6 +499,11 @@ function applyInjectedDivergence(runs, injectDivergence) {
  * @param {string[]} [options.lanes] - subset of PARITY_LANES. Defaults to ALL
  *   THREE. Narrowing is always an explicit caller decision — lanes are never
  *   skipped silently, and a single-lane run can never claim parity.
+ * @param {string} [options.surface] - "direct" runs EVERY lane on the direct
+ *   surface: the browser harness, and the wasi-threads runner with
+ *   --sdm-direct (the WasmEdge CLI has no direct surface, so a single-thread
+ *   artifact cannot be compared on it). Omitted: the browser lane follows
+ *   browserSurface and the WasmEdge lanes run the artifact's default surface.
  * @param {Object} [options.laneRunners] - {laneName: async (context) => runs[]}
  *   override for tests. Default runners come from parityLanes.js.
  * @param {string} [options.injectDivergence] - fire-drill: XOR one output byte
@@ -555,7 +560,8 @@ export async function runParityHarness(options = {}) {
     chromeBinary: options.chromeBinary,
     wasmedgeBinary: options.wasmedgeBinary,
     wasmEdgeRunnerBinary: options.wasmEdgeRunnerBinary,
-    browserSurface: options.browserSurface ??
+    surface: options.surface ?? null,
+    browserSurface: options.browserSurface ?? options.surface ??
       (WebAssembly.Module.exports(await WebAssembly.compile(loadableBytes)).some((entry) => entry.name === "_start") ? "command" : "direct"),
     dockerBinary: options.dockerBinary,
     dockerPlatform: options.dockerPlatform,

package/src/testing/parityLanes.js

@@ -130,6 +130,21 @@ function wasmedgeInvocationArgs(planCase, plan, threadCount) {
   return args;
 }
 
+// Runner flags that select the surface. Only the wasi-threads runner serves the
+// direct surface of an artifact with a command entry; the WasmEdge CLI runs
+// `_start` or nothing, so a direct-surface comparison on it would silently
+// compare two different surfaces.
+function surfaceArgs(context, threaded, lane) {
+  if (context.surface !== "direct") return [];
+  if (!threaded) {
+    throw new Error(
+      `${lane}: the WasmEdge CLI serves only the command surface of a single-thread artifact; ` +
+        "it cannot take part in a direct-surface parity run.",
+    );
+  }
+  return ["--sdm-direct"];
+}
+
 async function stageModuleWorkdir(context, label) {
   const workdir = await mkdtemp(path.join(os.tmpdir(), `sdm-parity-${label}-`));
   // Stage the canonical loadable bytes (publication records stripped by the
@@ -183,6 +198,7 @@ export async function runNativeWasmEdgeLane(context) {
     `native binary ${binary}`,
   );
 
+  const directArgs = surfaceArgs(context, threaded, "native WasmEdge lane");
   const workdir = await stageModuleWorkdir(context, "native");
   const runs = [];
   try {
@@ -191,6 +207,7 @@ export async function runNativeWasmEdgeLane(context) {
         const outcome = await spawnWithStdin(
           binary,
           [...(threaded ? ["--sdm-thread-stats"] : []),
+            ...directArgs,
             ...wasmedgeInvocationArgs(planCase, context.plan, threadCount)],
           {
             cwd: workdir,
@@ -288,6 +305,7 @@ export async function runDockerWasmEdgeLane(context) {
       `docker WasmEdge lane: cannot execute "${dockerBinary}" (${error.message}).`,
     );
   }
+  const directArgs = surfaceArgs(context, threaded, "docker WasmEdge lane");
   const image = await ensureDockerParityImage(context);
 
   const workdir = await stageModuleWorkdir(context, "docker");
@@ -313,6 +331,7 @@ export async function runDockerWasmEdgeLane(context) {
         dockerArgs.push(
           image,
           ...(threaded ? ["--sdm-thread-stats"] : []),
+          ...directArgs,
           ...wasmedgeInvocationArgs(planCase, context.plan, threadCount),
         );
         const outcome = await spawnWithStdin(dockerBinary, dockerArgs, {