space-data-module-sdk 0.2.5 → 0.2.7

package/README.md

@@ -34,6 +34,7 @@ A module built with this SDK is a `.wasm` artifact with:
 - an exported `_start` entry when the artifact supports WASI command mode
 - optional `sds.bundle` custom-section payloads for:
   - manifest bytes
+  - resolved deployment plans and input bindings
   - deployment authorization
   - detached signatures
   - encrypted transport envelopes
@@ -81,6 +82,14 @@ outputs. The reference invoke examples live in
 - `manifest.hybrid.json`
 - `module.c`
 
+Input and output ports can independently declare regular `flatbuffer` payloads
+or `aligned-binary` layouts. Mixed contracts are valid. When a port advertises
+an `aligned-binary` layout, it must also advertise a regular `flatbuffer`
+fallback for the same schema in the same accepted type set. A module can accept
+a regular `OMM.fbs` request and emit an aligned-binary `StateVector.fbs`
+response, provided the output port also declares the regular `StateVector.fbs`
+fallback and the aligned type ref carries the correct layout metadata.
+
 ## Runtime Portability
 
 The module format is language-neutral. A host can load modules from this SDK
@@ -115,6 +124,25 @@ 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
+
+The detailed edge cases and the current WASI-vs-host portability boundary are
+documented in
+[`docs/testing-harness.md`](./docs/testing-harness.md).
+
 ## Install
 
 ```bash
@@ -161,8 +189,36 @@ import { createDeploymentAuthorization } from "space-data-module-sdk/auth";
 import { encryptJsonForRecipient } from "space-data-module-sdk/transport";
 import { compileModuleFromSource } from "space-data-module-sdk/compiler";
 import { createSingleFileBundle } from "space-data-module-sdk/bundle";
+import { validateDeploymentPlan } from "space-data-module-sdk/deployment";
+import { generateManifestHarnessPlan } from "space-data-module-sdk/testing";
 ```
 
+## Protocol Installation
+
+Modules can declare hosted protocol contracts in `manifest.protocols`.
+
+Those declarations are for stable artifact identity:
+
+- `wireId`
+- `transportKind`
+- `role`
+- `specUri`
+- hosting hints like `defaultPort` and `requireSecureTransport`
+
+Concrete multiaddrs, peer IDs, and producer routing do not belong in the
+canonical manifest. They belong in deployment metadata attached to the final
+package or bundle.
+
+This repo exposes that deployment surface from
+`space-data-module-sdk/deployment`. Use it to:
+
+- validate resolved protocol installations
+- describe input bindings from producers to module ports
+- attach a deployment plan to `sds.bundle`
+
+The full contract split is documented in
+[`docs/protocol-installation.md`](./docs/protocol-installation.md).
+
 ## Single-File Bundles
 
 `sds.bundle` keeps module delivery to one file without changing WebAssembly
@@ -179,6 +235,9 @@ The reference path lives in
 - the `go` and `python` directories show non-JS readers against the same
   bundle contract
 
+Standard bundle payloads now include the optional `deployment-plan` JSON entry
+for resolved protocol installations and producer input bindings.
+
 ## Module Publication
 
 Packages that publish SDN modules now use the canonical `sdn-module`
@@ -294,8 +353,11 @@ npm run check:compliance
 ```
 
 Node.js `>=20` is required. The compiler uses `sdn-emception` and `flatc-wasm`
-by default, with a system Emscripten fallback only if the embedded toolchain
-cannot load.
+by default.
+
+If another repo needs the same compiler runtime, the package also exposes a
+shared emception session at `space-data-module-sdk/compiler/emception` with
+helpers for serialized command execution and virtual filesystem access.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "space-data-module-sdk",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Module SDK for building, validating, signing, and deploying WebAssembly modules on the Space Data Network.",
   "type": "module",
   "types": "./src/index.d.ts",
@@ -9,7 +9,7 @@
     "url": "git+https://github.com/DigitalArsenal/space-data-module-sdk.git"
   },
   "bin": {
-    "space-data-module": "./bin/space-data-module.js"
+    "space-data-module": "bin/space-data-module.js"
   },
   "exports": {
     ".": "./src/index.js",
@@ -18,8 +18,12 @@
     "./auth": "./src/auth/index.js",
     "./transport": "./src/transport/index.js",
     "./compiler": "./src/compiler/index.js",
+    "./compiler/emception": "./src/compiler/emception.js",
     "./bundle": "./src/bundle/index.js",
+    "./deployment": "./src/deployment/index.js",
     "./invoke": "./src/invoke/index.js",
+    "./runtime": "./src/runtime/index.js",
+    "./testing": "./src/testing/index.js",
     "./standards": "./src/standards/index.js",
     "./schemas/*": "./schemas/*"
   },
@@ -30,6 +34,8 @@
   ],
   "scripts": {
     "test": "node --test",
+    "test:host-surfaces": "node --test test/node-host.test.js test/host-abi.test.js",
+    "test:runtime-matrix": "SPACE_DATA_MODULE_SDK_ENABLE_RUNTIME_MATRIX=1 node --test test/runtime-matrix.test.js",
     "start:lab": "node ./lab/server.js",
     "check:compliance": "node ./bin/space-data-module.js check --repo-root .",
     "generate:vectors": "node ./examples/single-file-bundle/generate-vectors.mjs",

package/schemas/PluginManifest.fbs

@@ -134,6 +134,15 @@ table ProtocolSpec {
   input_port_id: string;
   output_port_id: string;
   description: string;
+  wire_id: string;
+  transport_kind: string;
+  role: string;
+  spec_uri: string;
+  auto_install: bool = true;
+  advertise: bool = false;
+  discovery_key: string;
+  default_port: uint16;
+  require_secure_transport: bool = false;
 }
 
 /// Build artifact emitted by the plugin toolchain.

package/src/bundle/constants.js

@@ -5,4 +5,7 @@ export const DEFAULT_HASH_ALGORITHM = "sha256";
 export const DEFAULT_MANIFEST_EXPORT_SYMBOL = "plugin_get_manifest_flatbuffer";
 export const DEFAULT_MANIFEST_SIZE_SYMBOL =
   "plugin_get_manifest_flatbuffer_size";
-
+export const SDS_DEPLOYMENT_SECTION_NAME = "sds.deployment";
+export const SDS_DEPLOYMENT_ENTRY_ID = "deployment-plan";
+export const SDS_DEPLOYMENT_MEDIA_TYPE =
+  "application/vnd.space-data.module.deployment+json";

package/src/bundle/wasm.js

@@ -3,11 +3,14 @@ import { decodePluginManifest, encodePluginManifest } from "../manifest/index.js
 import { toUint8Array } from "../runtime/bufferLike.js";
 import { sha256Bytes } from "../utils/crypto.js";
 import { bytesToHex } from "../utils/encoding.js";
+import { createDeploymentPlanBundleEntry } from "../deployment/index.js";
 import {
   DEFAULT_MANIFEST_EXPORT_SYMBOL,
   DEFAULT_MANIFEST_SIZE_SYMBOL,
   SDS_BUNDLE_SECTION_NAME,
   SDS_CUSTOM_SECTION_PREFIX,
+  SDS_DEPLOYMENT_ENTRY_ID,
+  SDS_DEPLOYMENT_SECTION_NAME,
 } from "./constants.js";
 import {
   decodeModuleBundle,
@@ -268,6 +271,9 @@ function normalizeStandardEntries(options = {}) {
       description: "Transport envelope metadata.",
     });
   }
+  if (options.deploymentPlan !== undefined) {
+    entries.push(createDeploymentPlanBundleEntry(options.deploymentPlan));
+  }
   return entries.filter((entry) => entry.payload !== null);
 }
 
@@ -282,7 +288,12 @@ function normalizeAdditionalEntries(entries = []) {
 }
 
 async function withSha256(entry) {
-  const payloadBytes = normalizeBytes(entry.payload, `entry "${entry.entryId}" payload`);
+  const payloadBytes =
+    toUint8Array(entry.payload) ??
+    ((entry.payloadEncoding === "json-utf8" ||
+      moduleBundleEncodingToName(entry.payloadEncoding) === "json-utf8")
+      ? canonicalBytes(entry.payload)
+      : normalizeBytes(entry.payload, `entry "${entry.entryId}" payload`));
   return {
     ...entry,
     payload: payloadBytes,
@@ -315,6 +326,17 @@ function buildParsedEntries(bundle) {
         parsedEntry.decodedManifest = null;
       }
     }
+    if (
+      parsedEntry.entryId === SDS_DEPLOYMENT_ENTRY_ID ||
+      parsedEntry.sectionName === SDS_DEPLOYMENT_SECTION_NAME
+    ) {
+      parsedEntry.decodedDeploymentPlan =
+        parsedEntry.payloadEncodingName === "json-utf8" &&
+        parsedEntry.decodedPayload &&
+        typeof parsedEntry.decodedPayload === "object"
+          ? parsedEntry.decodedPayload
+          : null;
+    }
     return parsedEntry;
   });
 }
@@ -432,16 +454,22 @@ export async function parseSingleFileBundle(bytes, options = {}) {
       manifest = null;
     }
   }
+  const deploymentEntry =
+    parsedEntries.find(
+      (entry) =>
+        entry.entryId === SDS_DEPLOYMENT_ENTRY_ID ||
+        entry.sectionName === SDS_DEPLOYMENT_SECTION_NAME,
+    ) ?? null;
   return {
     wasmBytes,
     bundleBytes,
     bundle,
     entries: parsedEntries,
     manifest,
+    deploymentPlan: deploymentEntry?.decodedDeploymentPlan ?? null,
     customSections,
     canonicalWasmBytes: canonical.canonicalWasmBytes,
     canonicalModuleHash: canonical.hashBytes,
     canonicalModuleHashHex: canonical.hashHex,
   };
 }
-

package/src/compiler/compileModule.js

@@ -1,14 +1,10 @@
 import os from "node:os";
 import path from "node:path";
 import {
-  mkdir,
   mkdtemp,
-  readFile,
   rm,
   writeFile,
 } from "node:fs/promises";
-import { execFile as execFileCallback } from "node:child_process";
-import { promisify } from "node:util";
 
 import {
   createDeploymentAuthorization,
@@ -43,7 +39,6 @@ import {
 import { sha256Bytes } from "../utils/crypto.js";
 import { getWasmWallet } from "../utils/wasmCrypto.js";
 
-const execFile = promisify(execFileCallback);
 const C_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
 
 function selectCompiler(language) {
@@ -89,14 +84,6 @@ async function getInvokeCppSupportFiles() {
   return { runtimeHeaders, schemaHeaders };
 }
 
-async function writeFilesToDirectory(rootDir, files) {
-  for (const [relativePath, content] of Object.entries(files)) {
-    const filePath = path.join(rootDir, relativePath);
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(filePath, content, "utf8");
-  }
-}
-
 async function writeFilesToEmception(emception, rootDir, files) {
   for (const [relativePath, content] of Object.entries(files)) {
     const filePath = path.posix.join(rootDir, relativePath);
@@ -235,101 +222,6 @@ async function compileWithEmception(options = {}) {
   }
 }
 
-// ---------------------------------------------------------------------------
-// System Emscripten — fallback to emcc/em++ on PATH
-// ---------------------------------------------------------------------------
-
-async function compileWithSystemToolchain(options = {}) {
-  const {
-    compilerCommand,
-    sourceCompilerCommand,
-    sourceExtension,
-    sourceCode,
-    manifestSource,
-    invokeHeaderSource,
-    invokeSource,
-    exportedSymbols,
-    outputPath,
-    compileOptions,
-  } = options;
-  const tempDir = await mkdtemp(
-    path.join(os.tmpdir(), "space-data-module-sdk-compile-"),
-  );
-  const sourcePath = path.join(tempDir, `module.${sourceExtension}`);
-  const manifestSourcePath = path.join(tempDir, "plugin-manifest-exports.cpp");
-  const invokeHeaderPath = path.join(tempDir, "space_data_module_invoke.h");
-  const invokeSourcePath = path.join(tempDir, "plugin-invoke-bridge.cpp");
-  const sourceObjectPath = path.join(tempDir, "module.o");
-  const manifestObjectPath = path.join(tempDir, "plugin-manifest-exports.o");
-  const invokeObjectPath = path.join(tempDir, "plugin-invoke-bridge.o");
-  const resolvedOutputPath = path.resolve(
-    outputPath ?? path.join(tempDir, "module.wasm"),
-  );
-  const runtimeIncludeDir = path.join(tempDir, "flatbuffers-runtime");
-
-  const { runtimeHeaders, schemaHeaders } = await getInvokeCppSupportFiles();
-
-  await writeFile(sourcePath, sourceCode, "utf8");
-  await writeFile(manifestSourcePath, manifestSource, "utf8");
-  await writeFile(invokeHeaderPath, invokeHeaderSource, "utf8");
-  await writeFile(invokeSourcePath, invokeSource, "utf8");
-  await writeFilesToDirectory(tempDir, schemaHeaders);
-  await writeFilesToDirectory(runtimeIncludeDir, runtimeHeaders);
-
-  const args = buildCompilerArgs(exportedSymbols, compileOptions);
-
-  try {
-    await execFile(sourceCompilerCommand, [
-      "-c",
-      sourcePath,
-      `-I${tempDir}`,
-      "-o",
-      sourceObjectPath,
-    ], { timeout: 120_000 });
-
-    await execFile(compilerCommand, [
-      "-c",
-      manifestSourcePath,
-      "-std=c++17",
-      `-I${tempDir}`,
-      `-I${runtimeIncludeDir}`,
-      "-o",
-      manifestObjectPath,
-    ], { timeout: 120_000 });
-
-    await execFile(compilerCommand, [
-      "-c",
-      invokeSourcePath,
-      "-std=c++17",
-      `-I${tempDir}`,
-      `-I${runtimeIncludeDir}`,
-      "-o",
-      invokeObjectPath,
-    ], { timeout: 120_000 });
-
-    await execFile(compilerCommand, [
-      sourceObjectPath,
-      manifestObjectPath,
-      invokeObjectPath,
-      ...args,
-      "-o",
-      resolvedOutputPath,
-    ], { timeout: 120_000 });
-  } catch (error) {
-    error.message =
-      `Compilation failed with ${compilerCommand}: ` +
-      (error.stderr || error.message);
-    throw error;
-  }
-
-  const wasmBytes = await readFile(resolvedOutputPath);
-  return { wasmBytes, outputPath: resolvedOutputPath, tempDir };
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
 export async function compileModuleFromSource(options = {}) {
   const manifest = options.manifest ?? {};
   const sourceCode = String(options.sourceCode ?? "");
@@ -382,38 +274,17 @@ export async function compileModuleFromSource(options = {}) {
     ...options,
     noEntry: includeCommandMain !== true,
   };
-  let compilerBackend = "em++ (emception)";
-  let result;
-  try {
-    result = await compileWithEmception({
-      sourceCompilerCommand: compiler.command,
-      sourceExtension: compiler.extension,
-      sourceCode,
-      manifestSource,
-      invokeHeaderSource,
-      invokeSource,
-      exportedSymbols,
-      outputPath: options.outputPath,
-      compileOptions,
-    });
-  } catch (error) {
-    if (error?.code !== "EMCEPTION_LOAD_FAILED") {
-      throw error;
-    }
-    result = await compileWithSystemToolchain({
-      compilerCommand: "em++",
-      sourceCompilerCommand: compiler.command,
-      sourceExtension: compiler.extension,
-      sourceCode,
-      manifestSource,
-      invokeHeaderSource,
-      invokeSource,
-      exportedSymbols,
-      outputPath: options.outputPath,
-      compileOptions,
-    });
-    compilerBackend = "em++ (system)";
-  }
+  const result = await compileWithEmception({
+    sourceCompilerCommand: compiler.command,
+    sourceExtension: compiler.extension,
+    sourceCode,
+    manifestSource,
+    invokeHeaderSource,
+    invokeSource,
+    exportedSymbols,
+    outputPath: options.outputPath,
+    compileOptions,
+  });
   wasmBytes = result.wasmBytes;
   resolvedOutputPath = result.outputPath;
   tempDir = result.tempDir;
@@ -425,7 +296,7 @@ export async function compileModuleFromSource(options = {}) {
   });
 
   return {
-    compiler: compilerBackend,
+    compiler: "em++ (emception)",
     language: compiler.language,
     outputPath: resolvedOutputPath,
     tempDir,

package/src/compiler/emception.d.ts

@@ -0,0 +1,60 @@
+export interface EmceptionCommandResult {
+  command: string;
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+export type SharedEmceptionFileContent =
+  | string
+  | Uint8Array
+  | ArrayBuffer
+  | ArrayBufferView;
+
+export interface SharedEmceptionHandle {
+  getRaw(): unknown;
+  exists(targetPath: string): boolean;
+  mkdirTree(directoryPath: string): void;
+  writeFile(filePath: string, content: SharedEmceptionFileContent): void;
+  writeFiles(
+    rootDir: string,
+    files: Record<string, SharedEmceptionFileContent>,
+  ): void;
+  readFile(filePath: string): Uint8Array;
+  readFile(filePath: string, options: { encoding: "utf8" }): string;
+  removeTree(targetPath: string): void;
+  run(
+    command: string,
+    options?: { throwOnNonZero?: boolean },
+  ): EmceptionCommandResult;
+}
+
+export interface SharedEmceptionSession {
+  load(): Promise<unknown>;
+  withLock<T>(
+    task: (handle: SharedEmceptionHandle) => T | Promise<T>,
+  ): Promise<T>;
+  exists(targetPath: string): Promise<boolean>;
+  mkdirTree(directoryPath: string): Promise<void>;
+  writeFile(
+    filePath: string,
+    content: SharedEmceptionFileContent,
+  ): Promise<void>;
+  writeFiles(
+    rootDir: string,
+    files: Record<string, SharedEmceptionFileContent>,
+  ): Promise<void>;
+  readFile(filePath: string): Promise<Uint8Array>;
+  readFile(filePath: string, options: { encoding: "utf8" }): Promise<string>;
+  removeTree(targetPath: string): Promise<void>;
+  run(
+    command: string,
+    options?: { throwOnNonZero?: boolean },
+  ): Promise<EmceptionCommandResult>;
+}
+
+export function createSharedEmceptionSession(): SharedEmceptionSession;
+export function loadSharedEmception(): Promise<unknown>;
+export function withSharedEmception<T>(
+  task: (handle: SharedEmceptionHandle) => T | Promise<T>,
+): Promise<T>;

package/src/compiler/emception.js

@@ -0,0 +1,191 @@
+import path from "node:path";
+
+import {
+  getSharedEmceptionController,
+  loadEmception,
+  runWithEmceptionLock,
+} from "./emceptionNode.js";
+
+const TEXT_DECODER = new TextDecoder();
+const TEXT_ENCODER = new TextEncoder();
+
+function normalizeFileContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (content instanceof Uint8Array) {
+    return content;
+  }
+  if (content instanceof ArrayBuffer) {
+    return new Uint8Array(content);
+  }
+  if (ArrayBuffer.isView(content)) {
+    return new Uint8Array(
+      content.buffer,
+      content.byteOffset,
+      content.byteLength,
+    );
+  }
+  throw new TypeError(
+    "Emception file content must be a string, Uint8Array, ArrayBuffer, or ArrayBufferView.",
+  );
+}
+
+function cloneReadBytes(value) {
+  if (typeof value === "string") {
+    return TEXT_ENCODER.encode(value);
+  }
+  const bytes = normalizeFileContent(value);
+  return new Uint8Array(bytes);
+}
+
+function removeTree(emception, targetPath) {
+  const analysis = emception.FS.analyzePath(targetPath);
+  if (!analysis.exists) {
+    return;
+  }
+  const stat = emception.FS.stat(targetPath);
+  if (!emception.FS.isDir(stat.mode)) {
+    emception.FS.unlink(targetPath);
+    return;
+  }
+  const entries = emception.FS.readdir(targetPath).filter(
+    (entry) => entry !== "." && entry !== "..",
+  );
+  for (const entry of entries) {
+    removeTree(emception, path.posix.join(targetPath, entry));
+  }
+  emception.FS.rmdir(targetPath);
+}
+
+function normalizeRunResult(command, result) {
+  const normalized = {
+    command,
+    exitCode: Number(result?.returncode ?? 0) >>> 0,
+    stdout: String(result?.stdout ?? ""),
+    stderr: String(result?.stderr ?? ""),
+  };
+  return normalized;
+}
+
+function maybeThrowRunFailure(result, options = {}) {
+  if (options.throwOnNonZero === false || result.exitCode === 0) {
+    return result;
+  }
+  const detail = result.stderr || result.stdout || "unknown emception failure";
+  throw new Error(
+    `Emception command failed with exit code ${result.exitCode}: ${result.command}\n${detail}`,
+  );
+}
+
+class SharedEmceptionHandle {
+  constructor(emception) {
+    this.emception = emception;
+  }
+
+  getRaw() {
+    return this.emception;
+  }
+
+  exists(targetPath) {
+    return this.emception.FS.analyzePath(targetPath).exists;
+  }
+
+  mkdirTree(directoryPath) {
+    this.emception.FS.mkdirTree(directoryPath);
+  }
+
+  writeFile(filePath, content) {
+    this.emception.FS.mkdirTree(path.posix.dirname(filePath));
+    this.emception.writeFile(filePath, normalizeFileContent(content));
+  }
+
+  writeFiles(rootDir, files) {
+    for (const [relativePath, content] of Object.entries(files ?? {})) {
+      this.writeFile(path.posix.join(rootDir, relativePath), content);
+    }
+  }
+
+  readFile(filePath, options = {}) {
+    const bytes = cloneReadBytes(this.emception.readFile(filePath));
+    if (options.encoding === "utf8") {
+      return TEXT_DECODER.decode(bytes);
+    }
+    return bytes;
+  }
+
+  removeTree(targetPath) {
+    removeTree(this.emception, targetPath);
+  }
+
+  run(command, options = {}) {
+    const result = normalizeRunResult(command, this.emception.run(command));
+    return maybeThrowRunFailure(result, options);
+  }
+}
+
+class SharedEmceptionSession {
+  constructor(controller = getSharedEmceptionController()) {
+    this.controller = controller;
+  }
+
+  async load() {
+    return this.controller.load();
+  }
+
+  async withLock(task) {
+    return this.controller.withLock(
+      (emception) => task(new SharedEmceptionHandle(emception)),
+    );
+  }
+
+  async exists(targetPath) {
+    return this.withLock((handle) => handle.exists(targetPath));
+  }
+
+  async mkdirTree(directoryPath) {
+    await this.withLock((handle) => {
+      handle.mkdirTree(directoryPath);
+    });
+  }
+
+  async writeFile(filePath, content) {
+    await this.withLock((handle) => {
+      handle.writeFile(filePath, content);
+    });
+  }
+
+  async writeFiles(rootDir, files) {
+    await this.withLock((handle) => {
+      handle.writeFiles(rootDir, files);
+    });
+  }
+
+  async readFile(filePath, options = {}) {
+    return this.withLock((handle) => handle.readFile(filePath, options));
+  }
+
+  async removeTree(targetPath) {
+    await this.withLock((handle) => {
+      handle.removeTree(targetPath);
+    });
+  }
+
+  async run(command, options = {}) {
+    return this.withLock((handle) => handle.run(command, options));
+  }
+}
+
+export function createSharedEmceptionSession() {
+  return new SharedEmceptionSession();
+}
+
+export async function loadSharedEmception() {
+  return loadEmception();
+}
+
+export async function withSharedEmception(task) {
+  return runWithEmceptionLock(
+    (emception) => task(new SharedEmceptionHandle(emception)),
+  );
+}