space-data-module-sdk 0.5.14 → 0.5.18

package/src/runtime-host/runtimeRegionStore.js

@@ -0,0 +1,245 @@
+function cloneBytes(bytes) {
+  return new Uint8Array(bytes);
+}
+
+function normalizePositiveInteger(value, label) {
+  const normalized = Number(value);
+  if (!Number.isInteger(normalized) || normalized < 0) {
+    throw new TypeError(`${label} must be a non-negative integer`);
+  }
+  return normalized;
+}
+
+function normalizeStrictlyPositiveInteger(value, label) {
+  const normalized = Number(value);
+  if (!Number.isInteger(normalized) || normalized <= 0) {
+    throw new TypeError(`${label} must be a positive integer`);
+  }
+  return normalized;
+}
+
+function normalizeRequiredString(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TypeError(`${label} must be a non-empty string`);
+  }
+  return value.trim();
+}
+
+function normalizeOptionalFunction(value, label) {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (typeof value !== "function") {
+    throw new TypeError(`${label} must be a function`);
+  }
+  return value;
+}
+
+function toRecordBytes(value, recordByteLength) {
+  const bytes = new Uint8Array(recordByteLength);
+  if (value === null || value === undefined) {
+    return bytes;
+  }
+  if (ArrayBuffer.isView(value)) {
+    const view = value;
+    if (view.byteLength > recordByteLength) {
+      throw new RangeError("record bytes exceed recordByteLength");
+    }
+    bytes.set(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+    return bytes;
+  }
+  if (value instanceof ArrayBuffer) {
+    if (value.byteLength > recordByteLength) {
+      throw new RangeError("record bytes exceed recordByteLength");
+    }
+    bytes.set(new Uint8Array(value));
+    return bytes;
+  }
+  throw new TypeError("runtime region records must be byte-oriented");
+}
+
+export function createRuntimeRegionStore() {
+  let nextRegionId = 1;
+  const regions = new Map();
+
+  function getRegionRecordCount(region) {
+    if (typeof region.getRecordCount === "function") {
+      return normalizePositiveInteger(
+        region.getRecordCount(region.regionId),
+        "recordCount",
+      );
+    }
+    return region.records.length;
+  }
+
+  function describeRegion(regionId) {
+    const normalizedRegionId = normalizePositiveInteger(regionId, "regionId");
+    const region = regions.get(normalizedRegionId);
+    if (!region) {
+      return null;
+    }
+    return {
+      regionId: region.regionId,
+      layoutId: region.layoutId,
+      recordByteLength: region.recordByteLength,
+      alignment: region.alignment,
+      recordCount: getRegionRecordCount(region),
+    };
+  }
+
+  function allocateRegion({
+    layoutId,
+    recordByteLength,
+    alignment = 1,
+    initialRecords = [],
+  }) {
+    const region = {
+      regionId: nextRegionId++,
+      kind: "owned",
+      layoutId: normalizeRequiredString(layoutId, "layoutId"),
+      recordByteLength: normalizeStrictlyPositiveInteger(
+        recordByteLength,
+        "recordByteLength",
+      ),
+      alignment: normalizeStrictlyPositiveInteger(alignment, "alignment"),
+      records: [],
+    };
+    region.records = Array.from(initialRecords, (record) =>
+      toRecordBytes(record, region.recordByteLength),
+    );
+    regions.set(region.regionId, region);
+    return describeRegion(region.regionId);
+  }
+
+  function registerExternalRegion({
+    layoutId,
+    recordByteLength,
+    alignment = 1,
+    recordCount = 0,
+    getRecordCount,
+    resolveRecordView,
+  }) {
+    const region = {
+      regionId: nextRegionId++,
+      kind: "external",
+      layoutId: normalizeRequiredString(layoutId, "layoutId"),
+      recordByteLength: normalizeStrictlyPositiveInteger(
+        recordByteLength,
+        "recordByteLength",
+      ),
+      alignment: normalizeStrictlyPositiveInteger(alignment, "alignment"),
+      records: [],
+      getRecordCount: normalizeOptionalFunction(getRecordCount, "getRecordCount"),
+      resolveRecordView: normalizeOptionalFunction(
+        resolveRecordView,
+        "resolveRecordView",
+      ),
+    };
+    if (region.getRecordCount === undefined) {
+      region.records.length = normalizePositiveInteger(recordCount, "recordCount");
+    }
+    regions.set(region.regionId, region);
+    return describeRegion(region.regionId);
+  }
+
+  function setRegionRecordCount(regionId, recordCount) {
+    const normalizedRegionId = normalizePositiveInteger(regionId, "regionId");
+    const region = regions.get(normalizedRegionId);
+    if (!region) {
+      return null;
+    }
+    if (typeof region.getRecordCount === "function") {
+      throw new Error("Cannot set recordCount for externally counted regions");
+    }
+    const normalizedRecordCount = normalizePositiveInteger(
+      recordCount,
+      "recordCount",
+    );
+    if (normalizedRecordCount < region.records.length) {
+      region.records.length = normalizedRecordCount;
+    } else {
+      while (region.records.length < normalizedRecordCount) {
+        region.records.push(new Uint8Array(region.recordByteLength));
+      }
+    }
+    return describeRegion(normalizedRegionId);
+  }
+
+  function resolveRecord({ regionId, recordIndex }) {
+    const normalizedRegionId = normalizePositiveInteger(regionId, "regionId");
+    const normalizedRecordIndex = normalizePositiveInteger(
+      recordIndex,
+      "recordIndex",
+    );
+    const region = regions.get(normalizedRegionId);
+    if (!region) {
+      return null;
+    }
+    if (normalizedRecordIndex >= getRegionRecordCount(region)) {
+      return null;
+    }
+    if (region.kind === "external") {
+      return null;
+    }
+    return {
+      regionId: region.regionId,
+      recordIndex: normalizedRecordIndex,
+      layoutId: region.layoutId,
+      recordByteLength: region.recordByteLength,
+      alignment: region.alignment,
+      byteLength: region.recordByteLength,
+      bytes: cloneBytes(region.records[normalizedRecordIndex]),
+    };
+  }
+
+  function resolveRecordView({ regionId, recordIndex }) {
+    const normalizedRegionId = normalizePositiveInteger(regionId, "regionId");
+    const normalizedRecordIndex = normalizePositiveInteger(
+      recordIndex,
+      "recordIndex",
+    );
+    const region = regions.get(normalizedRegionId);
+    if (!region) {
+      return null;
+    }
+    if (normalizedRecordIndex >= getRegionRecordCount(region)) {
+      return null;
+    }
+    if (region.kind !== "external") {
+      return resolveRecord({
+        regionId: normalizedRegionId,
+        recordIndex: normalizedRecordIndex,
+      });
+    }
+    if (typeof region.resolveRecordView !== "function") {
+      return null;
+    }
+    const view = region.resolveRecordView({
+      regionId: normalizedRegionId,
+      recordIndex: normalizedRecordIndex,
+      layoutId: region.layoutId,
+      recordByteLength: region.recordByteLength,
+      alignment: region.alignment,
+    });
+    if (view === null || view === undefined) {
+      return null;
+    }
+    return {
+      regionId: normalizedRegionId,
+      recordIndex: normalizedRecordIndex,
+      layoutId: region.layoutId,
+      recordByteLength: region.recordByteLength,
+      alignment: region.alignment,
+      ...view,
+    };
+  }
+
+  return {
+    allocateRegion,
+    describeRegion,
+    registerExternalRegion,
+    resolveRecord,
+    resolveRecordView,
+    setRegionRecordCount,
+  };
+}

package/src/testing/buildWasmEdgeRunner.js

@@ -0,0 +1,253 @@
+import { accessSync, existsSync } from "node:fs";
+import { execFile } from "node:child_process";
+import os from "node:os";
+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",
+  );
+}
+
+function resolveDefaultWasmEdgeInstall() {
+  const home = os.homedir();
+  const candidates = [
+    {
+      includeDir: path.join(home, ".wasmedge", "include"),
+      libDir: path.join(home, ".wasmedge", "lib"),
+    },
+    {
+      includeDir: "/opt/homebrew/include",
+      libDir: "/opt/homebrew/opt/wasmedge/lib",
+    },
+    {
+      includeDir: "/usr/local/include",
+      libDir: "/usr/local/lib",
+    },
+  ];
+  for (const candidate of candidates) {
+    const header = path.join(
+      candidate.includeDir,
+      "wasmedge",
+      "enum_configure.h",
+    );
+    const library = path.join(
+      candidate.libDir,
+      resolveWasmEdgeSharedLibraryFilename(),
+    );
+    if (existsSync(header) && existsSync(library)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+export function resolveWasmEdgeRunnerBuildPlan(options = {}) {
+  const detectedInstall = resolveDefaultWasmEdgeInstall();
+  const requestedIncludeDir = normalizeResolvedPath(
+    options.wasmedgeIncludeDir ??
+      process.env.WASMEDGE_INCLUDE_DIR ??
+      detectedInstall?.includeDir,
+  );
+  const wasmedgeLibDir = normalizeResolvedPath(
+    options.wasmedgeLibDir ??
+      process.env.WASMEDGE_LIB_DIR ??
+      detectedInstall?.libDir,
+  );
+  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;
+}