relaxnative 0.1.0-beta.1

package/dist/chunk-X7SAP7FC.js

@@ -0,0 +1,582 @@
+import {
+  wrapFunctions
+} from "./chunk-XI65CAQV.js";
+import {
+  InvalidFreeError,
+  MemoryError,
+  NativeBuffer,
+  NativePointer,
+  NullPointerError,
+  UseAfterFreeError,
+  loadFfi
+} from "./chunk-IDYSBXYS.js";
+import {
+  __export
+} from "./chunk-R5U7XKVJ.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/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";
+  if (/\b(u?int8_t|unsigned\s+char|uint8_t)\b/.test(type) && type.includes("*")) return "buffer";
+  if (type.includes("int")) return "int";
+  if (type.includes("long")) return "long";
+  if (type.includes("float")) return "float";
+  if (type.includes("double")) return "double";
+  if (type.includes("char") && type.includes("*")) return "buffer";
+  if (type.includes("*")) return "pointer";
+  if (type.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/loader.ts
+async function loadNative(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);
+  const isolation = options?.isolation ?? "worker";
+  return wrapFunctions(api, compileResult.outputPath, bindings, { isolation });
+}
+async function loadNativeWithBindings(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);
+  const isolation = options?.isolation ?? "worker";
+  const mod = wrapFunctions(api, compileResult.outputPath, bindings, { isolation });
+  return { mod, bindings };
+}
+
+// src/memory/nativeMemory.ts
+import koffi from "koffi";
+function allocRaw(size) {
+  if (!Number.isInteger(size) || size <= 0) {
+    throw new TypeError(`native.alloc(size): size must be a positive integer, got ${size}`);
+  }
+  const handle = koffi.alloc("char", size);
+  const ab = koffi.view(handle, size);
+  const view = new Uint8Array(ab);
+  return { handle, view };
+}
+function freeRaw(ptr) {
+  koffi.free(ptr);
+}
+
+// src/memory/index.ts
+var memory_exports = {};
+__export(memory_exports, {
+  InvalidFreeError: () => InvalidFreeError,
+  MemoryError: () => MemoryError,
+  NativeBuffer: () => NativeBuffer,
+  NativePointer: () => NativePointer,
+  NullPointerError: () => NullPointerError,
+  UseAfterFreeError: () => UseAfterFreeError,
+  alloc: () => alloc,
+  allocRaw: () => allocRaw,
+  free: () => free,
+  freeRaw: () => freeRaw
+});
+function alloc(size, opts) {
+  const allocation = allocRaw(size);
+  return new NativeBuffer(allocation, { ownership: "js", autoFree: opts?.autoFree });
+}
+function free(ptr) {
+  if (NativeBuffer.isNativeBuffer(ptr)) {
+    ptr.free();
+    return;
+  }
+  if (NativePointer.isNativePointer(ptr)) {
+    throw new InvalidFreeError(
+      `native.free(ptr): cannot free a raw NativePointer (unknown allocator). Use a NativeBuffer allocated by native.alloc().`
+    );
+  }
+  throw new TypeError("native.free(ptr): expected NativeBuffer or NativePointer");
+}
+
+export {
+  detectCompilers,
+  compileNative,
+  compileWithCache,
+  loadNative,
+  loadNativeWithBindings,
+  allocRaw,
+  freeRaw,
+  alloc,
+  free,
+  memory_exports
+};