relaxnative 0.1.0-beta.1

package/dist/chunk-VSP234PR.js

@@ -0,0 +1,627 @@
+import {
+  alloc,
+  compileWithCache,
+  detectCompilers,
+  detectLanguage,
+  loadNative,
+  loadNativeWithBindings,
+  parseNativeSource
+} from "./chunk-V74SNTE6.js";
+import {
+  loadFfi
+} from "./chunk-ZPPXCDSH.js";
+
+// src/registry/registryPaths.ts
+import { join, resolve } from "path";
+function getProjectRoot(cwd = process.cwd()) {
+  return cwd;
+}
+function getRegistryRoot(projectRoot = getProjectRoot()) {
+  return join(projectRoot, "native", "registry");
+}
+function getInstalledPackageDir(pkg, projectRoot = getProjectRoot()) {
+  return join(getRegistryRoot(projectRoot), pkg);
+}
+function resolveRegistryImport(specifier, projectRoot = getProjectRoot()) {
+  const prefix = "relaxnative/";
+  if (!specifier.startsWith(prefix)) return null;
+  const pkg = specifier.slice(prefix.length);
+  return resolve(getInstalledPackageDir(pkg, projectRoot));
+}
+
+// src/registry/relaxJson.ts
+import { readFileSync } from "fs";
+import { join as join2 } from "path";
+function readRelaxJson(pkgDir) {
+  const jsonPath = join2(pkgDir, "relax.json");
+  const raw = readFileSync(jsonPath, "utf8");
+  const parsed = JSON.parse(raw);
+  if (!parsed?.name || !parsed?.version || !Array.isArray(parsed?.exports)) {
+    throw new Error(`Invalid relax.json at ${jsonPath}`);
+  }
+  return parsed;
+}
+
+// src/registry/installer.ts
+import {
+  mkdirSync,
+  readFileSync as readFileSync3,
+  rmSync,
+  writeFileSync,
+  existsSync,
+  readdirSync
+} from "fs";
+import { join as join3 } from "path";
+
+// src/registry/staticScan.ts
+import { readFileSync as readFileSync2 } from "fs";
+function staticScanNativeSource(sourcePath) {
+  const src = readFileSync2(sourcePath, "utf8");
+  const lines = src.split(/\r?\n/);
+  const rules = [
+    {
+      rule: "process-spawn",
+      re: /\b(system|popen|fork|execv|execve|execvp|execvpe|execl|execlp|CreateProcessW|WinExec)\b/,
+      message: "Potential process execution API found"
+    },
+    {
+      rule: "raw-syscall",
+      re: /\b(syscall|__syscall)\b/,
+      message: "Raw syscall usage found"
+    },
+    {
+      rule: "file-io",
+      re: /\b(fopen|open|CreateFileW|unlink|remove|rename)\b/,
+      message: "Potential filesystem API found"
+    },
+    {
+      rule: "network",
+      re: /\b(socket|connect|bind|listen|accept|recv|send|getaddrinfo)\b/,
+      message: "Potential network API found"
+    },
+    {
+      rule: "w-x-memory",
+      re: /\b(mprotect|VirtualProtect|PROT_EXEC|PAGE_EXECUTE_READWRITE)\b/,
+      message: "Writable/executable memory pattern found"
+    },
+    {
+      rule: "dynamic-loader",
+      re: /\b(dlopen|LoadLibraryA|LoadLibraryW)\b/,
+      message: "Dynamic loader API found"
+    }
+  ];
+  const findings = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const r of rules) {
+      if (r.re.test(line)) {
+        findings.push({ rule: r.rule, message: r.message, line: i + 1 });
+      }
+    }
+  }
+  return findings;
+}
+
+// src/registry/installer.ts
+function installPackage(pkgSpecifier, projectRoot = process.cwd()) {
+  const warnings = [];
+  const registryRoot = getRegistryRoot(projectRoot);
+  mkdirSync(registryRoot, { recursive: true });
+  const isFile = pkgSpecifier.startsWith("file:");
+  if (!isFile) {
+    throw new Error(
+      `Only file: installs are supported right now (deterministic, offline). Got: ${pkgSpecifier}`
+    );
+  }
+  const srcDir = pkgSpecifier.slice("file:".length);
+  const manifest = readRelaxJson(srcDir);
+  const destDir = getInstalledPackageDir(manifest.name, projectRoot);
+  rmSync(destDir, { recursive: true, force: true });
+  mkdirSync(destDir, { recursive: true });
+  writeFileSync(join3(destDir, "relax.json"), readFileSync3(join3(srcDir, "relax.json")));
+  for (const exp of manifest.exports) {
+    const srcPath = join3(srcDir, exp.source);
+    const dstPath = join3(destDir, exp.source);
+    mkdirSync(join3(dstPath, ".."), { recursive: true });
+    if (!existsSync(srcPath)) {
+      throw new Error(`Missing export source: ${srcPath}`);
+    }
+    const findings = staticScanNativeSource(srcPath);
+    for (const f of findings) {
+      warnings.push(`${exp.source}:${f.line ?? "?"} ${f.rule}: ${f.message}`);
+    }
+    writeFileSync(dstPath, readFileSync3(srcPath));
+  }
+  return { pkg: manifest.name, dir: destDir, warnings };
+}
+function removePackage(pkg, projectRoot = process.cwd()) {
+  const destDir = getInstalledPackageDir(pkg, projectRoot);
+  rmSync(destDir, { recursive: true, force: true });
+}
+function listPackages(projectRoot = process.cwd()) {
+  const root = getRegistryRoot(projectRoot);
+  if (!existsSync(root)) return [];
+  return readdirSync(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+}
+function updateIndex(projectRoot = process.cwd()) {
+  const root = getRegistryRoot(projectRoot);
+  if (!existsSync(root)) return;
+  const pkgs = listPackages(projectRoot);
+  writeFileSync(join3(root, ".index"), pkgs.join("\n") + (pkgs.length ? "\n" : ""));
+}
+
+// src/nativeTestHarness.ts
+import { readdirSync as readdirSync2, existsSync as existsSync2, readFileSync as readFileSync4 } from "fs";
+import { extname, join as join4 } from "path";
+var NATIVE_EXTS = /* @__PURE__ */ new Set([".c", ".cpp", ".cc", ".cxx", ".rs"]);
+function isNativeFile(p) {
+  return NATIVE_EXTS.has(extname(p));
+}
+function discoverNativeTestFiles(rootDir) {
+  const out = [];
+  function walk(dir) {
+    for (const ent of readdirSync2(dir, { withFileTypes: true })) {
+      const p = join4(dir, ent.name);
+      if (ent.isDirectory()) walk(p);
+      else if (ent.isFile() && isNativeFile(p)) out.push(p);
+    }
+  }
+  if (!existsSync2(rootDir)) return [];
+  walk(rootDir);
+  out.sort((a, b) => {
+    const at = /_test\./.test(a) ? 0 : 1;
+    const bt = /_test\./.test(b) ? 0 : 1;
+    return at - bt || a.localeCompare(b);
+  });
+  return out;
+}
+function discoverNativeTestsFromFile(sourcePath) {
+  const src = readFileSync4(sourcePath, "utf8");
+  const lines = src.split(/\r?\n/);
+  const out = [];
+  const re = /^(?:\s*)(const\s+char\s*\*|int)\s+(test_[A-Za-z0-9_]+)\s*\(/;
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(re);
+    if (!m) continue;
+    const ret = m[1];
+    const name = m[2];
+    const kind = /^int\b/.test(ret) ? "int" : "cstring";
+    out.push({ name, sourcePath, line: i + 1, kind });
+  }
+  if (out.length) return out;
+  const language = detectLanguage(sourcePath);
+  const bindings = parseNativeSource(sourcePath, language);
+  const tests = [];
+  for (const [name, fn] of Object.entries(bindings.functions ?? {})) {
+    if (!name.startsWith("test_")) continue;
+    const ret = fn.returns;
+    const kind = ret === "int" || ret === "uint" || ret === "long" || ret === "size_t" ? "int" : "cstring";
+    tests.push({
+      name,
+      sourcePath,
+      line: fn.sourceLine,
+      kind
+    });
+  }
+  return tests;
+}
+function discoverNativeTests(rootDir) {
+  const files = discoverNativeTestFiles(rootDir);
+  const all = [];
+  for (const f of files) {
+    all.push(...discoverNativeTestsFromFile(f));
+  }
+  return all;
+}
+function formatLocation(sourcePath, line) {
+  if (!line) return sourcePath;
+  return `${sourcePath}:${line}`;
+}
+function formatNativeTestResults(results) {
+  const lines = [];
+  for (const r of results) {
+    if (r.ok) {
+      lines.push(`\u2713 ${r.name}`);
+    } else {
+      const loc = formatLocation(r.sourcePath, r.line);
+      const msg = r.message ? ` (${r.message})` : "";
+      lines.push(`\u2717 ${r.name}${msg}`);
+      lines.push(`  at ${loc}`);
+    }
+  }
+  const passed = results.filter((r) => r.ok).length;
+  const failed = results.length - passed;
+  lines.push("");
+  lines.push(`${passed} passed, ${failed} failed`);
+  return lines.join("\n");
+}
+async function runNativeTests(rootDir, opts) {
+  const isolation = opts?.isolation ?? "in-process";
+  const tests = discoverNativeTests(rootDir);
+  if (!tests.length) {
+    return { results: [], exitCode: 0 };
+  }
+  const { c, rust, platform } = detectCompilers();
+  const byFile = /* @__PURE__ */ new Map();
+  for (const t of tests) {
+    const arr = byFile.get(t.sourcePath) ?? [];
+    arr.push(t);
+    byFile.set(t.sourcePath, arr);
+  }
+  const results = [];
+  for (const [sourcePath, cases] of byFile) {
+    const language = detectLanguage(sourcePath);
+    const compiler = language === "rust" ? rust : c;
+    if (!compiler) throw new Error(`No compiler for ${language}`);
+    const compileRes = compileWithCache(compiler, platform, {
+      sourcePath,
+      outDir: ".cache/native"
+    });
+    let api;
+    if (isolation === "in-process") {
+      const bindings = parseNativeSource(sourcePath, language);
+      api = loadFfi(compileRes.outputPath, bindings);
+    } else {
+      const synth = {
+        functions: Object.fromEntries(
+          cases.map((tc) => [
+            tc.name,
+            {
+              name: tc.name,
+              // Note: mapType supports "char*" (and "cstring" used to), but
+              // some environments/version combos reject "cstring" when sent
+              // across worker/process boundaries. Use a stable alias.
+              returns: tc.kind === "int" ? "int" : "char*",
+              args: [],
+              mode: "sync",
+              cost: "low"
+            }
+          ])
+        )
+      };
+      const { mod } = await loadNativeWithBindings(sourcePath, {
+        isolation,
+        mutateBindings(bindings) {
+          bindings.functions = synth.functions;
+        }
+      });
+      api = mod;
+    }
+    for (const tc of cases) {
+      const fn = api[tc.name];
+      if (typeof fn !== "function") {
+        results.push({
+          name: tc.name,
+          ok: false,
+          message: `Function not found: ${tc.name}`,
+          sourcePath: tc.sourcePath,
+          line: tc.line,
+          durationMs: 0
+        });
+        continue;
+      }
+      const start = process.hrtime.bigint();
+      let ok = false;
+      let message;
+      try {
+        const out = fn();
+        const awaited = out instanceof Promise ? await out : out;
+        if (tc.kind === "int") {
+          ok = Number(awaited) === 0;
+          if (!ok) message = `returned ${String(awaited)}`;
+        } else {
+          ok = awaited == null || String(awaited).length === 0;
+          if (!ok) message = String(awaited);
+        }
+      } catch (err) {
+        ok = false;
+        message = err?.message ?? String(err);
+      }
+      const end = process.hrtime.bigint();
+      const durationMs = Number(end - start) / 1e6;
+      results.push({
+        name: tc.name,
+        ok,
+        message,
+        sourcePath: tc.sourcePath,
+        line: tc.line,
+        durationMs
+      });
+    }
+  }
+  const failed = results.some((r) => !r.ok);
+  return { results, exitCode: failed ? 1 : 0 };
+}
+function getSourceLine(sourcePath, line) {
+  if (!line) return null;
+  try {
+    const src = readFileSync4(sourcePath, "utf8");
+    const lines = src.split(/\r?\n/);
+    return lines[line - 1] ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/benchmark.ts
+function nowNs() {
+  return process.hrtime.bigint();
+}
+function nsToMs(ns) {
+  return Number(ns) / 1e6;
+}
+function assertSafeRun(iterations) {
+  if (iterations > 2e6) {
+    throw new Error(
+      `Refusing to run benchmark with iterations=${iterations} (cap=2,000,000). Pass a smaller value.`
+    );
+  }
+}
+async function benchmarkJsFunction(name, fn, opts) {
+  const iterations = opts?.iterations ?? 1e5;
+  const warmup = opts?.warmup ?? Math.min(1e4, Math.max(100, Math.floor(iterations * 0.05)));
+  assertSafeRun(iterations);
+  const args = Array.isArray(opts?.args) ? opts.args : fn.length === 0 ? [] : [1, 2];
+  for (let i = 0; i < warmup; i++) {
+    const out = fn(...args);
+    if (out instanceof Promise) await out;
+  }
+  const latencies = [];
+  const startAll = nowNs();
+  for (let i = 0; i < iterations; i++) {
+    const t0 = nowNs();
+    const out = fn(...args);
+    if (out instanceof Promise) await out;
+    const t1 = nowNs();
+    latencies.push(nsToMs(t1 - t0));
+  }
+  const endAll = nowNs();
+  const totalMs = nsToMs(endAll - startAll);
+  let min = Infinity;
+  let max = -Infinity;
+  let sum = 0;
+  for (const l of latencies) {
+    if (l < min) min = l;
+    if (l > max) max = l;
+    sum += l;
+  }
+  const avg = sum / latencies.length;
+  const callsPerSec = iterations / (totalMs / 1e3);
+  return {
+    name,
+    iterations,
+    warmup,
+    callsPerSec,
+    avgLatencyMs: avg,
+    minLatencyMs: min,
+    maxLatencyMs: max
+  };
+}
+function getBuiltInBaseline(fnName) {
+  if (fnName === "add") {
+    return {
+      name: "traditional-js",
+      fn: (a, b) => a + b,
+      defaultArgs: [1, 2]
+    };
+  }
+  if (fnName === "loop_sum") {
+    return {
+      name: "traditional-js",
+      fn: (n) => {
+        let acc = 0;
+        for (let i = 0; i < n; i++) {
+          acc += (i ^ 2654435769) & 65535;
+        }
+        return acc;
+      },
+      // default to a CPU-heavy iteration count so native has a chance to win
+      defaultArgs: [5e7]
+    };
+  }
+  if (fnName === "sum_u8") {
+    return {
+      name: "traditional-js",
+      fn: (buf, n) => {
+        let s = 0;
+        for (let i = 0; i < n; i++) s += buf[i];
+        return s;
+      },
+      // Default to 64MB. Big enough that native often has a chance to win.
+      defaultArgs: [new Uint8Array(64 * 1024 * 1024).fill(1), 64 * 1024 * 1024]
+    };
+  }
+  if (fnName === "dot_f32") {
+    const n = 8e6;
+    const a = new Float32Array(n);
+    const b = new Float32Array(n);
+    for (let i = 0; i < n; i++) {
+      a[i] = i % 1024 * 1e-3;
+      b[i] = i % 2048 * 2e-3;
+    }
+    return {
+      name: "traditional-js",
+      fn: (aa, bb, nn) => {
+        let acc = 0;
+        for (let i = 0; i < nn; i++) acc += aa[i] * bb[i];
+        return acc;
+      },
+      defaultArgs: [a, b, n]
+    };
+  }
+  return null;
+}
+function pickArgs(fnName, jsArity, callerArgs) {
+  if (Array.isArray(callerArgs)) return callerArgs;
+  const builtIn = getBuiltInBaseline(fnName);
+  if (builtIn) return builtIn.defaultArgs;
+  return jsArity === 0 ? [] : [1, 2];
+}
+function mapArgsForNative(fnName, args) {
+  if (fnName === "sum_u8") {
+    const buf = args[0];
+    const n = args[1];
+    if (buf && typeof n === "number" && ArrayBuffer.isView(buf)) {
+      const nb = alloc(buf.byteLength);
+      nb.write(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
+      return [nb, n];
+    }
+  }
+  if (fnName === "dot_f32") {
+    const a = args[0];
+    const b = args[1];
+    const n = args[2];
+    if (a && b && typeof n === "number" && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+      const na = alloc(a.byteLength);
+      na.write(new Uint8Array(a.buffer, a.byteOffset, a.byteLength));
+      const nb = alloc(b.byteLength);
+      nb.write(new Uint8Array(b.buffer, b.byteOffset, b.byteLength));
+      return [na, nb, n];
+    }
+  }
+  return args;
+}
+async function benchmarkNativeFunction(nativePath, fnName, opts) {
+  const iterations = opts?.iterations ?? 1e5;
+  const warmup = opts?.warmup ?? Math.min(1e4, Math.max(100, Math.floor(iterations * 0.05)));
+  const mode = opts?.mode ?? "sync";
+  assertSafeRun(iterations);
+  const isolation = mode === "worker" ? "worker" : "in-process";
+  const mod = await loadNative(nativePath, { isolation });
+  const fn = mod?.[fnName];
+  if (typeof fn !== "function") {
+    throw new Error(`Function not found: ${fnName}`);
+  }
+  const args = mapArgsForNative(fnName, pickArgs(fnName, fn.length, opts?.args));
+  for (let i = 0; i < warmup; i++) {
+    const out = fn(...args);
+    if (out instanceof Promise) await out;
+  }
+  const latencies = [];
+  const startAll = nowNs();
+  for (let i = 0; i < iterations; i++) {
+    const t0 = nowNs();
+    const out = fn(...args);
+    if (out instanceof Promise) await out;
+    const t1 = nowNs();
+    latencies.push(nsToMs(t1 - t0));
+  }
+  const endAll = nowNs();
+  const totalMs = nsToMs(endAll - startAll);
+  let min = Infinity;
+  let max = -Infinity;
+  let sum = 0;
+  for (const l of latencies) {
+    if (l < min) min = l;
+    if (l > max) max = l;
+    sum += l;
+  }
+  const avg = sum / latencies.length;
+  const callsPerSec = iterations / (totalMs / 1e3);
+  return {
+    fnName,
+    mode,
+    iterations,
+    warmup,
+    callsPerSec,
+    avgLatencyMs: avg,
+    minLatencyMs: min,
+    maxLatencyMs: max
+  };
+}
+async function benchmarkCompareSyncVsWorker(nativePath, fnName, opts) {
+  const sync = await benchmarkNativeFunction(nativePath, fnName, {
+    ...opts,
+    mode: "sync"
+  });
+  const worker = await benchmarkNativeFunction(nativePath, fnName, {
+    ...opts,
+    mode: "worker"
+  });
+  return { sync, worker };
+}
+async function benchmarkCompareTraditionalVsRelaxnative(nativePath, fnName, opts) {
+  const builtIn = getBuiltInBaseline(fnName);
+  const baseline = opts?.baseline ?? builtIn?.fn ?? (() => {
+    throw new Error(
+      `No default baseline for fn=${fnName}. Provide opts.baseline to benchmark \u201Ctraditional programming\u201D for this function.`
+    );
+  })();
+  const baselineName = opts?.baselineName ?? builtIn?.name ?? "traditional-js";
+  const traditional = await benchmarkJsFunction(baselineName, baseline, {
+    iterations: opts?.iterations,
+    warmup: opts?.warmup,
+    args: pickArgs(fnName, baseline.length, opts?.args)
+  });
+  const relaxnative = await benchmarkCompareSyncVsWorker(nativePath, fnName, opts);
+  return { traditional, relaxnative };
+}
+function formatBenchmarkResult(r) {
+  const f = (n) => Number.isFinite(n) ? n.toFixed(3) : String(n);
+  return [
+    `${r.fnName} (${r.mode})`,
+    `  iterations: ${r.iterations} (warmup ${r.warmup})`,
+    `  calls/sec:   ${f(r.callsPerSec)}`,
+    `  avg ms:      ${f(r.avgLatencyMs)}`,
+    `  min ms:      ${f(r.minLatencyMs)}`,
+    `  max ms:      ${f(r.maxLatencyMs)}`
+  ].join("\n");
+}
+function formatBenchmarkCompare(res) {
+  return [formatBenchmarkResult(res.sync), "", formatBenchmarkResult(res.worker)].join("\n");
+}
+function formatBenchmarkTraditionalCompare(res) {
+  const f = (n) => Number.isFinite(n) ? n.toFixed(3) : String(n);
+  const t = res.traditional;
+  const speedup = (relax) => {
+    if (!Number.isFinite(relax) || !Number.isFinite(t.callsPerSec) || t.callsPerSec <= 0) return "n/a";
+    const s = relax / t.callsPerSec;
+    return s.toFixed(2) + "x";
+  };
+  const traditionalBlock = [
+    `${t.name} (baseline)`,
+    `  iterations: ${t.iterations} (warmup ${t.warmup})`,
+    `  calls/sec:   ${f(t.callsPerSec)}`,
+    `  avg ms:      ${f(t.avgLatencyMs)}`,
+    `  min ms:      ${f(t.minLatencyMs)}`,
+    `  max ms:      ${f(t.maxLatencyMs)}`
+  ].join("\n");
+  const summary = [
+    "Speedup vs baseline (higher is better)",
+    `  sync:   ${speedup(res.relaxnative.sync.callsPerSec)}`,
+    `  worker: ${speedup(res.relaxnative.worker.callsPerSec)}`
+  ].join("\n");
+  return [
+    traditionalBlock,
+    "",
+    summary,
+    "",
+    formatBenchmarkResult(res.relaxnative.sync),
+    "",
+    formatBenchmarkResult(res.relaxnative.worker)
+  ].join("\n");
+}
+
+export {
+  getProjectRoot,
+  getRegistryRoot,
+  getInstalledPackageDir,
+  resolveRegistryImport,
+  readRelaxJson,
+  installPackage,
+  removePackage,
+  listPackages,
+  updateIndex,
+  discoverNativeTestFiles,
+  discoverNativeTestsFromFile,
+  discoverNativeTests,
+  formatNativeTestResults,
+  runNativeTests,
+  getSourceLine,
+  benchmarkNativeFunction,
+  benchmarkCompareSyncVsWorker,
+  benchmarkCompareTraditionalVsRelaxnative,
+  formatBenchmarkResult,
+  formatBenchmarkCompare,
+  formatBenchmarkTraditionalCompare
+};