relaxnative 0.1.0-beta.1

package/dist/chunk-WH4JPUWF.js

@@ -0,0 +1,598 @@
+import {
+  wrapFunctions
+} from "./chunk-Y7OSHR6W.js";
+import {
+  loadFfi
+} from "./chunk-WXCN2QJ7.js";
+
+// src/compiler/detectPlatform.ts
+function detectPlatform() {
+  const platform = process.platform;
+  const arch = process.arch;
+  return {
+    platform,
+    arch,
+    isWindows: platform === "win32",
+    isMac: platform === "darwin",
+    isLinux: platform === "linux"
+  };
+}
+
+// src/compiler/detectCCompiler.ts
+import { execFileSync } from "child_process";
+
+// src/utils/which.ts
+import { accessSync, constants } from "fs";
+import { delimiter } from "path";
+function which(cmd) {
+  const paths = process.env.PATH?.split(delimiter) ?? [];
+  for (const p of paths) {
+    const full = `${p}/${cmd}`;
+    try {
+      accessSync(full, constants.X_OK);
+      return full;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/compiler/detectCCompiler.ts
+function getVersion(path) {
+  try {
+    return execFileSync(path, ["--version"], { encoding: "utf8" }).split("\n")[0].trim();
+  } catch {
+    return "unknown";
+  }
+}
+function detectCCompiler() {
+  const candidates = [
+    process.env.CC,
+    "clang",
+    "gcc",
+    "cc",
+    "cl"
+  ].filter(Boolean);
+  for (const name of candidates) {
+    const resolved = name.includes("/") ? name : which(name);
+    if (!resolved) continue;
+    const version = getVersion(resolved);
+    return {
+      kind: "c",
+      path: resolved,
+      version,
+      vendor: resolved.includes("clang") ? "clang" : resolved.includes("gcc") ? "gcc" : resolved.includes("cl") ? "msvc" : "unknown"
+    };
+  }
+  throw new Error("No C compiler found (gcc/clang/cl)");
+}
+
+// src/compiler/detectRustCompiler.ts
+import { execFileSync as execFileSync2 } from "child_process";
+function detectRustCompiler() {
+  const rustc = process.env.RUSTC ?? which("rustc");
+  if (!rustc) return null;
+  const version = execFileSync2(rustc, ["--version"], {
+    encoding: "utf8"
+  }).trim();
+  return {
+    kind: "rust",
+    path: rustc,
+    version,
+    vendor: "rust"
+  };
+}
+
+// src/compiler/sanityCheck.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import { writeFileSync, mkdtempSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+function sanityCheckC(compiler) {
+  const dir = mkdtempSync(join(tmpdir(), "relaxnative-"));
+  const source = join(dir, "test.c");
+  const output = join(dir, "test");
+  writeFileSync(source, "int main(){return 0;}");
+  try {
+    execFileSync3(
+      compiler.path,
+      compiler.vendor === "msvc" ? [source] : [source, "-o", output],
+      { stdio: "ignore" }
+    );
+  } catch (err) {
+    throw new Error(
+      `C compiler failed sanity check: ${compiler.path}`
+    );
+  }
+}
+
+// src/compiler/detect.ts
+function detectCompilers() {
+  const platform = detectPlatform();
+  const c = detectCCompiler();
+  sanityCheckC(c);
+  const rust = detectRustCompiler();
+  return {
+    platform,
+    c,
+    rust
+  };
+}
+
+// src/compiler/compileNative.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import { mkdirSync } from "fs";
+
+// src/compiler/buildCommand.ts
+import { basename } from "path";
+
+// src/compiler/detectLanguage.ts
+function detectLanguage(filePath) {
+  if (filePath.endsWith(".c")) return "c";
+  if (filePath.endsWith(".cpp") || filePath.endsWith(".cc") || filePath.endsWith(".cxx"))
+    return "cpp";
+  if (filePath.endsWith(".rs")) return "rust";
+  throw new Error(`Unsupported native file: ${filePath}`);
+}
+
+// src/compiler/outputNaming.ts
+function getSharedLibName(baseName, platform) {
+  if (platform.isWindows) return `${baseName}.dll`;
+  if (platform.isMac) return `lib${baseName}.dylib`;
+  return `lib${baseName}.so`;
+}
+
+// src/compiler/buildCommand.ts
+function buildCompileCommand(compiler, platform, request) {
+  const language = detectLanguage(request.sourcePath);
+  const baseName = basename(request.sourcePath).split(".")[0];
+  const outputName = getSharedLibName(baseName, platform);
+  const outputPath = `${request.outDir}/${outputName}`;
+  const flags = request.flags ?? [];
+  let command = [];
+  if (language === "c" || language === "cpp") {
+    if (compiler.vendor === "msvc") {
+      command = [
+        request.sourcePath,
+        "/LD",
+        `/Fe:${outputPath}`,
+        ...flags
+      ];
+    } else {
+      command = [
+        request.sourcePath,
+        "-shared",
+        "-fPIC",
+        "-o",
+        outputPath,
+        ...flags
+      ];
+    }
+  }
+  if (language === "rust") {
+    command = [
+      request.sourcePath,
+      "--crate-type",
+      "cdylib",
+      "-O",
+      "-o",
+      outputPath,
+      ...flags
+    ];
+  }
+  return {
+    language,
+    outputPath,
+    command
+  };
+}
+
+// src/compiler/compileNative.ts
+function compileNative(compiler, platform, request) {
+  mkdirSync(request.outDir, { recursive: true });
+  const result = buildCompileCommand(compiler, platform, request);
+  try {
+    execFileSync4(
+      compiler.kind === "rust" ? compiler.path : compiler.path,
+      result.command,
+      { stdio: "inherit" }
+    );
+  } catch (err) {
+    throw new Error(
+      `Native compilation failed for ${request.sourcePath}`
+    );
+  }
+  return result;
+}
+
+// src/compiler/compileWithCache.ts
+import { mkdirSync as mkdirSync3 } from "fs";
+
+// src/cache/hash.ts
+import { readFileSync } from "fs";
+import crypto from "crypto";
+function computeHash(input) {
+  const source = readFileSync(input.sourcePath, "utf8");
+  const hash = crypto.createHash("sha256");
+  hash.update(source);
+  hash.update(input.compiler.path);
+  hash.update(input.compiler.version);
+  hash.update(input.flags.join(" "));
+  hash.update(input.platform);
+  return hash.digest("hex");
+}
+
+// src/cache/cacheManager.ts
+import { existsSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
+
+// src/cache/cachePaths.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+function getCacheRoot() {
+  return join2(homedir(), ".relaxnative", "cache");
+}
+function getCacheEntry(hash) {
+  return join2(getCacheRoot(), hash);
+}
+
+// src/cache/cacheManager.ts
+function cacheExists(hash) {
+  return existsSync(getCacheEntry(hash));
+}
+function loadCacheEntry(hash) {
+  const metaPath = join3(getCacheEntry(hash), "meta.json");
+  const raw = readFileSync2(metaPath, "utf8");
+  return JSON.parse(raw);
+}
+function saveCacheEntry(entry) {
+  const dir = getCacheEntry(entry.hash);
+  mkdirSync2(dir, { recursive: true });
+  writeFileSync2(
+    join3(dir, "meta.json"),
+    JSON.stringify(entry, null, 2)
+  );
+}
+
+// src/compiler/compileWithCache.ts
+function compileWithCache(compiler, platform, request) {
+  const flags = request.flags ?? [];
+  const hash = computeHash({
+    sourcePath: request.sourcePath,
+    compiler,
+    flags,
+    platform: `${platform.platform}-${platform.arch}`
+  });
+  if (cacheExists(hash)) {
+    const entry = loadCacheEntry(hash);
+    return {
+      language: compiler.kind === "rust" ? "rust" : "c",
+      outputPath: entry.outputPath,
+      command: []
+    };
+  }
+  const cacheDir = getCacheEntry(hash);
+  mkdirSync3(cacheDir, { recursive: true });
+  const result = compileNative(compiler, platform, {
+    ...request,
+    outDir: cacheDir
+  });
+  saveCacheEntry({
+    hash,
+    sourcePath: request.sourcePath,
+    outputPath: result.outputPath,
+    compilerPath: compiler.path,
+    compilerVersion: compiler.version,
+    flags,
+    platform: `${platform.platform}-${platform.arch}`,
+    createdAt: Date.now()
+  });
+  return result;
+}
+
+// src/dev/hotReload.ts
+import { watch } from "fs";
+import { dirname } from "path";
+
+// src/parser/index.ts
+import { readFileSync as readFileSync3 } from "fs";
+
+// src/parser/loadParser.ts
+import Parser from "tree-sitter";
+import C from "tree-sitter-c";
+import CPP from "tree-sitter-cpp";
+import Rust from "tree-sitter-rust";
+function createParser(lang) {
+  const parser = new Parser();
+  if (lang === "c") parser.setLanguage(C);
+  if (lang === "cpp") parser.setLanguage(CPP);
+  if (lang === "rust") parser.setLanguage(Rust);
+  return parser;
+}
+
+// src/parser/parseC.ts
+function parseCFunctions(tree) {
+  const functions = [];
+  function visit(node) {
+    if (node.type === "function_definition") {
+      const declarator = node.childForFieldName("declarator");
+      const typeNode = node.childForFieldName("type");
+      if (!declarator || !typeNode) return;
+      const nameNode = declarator.childForFieldName("declarator");
+      const name = nameNode?.text ?? declarator.text?.split("(")[0]?.trim();
+      if (!name) return;
+      const paramsNode = declarator.childForFieldName("parameters");
+      const params = paramsNode?.children?.filter((c) => c.type === "parameter_declaration").map((p) => ({
+        name: p.childForFieldName("declarator")?.text ?? "arg",
+        type: mapCType(
+          // For pointer params, tree-sitter C often stores `*` in the declarator,
+          // not in the `type` field. Combine both so we can detect pointers.
+          `${p.childForFieldName("type")?.text ?? ""}${p.childForFieldName("declarator")?.text ?? ""}`
+        )
+      })) ?? [];
+      functions.push({
+        name,
+        returnType: mapCType(typeNode.text),
+        params,
+        sourceLine: node.startPosition.row + 1
+      });
+    }
+    for (const child of node.children ?? []) visit(child);
+  }
+  visit(tree.rootNode);
+  return functions;
+}
+function mapCType(type) {
+  if (!type) return "unknown";
+  const t = type.replace(/\s+/g, " ").trim();
+  if (/\b(u?int8_t|unsigned\s+char|uint8_t)\b/.test(t) && t.includes("*")) return "buffer";
+  if (/\bconst\s+char\s*\*/.test(t)) return "cstring";
+  if (/\bunsigned\s+int\b/.test(t) || /\buint32_t\b/.test(t)) return "uint";
+  if (/\bsize_t\b/.test(t)) return "size_t";
+  if (t.includes("int")) return "int";
+  if (t.includes("long")) return "long";
+  if (type.includes("float")) return "float";
+  if (type.includes("double")) return "double";
+  if (t.includes("char") && t.includes("*")) return "buffer";
+  if (t.includes("*")) return "pointer";
+  if (t.includes("void")) return "void";
+  return "unknown";
+}
+
+// src/parser/parseRust.ts
+function parseRustFunctions(tree) {
+  const functions = [];
+  function visit(node) {
+    if (node.type === "function_item" && node.text.includes("pub extern")) {
+      const nameNode = node.childForFieldName("name");
+      const paramsNode = node.childForFieldName("parameters");
+      const returnNode = node.childForFieldName("return_type");
+      const params = paramsNode?.children?.filter((c) => c.type === "parameter").map((p) => ({
+        name: p.childForFieldName("pattern")?.text ?? "arg",
+        type: mapRustType(p.childForFieldName("type")?.text)
+      })) ?? [];
+      functions.push({
+        name: nameNode?.text ?? "unknown",
+        returnType: mapRustType(returnNode?.text),
+        params,
+        sourceLine: node.startPosition.row + 1
+      });
+    }
+    for (const child of node.children ?? []) visit(child);
+  }
+  visit(tree.rootNode);
+  return functions;
+}
+function mapRustType(type) {
+  if (!type) return "void";
+  if (type.includes("i32")) return "int";
+  if (type.includes("i64")) return "long";
+  if (type.includes("f32")) return "float";
+  if (type.includes("f64")) return "double";
+  if (type.includes("*const i8")) return "char*";
+  if (type.includes("*")) return "pointer";
+  return "unknown";
+}
+
+// src/parser/validateFunctions.ts
+function validateFunctions(funcs) {
+  return funcs.filter((fn) => {
+    if (fn.returnType === "unknown") return false;
+    if (fn.params.some((p) => p.type === "unknown")) return false;
+    return true;
+  });
+}
+
+// src/parser/generateBindings.ts
+function generateBindings(functions) {
+  const entries = functions.map((f) => [
+    f.name,
+    {
+      name: f.name,
+      returns: f.returnType,
+      args: f.params.map((p) => p.type),
+      // optional execution hints
+      mode: f.annotations?.mode,
+      cost: f.annotations?.cost
+    }
+  ]);
+  return {
+    functions: Object.fromEntries(entries)
+  };
+}
+
+// src/parser/index.ts
+function parseAnnotationsForFunctions(source, funcs) {
+  const lines = source.split(/\r?\n/);
+  for (const fn of funcs) {
+    if (!fn.sourceLine) continue;
+    const idx = Math.max(0, fn.sourceLine - 1);
+    const start = Math.max(0, idx - 3);
+    const window = lines.slice(start, idx).join("\n");
+    const mode = /@async\b/.test(window) ? "async" : /@sync\b/.test(window) ? "sync" : void 0;
+    const costMatch = window.match(/@cost\s+(low|medium|high)\b/);
+    const cost = costMatch?.[1] ?? void 0;
+    if (mode || cost) {
+      fn.annotations = { ...fn.annotations ?? {}, mode, cost };
+    }
+  }
+  return funcs;
+}
+function parseNativeSource(filePath, lang) {
+  const source = readFileSync3(filePath, "utf8");
+  const parser = createParser(lang);
+  const tree = parser.parse(source);
+  const rawFunctions = lang === "rust" ? parseRustFunctions(tree) : parseCFunctions(tree);
+  const annotated = parseAnnotationsForFunctions(source, rawFunctions);
+  const validFunctions = validateFunctions(annotated);
+  return generateBindings(validFunctions);
+}
+
+// src/dev/hotReload.ts
+function log(msg) {
+  console.log(msg);
+}
+function fingerprintBindings(bindings) {
+  const entries = Object.entries(bindings?.functions ?? {}).map(([k, v]) => {
+    return `${k}:${v.returns}(${(v.args ?? []).join(",")})`;
+  });
+  entries.sort();
+  return entries.join("|");
+}
+async function loadNativeDevHot(sourcePath, opts) {
+  const enabled = process.env.RELAXNATIVE_DEV === "1";
+  if (!enabled) {
+    throw new Error("Hot reload is only available when RELAXNATIVE_DEV=1");
+  }
+  const { c, rust, platform } = detectCompilers();
+  const isolation = opts?.isolation ?? "worker";
+  let current = null;
+  const buildOnce = () => {
+    const language = detectLanguage(sourcePath);
+    const compiler = language === "rust" ? rust : c;
+    if (!compiler) throw new Error(`No compiler for ${language}`);
+    const t0 = process.hrtime.bigint();
+    const compileRes = compileWithCache(compiler, platform, {
+      sourcePath,
+      outDir: ".cache/native"
+    });
+    const bindings = parseNativeSource(sourcePath, language);
+    const api = loadFfi(compileRes.outputPath, bindings);
+    const mod = wrapFunctions(api, compileRes.outputPath, bindings, { isolation });
+    const abi = fingerprintBindings(bindings);
+    const t1 = process.hrtime.bigint();
+    const durationMs = Number(t1 - t0) / 1e6;
+    return { libPath: compileRes.outputPath, bindings, abi, api, mod, durationMs };
+  };
+  const first = buildOnce();
+  current = { ...first, mod: first.mod };
+  const stable = new Proxy(
+    {},
+    {
+      get(_t, prop) {
+        if (prop === "__isHotReloadProxy") return true;
+        if (prop === "then") return void 0;
+        const target = current?.mod;
+        if (!target) return void 0;
+        return target[prop];
+      },
+      ownKeys() {
+        return Reflect.ownKeys(current?.mod ?? {});
+      },
+      getOwnPropertyDescriptor(_t, prop) {
+        return Object.getOwnPropertyDescriptor(current?.mod ?? {}, prop);
+      }
+    }
+  );
+  const watcher = watch(dirname(sourcePath), { persistent: false }, (event, filename) => {
+    if (!filename) return;
+    if (!String(filename).endsWith(sourcePath.split("/").pop() ?? "")) return;
+    try {
+      const next = buildOnce();
+      if (current && next.abi !== current.abi) {
+        log(`[relaxnative] ABI change detected in ${sourcePath}; reload requires restart`);
+        return;
+      }
+      current = { ...next, mod: next.mod };
+      const ms = next.durationMs;
+      log(`[relaxnative] Recompiled ${sourcePath} (${ms.toFixed(0)}ms)`);
+      opts?.onReload?.({ sourcePath, durationMs: ms });
+    } catch (err) {
+      log(`[relaxnative] Hot reload failed for ${sourcePath}: ${err?.message ?? String(err)}`);
+    }
+  });
+  return {
+    mod: stable,
+    close() {
+      watcher.close();
+    }
+  };
+}
+
+// src/loader.ts
+async function buildNative(sourcePath, options) {
+  const { c, rust, platform } = detectCompilers();
+  const language = detectLanguage(sourcePath);
+  const compiler = language === "rust" ? rust : c;
+  if (!compiler) {
+    throw new Error(`No compiler for ${language}`);
+  }
+  const compileResult = compileWithCache(compiler, platform, {
+    sourcePath,
+    outDir: ".cache/native"
+  });
+  const bindings = parseNativeSource(sourcePath, language);
+  const config = options?.config;
+  if (config?.functionMode) {
+    for (const [name, mode] of Object.entries(config.functionMode)) {
+      if (bindings.functions?.[name]) {
+        bindings.functions[name] = {
+          ...bindings.functions[name],
+          mode
+        };
+      }
+    }
+  }
+  if (config?.defaultMode) {
+    for (const [name, binding] of Object.entries(bindings.functions ?? {})) {
+      if (!binding.mode) {
+        bindings.functions[name] = { ...binding, mode: config.defaultMode };
+      }
+    }
+  }
+  globalThis.__bindings = bindings;
+  const api = loadFfi(compileResult.outputPath, bindings);
+  return { libPath: compileResult.outputPath, bindings, api };
+}
+async function loadNative(sourcePath, options) {
+  if (process.env.RELAXNATIVE_DEV === "1") {
+    if (options?.config) {
+      throw new Error("RELAXNATIVE_DEV=1: loadNative() does not support config overrides yet");
+    }
+    const handle = await loadNativeDevHot(sourcePath, { isolation: options?.isolation });
+    return handle.mod;
+  }
+  const { libPath, bindings, api } = await buildNative(sourcePath, options);
+  const isolation = options?.isolation ?? "worker";
+  return wrapFunctions(api, libPath, bindings, { isolation });
+}
+async function loadNativeWithBindings(sourcePath, options) {
+  const { libPath, bindings, api } = await buildNative(sourcePath, options);
+  if (options?.mutateBindings) {
+    options.mutateBindings(bindings);
+  }
+  const isolation = options?.isolation ?? "worker";
+  const mod = wrapFunctions(api, libPath, bindings, { isolation });
+  return { mod, bindings };
+}
+
+export {
+  detectCompilers,
+  detectLanguage,
+  compileNative,
+  compileWithCache,
+  parseNativeSource,
+  loadNativeDevHot,
+  loadNative,
+  loadNativeWithBindings
+};