@vulfram/transport-bun 0.5.5-alpha

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@vulfram/transport-bun",
+  "version": "0.5.5-alpha",
+  "module": "src/index.ts",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "type": "module",
+  "dependencies": {
+    "@vulfram/transport-types": "^0.2.1",
+    "glob": "^13.0.0",
+    "msgpackr": "^1.11.8"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.6"
+  }
+}

package/src/bind/ffi-loader.ts

@@ -0,0 +1,172 @@
+import { dlopen, ptr, toArrayBuffer, type Pointer } from 'bun:ffi';
+import type { BufferResult } from './types';
+import { detectRuntime } from './utils';
+
+const loaders: Record<
+  string,
+  Record<string, () => Promise<{ default: string }>>
+> = {
+  darwin: {
+    arm64: () =>
+      // @ts-expect-error
+      import('../../lib/macos-arm64/libvulfram_core.dylib', {
+        with: { type: 'file' },
+      }),
+    x64: () =>
+      // @ts-expect-error
+      import('../../lib/macos-x64/libvulfram_core.dylib', {
+        with: { type: 'file' },
+      }),
+  },
+  linux: {
+    arm64: () =>
+      // @ts-expect-error
+      import('../../lib/linux-arm64/libvulfram_core.so', {
+        with: { type: 'file' },
+      }),
+    x64: () =>
+      // @ts-expect-error
+      import('../../lib/linux-x64/libvulfram_core.so', {
+        with: { type: 'file' },
+      }),
+  },
+  win32: {
+    arm64: () =>
+      // @ts-expect-error
+      import('../../lib/windows-arm64/vulfram_core.dll', {
+        with: { type: 'file' },
+      }),
+    x64: () =>
+      // @ts-expect-error
+      import('../../lib/windows-x64/vulfram_core.dll', {
+        with: { type: 'file' },
+      }),
+  },
+};
+
+const importLoader = loaders[process.platform]?.[process.arch];
+
+if (!importLoader) {
+  throw new Error(
+    `FFI build not found for the current runtime: ${JSON.stringify(
+      detectRuntime(),
+    )}`,
+  );
+}
+
+const lib = await importLoader().then((mod) => mod.default);
+
+const { symbols: VULFRAM_CORE_DYLIB, close } = dlopen(lib, {
+  vulfram_init: { args: [], returns: 'u32' },
+  vulfram_dispose: { args: [], returns: 'u32' },
+  vulfram_send_queue: { args: ['ptr', 'usize'], returns: 'u32' },
+  vulfram_receive_queue: { args: ['ptr', 'ptr'], returns: 'u32' },
+  vulfram_receive_events: { args: ['ptr', 'ptr'], returns: 'u32' },
+  vulfram_upload_buffer: {
+    args: ['u64', 'u32', 'ptr', 'usize'],
+    returns: 'u32',
+  },
+  vulfram_tick: { args: ['u64', 'u32'], returns: 'u32' },
+  vulfram_get_profiling: { args: ['ptr', 'ptr'], returns: 'u32' },
+});
+
+process.once('beforeExit', () => {
+  close();
+});
+
+function vulframDispose(): number {
+  return VULFRAM_CORE_DYLIB.vulfram_dispose();
+}
+
+function vulframInit(): number {
+  return VULFRAM_CORE_DYLIB.vulfram_init();
+}
+
+function vulframReceiveQueue(): BufferResult {
+  const ptrHolder = new BigUint64Array(1);
+  const sizeHolder = new BigUint64Array(1);
+  const result = VULFRAM_CORE_DYLIB.vulfram_receive_queue(
+    ptr(ptrHolder),
+    ptr(sizeHolder),
+  );
+  if (!sizeHolder[0]) {
+    return { buffer: Buffer.alloc(0), result };
+  }
+  const srcPtr = Number(ptrHolder[0]) as Pointer;
+  if (!srcPtr) {
+    return { buffer: Buffer.alloc(0), result };
+  }
+  const buffer = Buffer.from(toArrayBuffer(srcPtr, 0, Number(sizeHolder[0])));
+
+  return { buffer, result };
+}
+
+function vulframReceiveEvents(): BufferResult {
+  const ptrHolder = new BigUint64Array(1);
+  const sizeHolder = new BigUint64Array(1);
+  const result = VULFRAM_CORE_DYLIB.vulfram_receive_events(
+    ptr(ptrHolder),
+    ptr(sizeHolder),
+  );
+  if (!sizeHolder[0]) {
+    return { buffer: Buffer.alloc(0), result };
+  }
+  const srcPtr = Number(ptrHolder[0]) as Pointer;
+  if (!srcPtr) {
+    return { buffer: Buffer.alloc(0), result };
+  }
+  const buffer = Buffer.from(toArrayBuffer(srcPtr, 0, Number(sizeHolder[0])));
+
+  return { buffer, result };
+}
+
+function vulframSendQueue(data: Buffer): number {
+  return VULFRAM_CORE_DYLIB.vulfram_send_queue(ptr(data), data.length);
+}
+
+function vulframTick(time: number, deltaTime: number): number {
+  return VULFRAM_CORE_DYLIB.vulfram_tick(time, deltaTime);
+}
+
+function vulframUploadBuffer(
+  id: number,
+  uploadType: number,
+  data: Buffer,
+): number {
+  return VULFRAM_CORE_DYLIB.vulfram_upload_buffer(
+    id,
+    uploadType,
+    ptr(data),
+    data.length,
+  );
+}
+
+function vulframGetProfiling(): BufferResult {
+  const ptrHolder = new BigUint64Array(1);
+  const sizeHolder = new BigUint64Array(1);
+  const result = VULFRAM_CORE_DYLIB.vulfram_get_profiling(
+    ptr(ptrHolder),
+    ptr(sizeHolder),
+  );
+  if (!sizeHolder[0]) {
+    return { buffer: Buffer.alloc(0), result };
+  }
+  const srcPtr = Number(ptrHolder[0]) as Pointer;
+  if (!srcPtr) {
+    return { buffer: Buffer.alloc(0), result };
+  }
+  const buffer = Buffer.from(toArrayBuffer(srcPtr, 0, Number(sizeHolder[0])));
+
+  return { buffer, result };
+}
+
+export const VULFRAM_CORE = {
+  vulframDispose,
+  vulframInit,
+  vulframReceiveQueue,
+  vulframReceiveEvents,
+  vulframSendQueue,
+  vulframTick,
+  vulframUploadBuffer,
+  vulframGetProfiling,
+};

package/src/bind/types.ts

@@ -0,0 +1,4 @@
+export interface BufferResult {
+  buffer: Buffer;
+  result: number;
+}

package/src/bind/utils.ts

@@ -0,0 +1,33 @@
+export function detectRuntime() {
+  if (
+    // @ts-ignore
+    typeof globalThis.Deno !== 'undefined' &&
+    // @ts-ignore
+    typeof globalThis.Deno?.version?.deno === 'string'
+  ) {
+    // @ts-ignore
+    return { runtime: 'deno', version: globalThis.Deno.version.deno };
+  }
+
+  if (
+    // @ts-ignore
+    typeof globalThis.Bun !== 'undefined' &&
+    // @ts-ignore
+    typeof globalThis.Bun?.version === 'string'
+  ) {
+    // @ts-ignore
+    return { runtime: 'bun', version: globalThis.Bun.version };
+  }
+
+  if (
+    // @ts-ignore
+    typeof globalThis.process !== 'undefined' &&
+    // @ts-ignore
+    typeof globalThis.process?.versions?.node === 'string'
+  ) {
+    // @ts-ignore
+    return { runtime: 'node', version: globalThis.process.versions.node };
+  }
+
+  return { runtime: 'unknown', version: null };
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+import type { EngineTransportFactory } from '@vulfram/transport-types';
+import { VULFRAM_CORE } from './bind/ffi-loader';
+
+export const transportBunFfi: EngineTransportFactory = () => VULFRAM_CORE;

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}