sdn-flow 0.2.0

package/src/compiler/EmceptionCompilerAdapter.js

@@ -0,0 +1,244 @@
+import { summarizeProgramRequirements } from "../designer/requirements.js";
+import { normalizeProgram } from "../runtime/index.js";
+import { bytesToHex, toUint8Array } from "../utils/encoding.js";
+import { sha256Bytes } from "../utils/crypto.js";
+import { generateCppFlowRuntimeSource } from "./CppFlowSourceGenerator.js";
+import { SignedArtifactCatalog } from "./SignedArtifactCatalog.js";
+
+const DEFAULT_FLAGS = Object.freeze([
+  "-std=c++20",
+  "-O2",
+  "-sWASM=1",
+  "-sALLOW_MEMORY_GROWTH=1",
+  "-sNO_EXIT_RUNTIME=1",
+  "-sMODULARIZE=1",
+  "-sEXPORT_ES6=1",
+  "-sENVIRONMENT=web,worker,node",
+  "-sEXPORTED_FUNCTIONS=['_main','_malloc','_free','_flow_get_manifest_flatbuffer','_flow_get_manifest_flatbuffer_size','_sdn_flow_get_program_id','_sdn_flow_get_program_name','_sdn_flow_get_program_version','_sdn_flow_get_type_descriptors','_sdn_flow_get_type_descriptor_count','_sdn_flow_get_accepted_type_indices','_sdn_flow_get_accepted_type_index_count','_sdn_flow_get_trigger_descriptors','_sdn_flow_get_trigger_descriptor_count','_sdn_flow_get_node_descriptors','_sdn_flow_get_node_descriptor_count','_sdn_flow_get_node_dispatch_descriptors','_sdn_flow_get_node_dispatch_descriptor_count','_sdn_flow_get_edge_descriptors','_sdn_flow_get_edge_descriptor_count','_sdn_flow_get_trigger_binding_descriptors','_sdn_flow_get_trigger_binding_descriptor_count','_sdn_flow_get_dependency_descriptors','_sdn_flow_get_dependency_count','_sdn_flow_get_ingress_descriptors','_sdn_flow_get_ingress_descriptor_count','_sdn_flow_get_ingress_frame_descriptors','_sdn_flow_get_ingress_frame_descriptor_count','_sdn_flow_get_node_ingress_indices','_sdn_flow_get_node_ingress_index_count','_sdn_flow_get_external_interface_descriptors','_sdn_flow_get_external_interface_descriptor_count','_sdn_flow_get_ingress_runtime_states','_sdn_flow_get_ingress_runtime_state_count','_sdn_flow_get_node_runtime_states','_sdn_flow_get_node_runtime_state_count','_sdn_flow_get_current_invocation_descriptor','_sdn_flow_prepare_node_invocation_descriptor','_sdn_flow_reset_runtime_state','_sdn_flow_enqueue_trigger_frames','_sdn_flow_enqueue_trigger_frame','_sdn_flow_enqueue_edge_frames','_sdn_flow_enqueue_edge_frame','_sdn_flow_get_ready_node_index','_sdn_flow_begin_node_invocation','_sdn_flow_complete_node_invocation','_sdn_flow_apply_node_invocation_result','_sdn_flow_dispatch_next_ready_node_with_host','_sdn_flow_drain_with_host_dispatch','_sdn_flow_get_runtime_descriptor']",
+]);
+
+const DEFAULT_RUNTIME_MODEL = "compiled-cpp-wasm";
+const DEFAULT_RUNTIME_EXPORTS = Object.freeze({
+  mallocSymbol: "malloc",
+  freeSymbol: "free",
+  descriptorSymbol: "sdn_flow_get_runtime_descriptor",
+  typeDescriptorsSymbol: "sdn_flow_get_type_descriptors",
+  typeDescriptorCountSymbol: "sdn_flow_get_type_descriptor_count",
+  acceptedTypeIndicesSymbol: "sdn_flow_get_accepted_type_indices",
+  acceptedTypeIndexCountSymbol: "sdn_flow_get_accepted_type_index_count",
+  triggerDescriptorsSymbol: "sdn_flow_get_trigger_descriptors",
+  triggerDescriptorCountSymbol: "sdn_flow_get_trigger_descriptor_count",
+  nodeDescriptorsSymbol: "sdn_flow_get_node_descriptors",
+  nodeDescriptorCountSymbol: "sdn_flow_get_node_descriptor_count",
+  nodeDispatchDescriptorsSymbol: "sdn_flow_get_node_dispatch_descriptors",
+  nodeDispatchDescriptorCountSymbol:
+    "sdn_flow_get_node_dispatch_descriptor_count",
+  edgeDescriptorsSymbol: "sdn_flow_get_edge_descriptors",
+  edgeDescriptorCountSymbol: "sdn_flow_get_edge_descriptor_count",
+  triggerBindingDescriptorsSymbol: "sdn_flow_get_trigger_binding_descriptors",
+  triggerBindingDescriptorCountSymbol:
+    "sdn_flow_get_trigger_binding_descriptor_count",
+  dependencyDescriptorsSymbol: "sdn_flow_get_dependency_descriptors",
+  dependencyCountSymbol: "sdn_flow_get_dependency_count",
+  resetStateSymbol: "sdn_flow_reset_runtime_state",
+  ingressDescriptorsSymbol: "sdn_flow_get_ingress_descriptors",
+  ingressDescriptorCountSymbol: "sdn_flow_get_ingress_descriptor_count",
+  ingressFrameDescriptorsSymbol: "sdn_flow_get_ingress_frame_descriptors",
+  ingressFrameDescriptorCountSymbol:
+    "sdn_flow_get_ingress_frame_descriptor_count",
+  nodeIngressIndicesSymbol: "sdn_flow_get_node_ingress_indices",
+  nodeIngressIndexCountSymbol: "sdn_flow_get_node_ingress_index_count",
+  externalInterfaceDescriptorsSymbol:
+    "sdn_flow_get_external_interface_descriptors",
+  externalInterfaceDescriptorCountSymbol:
+    "sdn_flow_get_external_interface_descriptor_count",
+  ingressStatesSymbol: "sdn_flow_get_ingress_runtime_states",
+  ingressStateCountSymbol: "sdn_flow_get_ingress_runtime_state_count",
+  nodeStatesSymbol: "sdn_flow_get_node_runtime_states",
+  nodeStateCountSymbol: "sdn_flow_get_node_runtime_state_count",
+  currentInvocationDescriptorSymbol:
+    "sdn_flow_get_current_invocation_descriptor",
+  prepareInvocationDescriptorSymbol:
+    "sdn_flow_prepare_node_invocation_descriptor",
+  enqueueTriggerSymbol: "sdn_flow_enqueue_trigger_frames",
+  enqueueTriggerFrameSymbol: "sdn_flow_enqueue_trigger_frame",
+  enqueueEdgeSymbol: "sdn_flow_enqueue_edge_frames",
+  enqueueEdgeFrameSymbol: "sdn_flow_enqueue_edge_frame",
+  readyNodeSymbol: "sdn_flow_get_ready_node_index",
+  beginInvocationSymbol: "sdn_flow_begin_node_invocation",
+  completeInvocationSymbol: "sdn_flow_complete_node_invocation",
+  applyInvocationResultSymbol: "sdn_flow_apply_node_invocation_result",
+  dispatchHostInvocationSymbol: "sdn_flow_dispatch_next_ready_node_with_host",
+  drainWithHostDispatchSymbol: "sdn_flow_drain_with_host_dispatch",
+});
+
+async function maybeCall(value) {
+  return value instanceof Promise ? value : Promise.resolve(value);
+}
+
+export class EmceptionCompilerAdapter {
+  #emception;
+
+  #manifestBuilder;
+
+  #artifactCatalog;
+
+  #sourceGenerator;
+
+  #flags;
+
+  #outputName;
+
+  constructor(options = {}) {
+    this.#emception = options.emception ?? null;
+    this.#manifestBuilder = options.manifestBuilder ?? null;
+    this.#artifactCatalog =
+      options.artifactCatalog ?? new SignedArtifactCatalog();
+    this.#sourceGenerator =
+      options.sourceGenerator ?? generateCppFlowRuntimeSource;
+    this.#flags = Array.isArray(options.flags) ? options.flags : DEFAULT_FLAGS;
+    this.#outputName = String(options.outputName ?? "flow-runtime");
+  }
+
+  get artifactCatalog() {
+    return this.#artifactCatalog;
+  }
+
+  async #buildManifestBuffer({ program, metadata, dependencies }) {
+    if (metadata?.manifestBuffer) {
+      return toUint8Array(metadata.manifestBuffer);
+    }
+    if (typeof this.#manifestBuilder === "function") {
+      return toUint8Array(
+        await maybeCall(
+          this.#manifestBuilder({
+            program,
+            metadata,
+            dependencies,
+          }),
+        ),
+      );
+    }
+    throw new Error(
+      "EmceptionCompilerAdapter requires metadata.manifestBuffer or manifestBuilder().",
+    );
+  }
+
+  async prepareCompile({ program, metadata = null } = {}) {
+    const normalizedProgram = normalizeProgram(program);
+    const dependencies =
+      await this.#artifactCatalog.resolveProgramDependencies(normalizedProgram);
+    const manifestBuffer = await this.#buildManifestBuffer({
+      program: normalizedProgram,
+      metadata,
+      dependencies,
+    });
+    const generatedSource = await maybeCall(
+      this.#sourceGenerator({
+        program: normalizedProgram,
+        manifestBuffer,
+        dependencies,
+      }),
+    );
+    const source =
+      typeof generatedSource === "string"
+        ? generatedSource
+        : (generatedSource?.source ?? "");
+    const sourceGeneratorModel =
+      typeof generatedSource === "string"
+        ? "native-cpp-wasm"
+        : (generatedSource?.generatorModel ?? "native-cpp-wasm");
+    const outputName = String(metadata?.outputName ?? this.#outputName);
+    const flags = Array.isArray(metadata?.flags) ? metadata.flags : this.#flags;
+    return {
+      program: normalizedProgram,
+      manifestBuffer,
+      dependencies,
+      runtimeModel: DEFAULT_RUNTIME_MODEL,
+      runtimeExports: { ...DEFAULT_RUNTIME_EXPORTS },
+      sourceGeneratorModel,
+      outputName,
+      flags,
+      source,
+      sourceFiles: [
+        {
+          path: "/working/main.cpp",
+          content: source,
+        },
+      ],
+      command: `em++ ${flags.join(" ")} /working/main.cpp -o /working/${outputName}.mjs`,
+    };
+  }
+
+  async compile({ program, metadata = null } = {}) {
+    const compilePlan = await this.prepareCompile({ program, metadata });
+    if (!this.#emception) {
+      return {
+        programId: compilePlan.program.programId,
+        manifestBuffer: compilePlan.manifestBuffer,
+        runtimeModel: compilePlan.runtimeModel,
+        runtimeExports: compilePlan.runtimeExports,
+        sourceGeneratorModel: compilePlan.sourceGeneratorModel,
+        compilePlan,
+      };
+    }
+
+    if (typeof this.#emception.init === "function") {
+      await maybeCall(this.#emception.init());
+    }
+    for (const file of compilePlan.sourceFiles) {
+      await maybeCall(this.#emception.writeFile(file.path, file.content));
+    }
+    const result = await maybeCall(this.#emception.run(compilePlan.command));
+    if (Number(result?.returncode ?? 1) !== 0) {
+      throw new Error(
+        `Emception compile failed: ${result?.stderr ?? result?.stdout ?? "unknown error"}`,
+      );
+    }
+
+    const wasm = toUint8Array(
+      await maybeCall(
+        this.#emception.readFile(`/working/${compilePlan.outputName}.wasm`),
+      ),
+    );
+    const loaderModule = await maybeCall(
+      this.#emception.readFile(`/working/${compilePlan.outputName}.mjs`, {
+        encoding: "utf8",
+      }),
+    );
+    const requirements = summarizeProgramRequirements({
+      program: compilePlan.program,
+    });
+
+    return {
+      artifactId: `${compilePlan.program.programId}:${bytesToHex(
+        await sha256Bytes(wasm),
+      ).slice(0, 16)}`,
+      programId: compilePlan.program.programId,
+      runtimeModel: compilePlan.runtimeModel,
+      sourceGeneratorModel: compilePlan.sourceGeneratorModel,
+      format: "application/wasm",
+      wasm,
+      loaderModule,
+      manifestBuffer: compilePlan.manifestBuffer,
+      runtimeExports: compilePlan.runtimeExports,
+      entrypoint: "main",
+      graphHash: bytesToHex(
+        await sha256Bytes(
+          new TextEncoder().encode(JSON.stringify(compilePlan.program)),
+        ),
+      ),
+      requiredCapabilities: requirements.capabilities,
+      pluginVersions: compilePlan.dependencies.map((dependency) => ({
+        pluginId: dependency.pluginId,
+        version: dependency.version,
+        sha256: dependency.sha256,
+      })),
+      schemaBindings: metadata?.schemaBindings ?? [],
+      abiVersion: 1,
+      compilePlan,
+    };
+  }
+}
+
+export default EmceptionCompilerAdapter;

package/src/compiler/SignedArtifactCatalog.js

@@ -0,0 +1,152 @@
+import {
+  normalizeArtifactDependency,
+  normalizeProgram,
+} from "../runtime/index.js";
+import { sha256Bytes } from "../utils/crypto.js";
+import { bytesToHex, toUint8Array } from "../utils/encoding.js";
+
+function normalizeSignedArtifact(artifact = {}) {
+  const normalized = normalizeArtifactDependency(artifact);
+  return {
+    ...normalized,
+    wasm:
+      artifact.wasm === undefined || artifact.wasm === null
+        ? null
+        : toUint8Array(artifact.wasm),
+    manifestBuffer:
+      artifact.manifestBuffer === undefined || artifact.manifestBuffer === null
+        ? null
+        : toUint8Array(artifact.manifestBuffer),
+  };
+}
+
+function preferNonEmptyString(primary, fallback = null) {
+  if (typeof primary === "string" && primary.trim().length > 0) {
+    return primary;
+  }
+  return fallback;
+}
+
+function dependencyKey(dependency) {
+  if (dependency.dependencyId) {
+    return `dependency:${dependency.dependencyId}`;
+  }
+  if (dependency.artifactId) {
+    return `artifact:${dependency.artifactId}`;
+  }
+  if (dependency.pluginId && dependency.version) {
+    return `plugin:${dependency.pluginId}@${dependency.version}`;
+  }
+  if (dependency.pluginId) {
+    return `plugin:${dependency.pluginId}`;
+  }
+  throw new Error(
+    "Signed artifact is missing dependencyId/artifactId/pluginId.",
+  );
+}
+
+export class SignedArtifactCatalog {
+  #artifacts = new Map();
+
+  registerArtifact(artifact) {
+    const normalized = normalizeSignedArtifact(artifact);
+    const key = dependencyKey(normalized);
+    this.#artifacts.set(key, normalized);
+    return normalized;
+  }
+
+  registerArtifacts(artifacts = []) {
+    return artifacts.map((artifact) => this.registerArtifact(artifact));
+  }
+
+  getArtifact(selector) {
+    const normalized = normalizeSignedArtifact(selector);
+    const attemptedKeys = [];
+    for (const key of [
+      normalized.dependencyId ? `dependency:${normalized.dependencyId}` : null,
+      normalized.artifactId ? `artifact:${normalized.artifactId}` : null,
+      normalized.pluginId && normalized.version
+        ? `plugin:${normalized.pluginId}@${normalized.version}`
+        : null,
+      normalized.pluginId ? `plugin:${normalized.pluginId}` : null,
+    ]) {
+      if (!key) {
+        continue;
+      }
+      attemptedKeys.push(key);
+      const artifact = this.#artifacts.get(key);
+      if (artifact) {
+        return artifact;
+      }
+    }
+    throw new Error(
+      `Signed artifact dependency not found in catalog (${attemptedKeys.join(", ")}).`,
+    );
+  }
+
+  async resolveProgramDependencies(program) {
+    const normalizedProgram = normalizeProgram(program);
+    const resolved = [];
+    for (const dependency of normalizedProgram.artifactDependencies) {
+      const artifact = this.getArtifact(dependency);
+      if (!artifact.signature || !artifact.signerPublicKey) {
+        throw new Error(
+          `Signed artifact "${dependency.dependencyId || dependency.pluginId}" is missing signature metadata.`,
+        );
+      }
+      if (!artifact.wasm || artifact.wasm.length === 0) {
+        throw new Error(
+          `Signed artifact "${dependency.dependencyId || dependency.pluginId}" is missing wasm bytes.`,
+        );
+      }
+      const computedSha256 = bytesToHex(await sha256Bytes(artifact.wasm));
+      if (artifact.sha256 && artifact.sha256 !== computedSha256) {
+        throw new Error(
+          `Signed artifact "${dependency.dependencyId || dependency.pluginId}" sha256 mismatch.`,
+        );
+      }
+      resolved.push({
+        ...artifact,
+        ...dependency,
+        wasm: artifact.wasm,
+        manifestBuffer: artifact.manifestBuffer,
+        sha256: artifact.sha256 ?? computedSha256,
+        manifestExports: {
+          bytesSymbol: preferNonEmptyString(
+            dependency.manifestExports?.bytesSymbol,
+            artifact.manifestExports?.bytesSymbol,
+          ),
+          sizeSymbol: preferNonEmptyString(
+            dependency.manifestExports?.sizeSymbol,
+            artifact.manifestExports?.sizeSymbol,
+          ),
+        },
+        runtimeExports: {
+          initSymbol: preferNonEmptyString(
+            dependency.runtimeExports?.initSymbol,
+            artifact.runtimeExports?.initSymbol,
+          ),
+          destroySymbol: preferNonEmptyString(
+            dependency.runtimeExports?.destroySymbol,
+            artifact.runtimeExports?.destroySymbol,
+          ),
+          mallocSymbol: preferNonEmptyString(
+            dependency.runtimeExports?.mallocSymbol,
+            artifact.runtimeExports?.mallocSymbol,
+          ),
+          freeSymbol: preferNonEmptyString(
+            dependency.runtimeExports?.freeSymbol,
+            artifact.runtimeExports?.freeSymbol,
+          ),
+          streamInvokeSymbol: preferNonEmptyString(
+            dependency.runtimeExports?.streamInvokeSymbol,
+            artifact.runtimeExports?.streamInvokeSymbol,
+          ),
+        },
+      });
+    }
+    return resolved;
+  }
+}
+
+export default SignedArtifactCatalog;

package/src/compiler/index.js

@@ -0,0 +1,8 @@
+export { SignedArtifactCatalog } from "./SignedArtifactCatalog.js";
+export { EmceptionCompilerAdapter } from "./EmceptionCompilerAdapter.js";
+export { generateCppFlowRuntimeSource } from "./CppFlowSourceGenerator.js";
+export {
+  ensureNativeFlowSourceGeneratorTool,
+  getNativeFlowSourceGeneratorToolInfo,
+  runNativeFlowSourceGenerator,
+} from "./nativeFlowSourceGeneratorTool.js";

package/src/compiler/nativeFlowSourceGeneratorTool.js

@@ -0,0 +1,144 @@
+import { mkdirSync, statSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const PACKAGE_ROOT = fileURLToPath(new URL("../../", import.meta.url));
+const NATIVE_SOURCE_PATH = fileURLToPath(
+  new URL("../../native/flow_source_generator.cpp", import.meta.url),
+);
+const GENERATED_DIR = fileURLToPath(
+  new URL("../../generated-tools/", import.meta.url),
+);
+const MODULE_PATH = path.join(GENERATED_DIR, "flow-source-generator.mjs");
+const WASM_PATH = path.join(GENERATED_DIR, "flow-source-generator.wasm");
+const EMXX_FLAGS = Object.freeze([
+  "-std=c++20",
+  "-O2",
+  "-sWASM=1",
+  "-sMODULARIZE=1",
+  "-sEXPORT_ES6=1",
+  "-sENVIRONMENT=node",
+  "-sALLOW_MEMORY_GROWTH=1",
+  "-sFORCE_FILESYSTEM=1",
+  "-sEXPORTED_RUNTIME_METHODS=['FS','callMain']",
+]);
+
+function getMtimeMs(filePath) {
+  try {
+    return statSync(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+function toolBuildIsCurrent() {
+  const sourceTime = getMtimeMs(NATIVE_SOURCE_PATH);
+  const moduleTime = getMtimeMs(MODULE_PATH);
+  const wasmTime = getMtimeMs(WASM_PATH);
+  return moduleTime >= sourceTime && wasmTime >= sourceTime;
+}
+
+function assertToolExists() {
+  if (!toolBuildIsCurrent()) {
+    throw new Error(
+      "flow source generator tool is not built. Run ensureNativeFlowSourceGeneratorTool() first.",
+    );
+  }
+}
+
+export function getNativeFlowSourceGeneratorToolInfo() {
+  return {
+    packageRoot: PACKAGE_ROOT,
+    sourcePath: NATIVE_SOURCE_PATH,
+    generatedDir: GENERATED_DIR,
+    modulePath: MODULE_PATH,
+    wasmPath: WASM_PATH,
+    command: ["em++", ...EMXX_FLAGS, NATIVE_SOURCE_PATH, "-o", MODULE_PATH],
+  };
+}
+
+export async function ensureNativeFlowSourceGeneratorTool({
+  force = false,
+} = {}) {
+  mkdirSync(GENERATED_DIR, { recursive: true });
+  if (!force && toolBuildIsCurrent()) {
+    return getNativeFlowSourceGeneratorToolInfo();
+  }
+
+  const result = spawnSync(
+    "em++",
+    [...EMXX_FLAGS, NATIVE_SOURCE_PATH, "-o", MODULE_PATH],
+    {
+      cwd: PACKAGE_ROOT,
+      encoding: "utf8",
+      maxBuffer: 16 * 1024 * 1024,
+    },
+  );
+  if (result.error) {
+    throw new Error(
+      `failed to run em++ for flow source generator: ${result.error.message}`,
+    );
+  }
+  if ((result.status ?? 1) !== 0) {
+    throw new Error(
+      `failed to build flow source generator wasm tool:\n${result.stdout ?? ""}${result.stderr ?? ""}`,
+    );
+  }
+
+  assertToolExists();
+  return getNativeFlowSourceGeneratorToolInfo();
+}
+
+async function importToolModule(modulePath) {
+  const moduleUrl = `${pathToFileURL(modulePath).href}?v=${getMtimeMs(modulePath)}`;
+  return import(moduleUrl);
+}
+
+export async function runNativeFlowSourceGenerator(requestBytes, options = {}) {
+  const tool = await ensureNativeFlowSourceGeneratorTool(options);
+  const toolModule = await importToolModule(tool.modulePath);
+  const stdout = [];
+  const stderr = [];
+  const generator = await toolModule.default({
+    locateFile(file) {
+      return path.join(tool.generatedDir, file);
+    },
+    print(...args) {
+      stdout.push(args.join(" "));
+    },
+    printErr(...args) {
+      stderr.push(args.join(" "));
+    },
+  });
+
+  generator.FS.writeFile("/request.bin", requestBytes);
+  let exitError = null;
+  try {
+    generator.callMain(["/request.bin", "/output.cpp"]);
+  } catch (error) {
+    exitError = error;
+  }
+
+  if (!generator.FS.analyzePath("/output.cpp").exists) {
+    const details = stderr.join("\n");
+    if (exitError) {
+      throw new Error(
+        `native flow source generator failed: ${exitError.message}\n${details}`.trim(),
+      );
+    }
+    throw new Error(
+      `native flow source generator did not produce output.\n${details}`.trim(),
+    );
+  }
+
+  return {
+    source: generator.FS.readFile("/output.cpp", { encoding: "utf8" }),
+    stdout: stdout.join("\n"),
+    stderr: stderr.join("\n"),
+    tool,
+    generatorModel: "native-cpp-wasm",
+  };
+}
+
+export default runNativeFlowSourceGenerator;

package/src/compliance/index.js

@@ -0,0 +1,13 @@
+export {
+  findManifestFiles,
+  getWasmExportNames,
+  getWasmExportNamesFromFile,
+  loadManifestFromFile,
+  loadComplianceConfig,
+  RecommendedCapabilityIds,
+  resolveManifestFiles,
+  validateArtifactWithStandards,
+  validateManifestWithStandards,
+  validatePluginArtifact,
+  validatePluginManifest,
+} from "space-data-module-sdk/compliance";

package/src/compliance/pluginCompliance.js

@@ -0,0 +1,11 @@
+export {
+  findManifestFiles,
+  getWasmExportNames,
+  getWasmExportNamesFromFile,
+  loadManifestFromFile,
+  loadComplianceConfig,
+  RecommendedCapabilityIds,
+  resolveManifestFiles,
+  validatePluginArtifact,
+  validatePluginManifest,
+} from "space-data-module-sdk/compliance";