space-data-module-sdk 0.5.14 → 0.5.15

package/src/testing/index.d.ts

@@ -57,10 +57,154 @@ export interface ManifestHarnessPlan {
   scenarios: Array<HarnessInvokeScenario | HarnessRawScenario>;
 }
 
+export interface PublicationProtectionDemoAlignedType {
+  methodId: string | null;
+  portId: string | null;
+  setId: string | null;
+  schemaName: string | null;
+  fileIdentifier: string | null;
+  rootTypeName: string | null;
+  byteLength: number | null;
+  requiredAlignment: number | null;
+  hasFlatbufferFallback: boolean;
+}
+
+export interface PublicationProtectionDemoSummary {
+  manifest: PluginManifest;
+  recTrailer: {
+    fileIdentifier: string;
+    version: string | null;
+    recordCount: number;
+    recordStandards: Array<string | null>;
+    usesStandardsFlatbuffers: boolean;
+    records: Array<Record<string, unknown>>;
+  };
+  alignedBinaryContract: PublicationProtectionDemoAlignedType[];
+  signedOnly: {
+    artifactId: string;
+    encrypted: boolean;
+    trailer: PublicationProtectionDemoSummary["recTrailer"];
+    recordStandards: Array<string | null>;
+    pnm: {
+      fileName: string | null;
+      fileId: string | null;
+      cid: string | null;
+      hasSignature: boolean;
+      signatureType: string | null;
+      publishTimestamp: string | null;
+    } | null;
+    enc: null;
+    envelope: null;
+  };
+  encryptedDelivery: {
+    artifactId: string;
+    encrypted: boolean;
+    trailer: PublicationProtectionDemoSummary["recTrailer"];
+    recordStandards: Array<string | null>;
+    pnm: {
+      fileName: string | null;
+      fileId: string | null;
+      cid: string | null;
+      hasSignature: boolean;
+      signatureType: string | null;
+      publishTimestamp: string | null;
+    } | null;
+    enc: {
+      context: string | null;
+      rootType: string | null;
+      keyExchange: string | null;
+      symmetric: string | null;
+      keyDerivation: string | null;
+      nonceLength: number;
+      ephemeralPublicKeyLength: number;
+    } | null;
+    envelope: {
+      scheme: string | null;
+      hasEncRecord: boolean;
+      hasPnmRecord: boolean;
+    } | null;
+  };
+}
+
+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;
 
+export function createPublicationProtectionDemoManifest(): PluginManifest;
+
+export function createPublicationProtectionDemoSummary(options?: {
+  manifest?: PluginManifest;
+  wasmBytes?: Uint8Array;
+  mnemonic?: string | null;
+  recipient?: {
+    publicKeyHex: string;
+    privateKeyHex: string;
+  };
+}): Promise<PublicationProtectionDemoSummary>;
+
 export function generateManifestHarnessPlan(options: {
   manifest: PluginManifest;
   includeOptionalInputs?: boolean;
@@ -84,3 +228,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,26 @@
+import { Buffer } from "node:buffer";
+
 import { encodePluginInvokeRequest } from "../invoke/codec.js";
 import { normalizeInvokeSurfaces } from "../invoke/index.js";
 import { selectPreferredPayloadTypeRef } from "../manifest/typeRefs.js";
+export {
+  createPublicationProtectionDemoManifest,
+  createPublicationProtectionDemoSummary,
+} from "./publicationProtectionDemo.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({

package/src/testing/moduleHarness.js

@@ -0,0 +1,62 @@
+import {
+  createPluginInvokeProcessClient,
+  resolveWasmEdgePluginLaunchPlan,
+} from "./processInvoke.js";
+
+function normalizeRuntimeDescriptor(options = {}) {
+  if (options.runtime && typeof options.runtime === "object") {
+    return options.runtime;
+  }
+  return options;
+}
+
+export function resolveModuleHarnessLaunchPlan(options = {}) {
+  const runtime = normalizeRuntimeDescriptor(options);
+  if (runtime.launchPlan && typeof runtime.launchPlan === "object") {
+    return runtime.launchPlan;
+  }
+
+  const kind = String(runtime.kind ?? "process").trim().toLowerCase();
+  if (kind === "wasmedge") {
+    return resolveWasmEdgePluginLaunchPlan(runtime);
+  }
+  if (kind === "process") {
+    if (typeof runtime.command !== "string" || runtime.command.trim().length === 0) {
+      throw new Error(
+        "resolveModuleHarnessLaunchPlan requires runtime.command for process runtimes.",
+      );
+    }
+    return {
+      command: runtime.command,
+      args: Array.isArray(runtime.args) ? runtime.args : [],
+      env: runtime.env,
+      cwd: runtime.cwd,
+    };
+  }
+
+  throw new Error(`Unsupported module harness runtime kind: ${kind}`);
+}
+
+export async function createModuleHarness(options = {}) {
+  const runtime = normalizeRuntimeDescriptor(options);
+  const kind = String(runtime.kind ?? "process").trim().toLowerCase();
+  const launchPlan = resolveModuleHarnessLaunchPlan(options);
+  const processClient = await createPluginInvokeProcessClient({ launchPlan });
+
+  return {
+    runtime: {
+      ...runtime,
+      kind,
+    },
+    launchPlan,
+    invokeRaw(requestBytes) {
+      return processClient.invokeRaw(requestBytes);
+    },
+    invoke(request) {
+      return processClient.invoke(request);
+    },
+    destroy() {
+      return processClient.destroy();
+    },
+  };
+}