@vulfram/transport-napi 0.17.2-alpha → 0.19.2-alpha

package/dist/index.js

@@ -34,50 +34,163 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // lib/macos-arm64/vulfram_core.node
 var require_vulfram_core = __commonJS((exports, module) => {
-  module.exports = __require("./vulfram_core-ft75ssqs.node");
+  module.exports = __require("./vulfram_core-w4dx1mnf.node");
 });
 
 // lib/macos-x64/vulfram_core.node
 var require_vulfram_core2 = __commonJS((exports, module) => {
-  module.exports = __require("./vulfram_core-qbdcr6jt.node");
+  module.exports = __require("./vulfram_core-zdzrhnjc.node");
 });
 
 // lib/linux-arm64/vulfram_core.node
 var require_vulfram_core3 = __commonJS((exports, module) => {
-  module.exports = __require("./vulfram_core-09fsy0tb.node");
+  module.exports = __require("./vulfram_core-77tjnpae.node");
 });
 
 // lib/linux-x64/vulfram_core.node
 var require_vulfram_core4 = __commonJS((exports, module) => {
-  module.exports = __require("./vulfram_core-mx29y6cy.node");
+  module.exports = __require("./vulfram_core-gc5kt6t3.node");
 });
 
 // lib/windows-arm64/vulfram_core.node
 var require_vulfram_core5 = __commonJS((exports, module) => {
-  module.exports = __require("./vulfram_core-f4dw99gh.node");
+  module.exports = __require("./vulfram_core-2pty1yvt.node");
 });
 
 // lib/windows-x64/vulfram_core.node
 var require_vulfram_core6 = __commonJS((exports, module) => {
-  module.exports = __require("./vulfram_core-v45afrt6.node");
+  module.exports = __require("./vulfram_core-nffbksne.node");
 });
 
-// src/bind/utils.ts
+// ../transport-types/src/index.ts
+var VULFRAM_R2_DEFAULT_BASE_URL = "https://pub-95922dbd81b344a893425215a2695b88.r2.dev";
+var VULFRAM_ARTIFACT_PREFIX = "v1";
+var VULFRAM_DEFAULT_CHANNEL = "alpha";
 function detectRuntime() {
   if (typeof globalThis.Deno !== "undefined" && typeof globalThis.Deno?.version?.deno === "string") {
-    return { runtime: "deno", version: globalThis.Deno.version.deno };
+    const deno = globalThis.Deno;
+    return {
+      runtime: "deno",
+      version: deno.version.deno,
+      platform: deno.build?.os ?? null,
+      arch: deno.build?.arch ?? null
+    };
   }
   if (typeof globalThis.Bun !== "undefined" && typeof globalThis.Bun?.version === "string") {
-    return { runtime: "bun", version: globalThis.Bun.version };
+    return {
+      runtime: "bun",
+      version: globalThis.Bun.version,
+      platform: typeof process !== "undefined" ? process.platform : null,
+      arch: typeof process !== "undefined" ? process.arch : null
+    };
   }
   if (typeof globalThis.process !== "undefined" && typeof globalThis.process?.versions?.node === "string") {
-    return { runtime: "node", version: globalThis.process.versions.node };
+    const proc = globalThis.process;
+    return {
+      runtime: "node",
+      version: proc.versions.node,
+      platform: proc.platform ?? null,
+      arch: proc.arch ?? null
+    };
   }
-  return { runtime: "unknown", version: null };
+  return {
+    runtime: "unknown",
+    version: null,
+    platform: null,
+    arch: null
+  };
+}
+function selectPlatformLoader(loaders, artifactKind) {
+  const runtime = detectRuntime();
+  const platformKey = runtime.platform ?? "";
+  const archKey = runtime.arch ?? "";
+  const byPlatform = loaders[platformKey];
+  const selected = byPlatform?.[archKey];
+  if (selected)
+    return selected;
+  throw new Error(`${artifactKind} build not found for the current runtime: ${JSON.stringify(runtime)}`);
+}
+function resolveNativePlatform(runtime = detectRuntime()) {
+  const platform = runtime.platform;
+  const arch = runtime.arch;
+  if (platform === "linux" && arch === "x64")
+    return "linux-x64";
+  if (platform === "linux" && arch === "arm64")
+    return "linux-arm64";
+  if (platform === "darwin" && arch === "x64")
+    return "macos-x64";
+  if (platform === "darwin" && arch === "arm64")
+    return "macos-arm64";
+  if (platform === "win32" && arch === "x64")
+    return "windows-x64";
+  if (platform === "win32" && arch === "arm64")
+    return "windows-arm64";
+  throw new Error(`Unsupported native platform for Vulfram transports: ${JSON.stringify(runtime)}`);
+}
+function getArtifactFileName(binding, platform) {
+  if (binding === "napi")
+    return "vulfram_core.node";
+  if (binding === "wasm")
+    return "vulfram_core_bg.wasm";
+  if (binding === "ffi" && platform.startsWith("windows"))
+    return "vulfram_core.dll";
+  if (binding === "ffi" && platform.startsWith("macos"))
+    return "vulfram_core.dylib";
+  if (binding === "ffi")
+    return "vulfram_core.so";
+  if (platform.startsWith("windows"))
+    return "vulfram_core.dll";
+  if (platform.startsWith("macos"))
+    return "vulfram_core.dylib";
+  return "vulfram_core.so";
+}
+function buildArtifactPath(config) {
+  const channel = config.channel ?? VULFRAM_DEFAULT_CHANNEL;
+  const prefix = config.prefix ?? VULFRAM_ARTIFACT_PREFIX;
+  const artifact = config.artifact ?? getArtifactFileName(config.binding, config.platform);
+  return [
+    prefix,
+    channel,
+    config.artifactVersion,
+    config.binding,
+    config.platform,
+    artifact
+  ].join("/");
+}
+function buildArtifactUrl(config) {
+  const base = (config.baseUrl ?? VULFRAM_R2_DEFAULT_BASE_URL).replace(/\/+$/, "");
+  return `${base}/${buildArtifactPath(config)}`;
+}
+function parsePackageArtifactTarget(packageVersion) {
+  const normalized = packageVersion.trim();
+  const match = normalized.match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+  if (!match) {
+    throw new Error(`Invalid package version "${packageVersion}". Expected semver format "X.Y.Z[-tag]".`);
+  }
+  const major = match[1];
+  const minor = match[2];
+  const pre = (match[4] ?? "").toLowerCase();
+  let channel = "release";
+  if (pre.includes("alpha"))
+    channel = "alpha";
+  else if (pre.includes("beta"))
+    channel = "beta";
+  return {
+    channel,
+    artifactVersion: `v${major}.${minor}`
+  };
 }
 
 // src/bind/napi-loader.ts
-console.log(process.platform, process.arch);
+import { createHash } from "crypto";
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { createRequire as createRequire2 } from "module";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var requireNative = createRequire2(import.meta.url);
+var pkg = requireNative("../../package.json");
+var { channel, artifactVersion } = parsePackageArtifactTarget(pkg.version);
 var loaders = {
   darwin: {
     arm64: () => Promise.resolve().then(() => __toESM(require_vulfram_core(), 1)),
@@ -92,12 +205,62 @@ var loaders = {
     x64: () => Promise.resolve().then(() => __toESM(require_vulfram_core6(), 1))
   }
 };
-var importLoader = loaders[process.platform]?.[process.arch];
-if (!importLoader) {
-  throw new Error(`FFI build not found for the current runtime: ${JSON.stringify(detectRuntime())}`);
+function getCacheDir() {
+  return join(homedir(), ".cache", "vulfram-transport");
+}
+async function ensureFileDir(path) {
+  await mkdir(dirname(path), { recursive: true });
+}
+async function sha256File(path) {
+  const data = await readFile(path);
+  return createHash("sha256").update(data).digest("hex");
+}
+async function downloadArtifactWithHash(url, destination) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download artifact: ${url} (${response.status})`);
+  }
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  await ensureFileDir(destination);
+  await writeFile(destination, bytes);
+  const hashResponse = await fetch(`${url}.sha256`);
+  if (!hashResponse.ok)
+    return;
+  const expected = (await hashResponse.text()).trim().split(/\s+/)[0] ?? "";
+  if (!expected)
+    return;
+  const actual = await sha256File(destination);
+  if (actual !== expected) {
+    throw new Error(`SHA256 mismatch for ${url}: expected=${expected} actual=${actual}`);
+  }
+}
+async function resolveRemoteModulePath() {
+  const platform = resolveNativePlatform();
+  const filename = getArtifactFileName("napi", platform);
+  const remoteUrl = buildArtifactUrl({
+    baseUrl: VULFRAM_R2_DEFAULT_BASE_URL,
+    channel,
+    artifactVersion,
+    binding: "napi",
+    platform,
+    artifact: filename
+  });
+  const cachePath = join(getCacheDir(), "runtime", channel, artifactVersion, "napi", platform, filename);
+  if (!existsSync(cachePath)) {
+    await downloadArtifactWithHash(remoteUrl, cachePath);
+  }
+  return cachePath;
+}
+async function resolveNativeModulePath() {
+  const importLoader = selectPlatformLoader(loaders, "N-API");
+  try {
+    return (await importLoader()).default;
+  } catch {
+    return resolveRemoteModulePath();
+  }
 }
-var lib = await importLoader().then((mod) => mod.default);
-var raw = lib;
+var modulePath = await resolveNativeModulePath();
+var raw = requireNative(modulePath);
 var VULFRAM_CORE = {
   vulframInit: () => raw.vulframInit(),
   vulframDispose: () => raw.vulframDispose(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vulfram/transport-napi",
-  "version": "0.17.2-alpha",
+  "version": "0.19.2-alpha",
   "type": "module",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
@@ -12,7 +12,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@vulfram/transport-types": "^0.2.6"
+    "@vulfram/transport-types": "^0.3.0"
   },
   "devDependencies": {
     "@types/bun": "^1.3.10"