@audio/host-vst 0.1.0

package/binding.gyp

@@ -0,0 +1,20 @@
+{
+  "targets": [{
+    "target_name": "host_vst",
+    "sources": ["native/host.cpp", "native/binding.cpp"],
+    "include_dirs": ["native"],
+    "cflags_cc": ["-std=c++17", "-O2", "-fno-exceptions"],
+    "xcode_settings": {
+      "OTHER_CPLUSPLUSFLAGS": ["-std=c++17", "-O2", "-fno-exceptions"],
+      "CLANG_CXX_LANGUAGE_STANDARD": "c++17",
+      "MACOSX_DEPLOYMENT_TARGET": "10.13"
+    },
+    "msvs_settings": {
+      "VCCLCompilerTool": { "AdditionalOptions": ["/std:c++17", "/O2"] }
+    },
+    "conditions": [
+      ["OS=='mac'", { "libraries": ["-framework CoreFoundation"] }],
+      ["OS=='linux'", { "libraries": ["-ldl"] }]
+    ]
+  }]
+}

package/index.js

@@ -0,0 +1,167 @@
+/**
+ * @module @audio/host-vst
+ * VST3 plugin host for audiojs
+ */
+import addon from './src/addon.js'
+import { readdirSync, statSync } from 'fs'
+import { join } from 'path'
+import { execFileSync } from 'child_process'
+
+export function load(path, opts = {}) {
+  const { sampleRate = 44100, channels = 2, blockSize = 128 } = opts
+  const handle = addon.open(path, sampleRate, channels, blockSize)
+  let closed = false
+
+  return {
+    get name() { return addon.getName(handle) },
+    get vendor() { return addon.getVendor(handle) },
+    get inputChannels() { return addon.getChannels(handle, 0) },
+    get outputChannels() { return addon.getChannels(handle, 1) },
+    blockSize,
+
+    get params() {
+      const n = addon.getParamCount(handle)
+      const out = []
+      for (let i = 0; i < n; i++) {
+        const info = addon.getParamInfo(handle, i)
+        if (info) out.push(info)
+      }
+      return out
+    },
+
+    getParam(id) { return addon.getParam(handle, id) },
+    setParam(id, value) { addon.setParam(handle, id, value) },
+
+    process(inputs, outputs) { addon.process(handle, inputs, outputs) },
+    processAll(ch) { return processBlocks(addon, handle, ch, blockSize) },
+
+    getState() { return addon.getState(handle) },
+    setState(buf) { addon.setState(handle, buf) },
+
+    close() {
+      if (closed) return
+      closed = true
+      addon.close(handle)
+    }
+  }
+}
+
+/**
+ * Scan system for installed VST3 plugins.
+ * Returns array of { path, name, vendor, format } for each loadable plugin.
+ */
+export function scan(dirs) {
+  return scanDir(dirs || defaultPaths({
+    darwin: ['/Library/Audio/Plug-Ins/VST3', '$HOME/Library/Audio/Plug-Ins/VST3'],
+    linux: ['$HOME/.vst3', '/usr/lib/vst3', '/usr/local/lib/vst3'],
+    win32: ['$PROGRAMFILES/Common Files/VST3'],
+  }), '.vst3', 'vst3')
+}
+
+/**
+ * Register a VST3 plugin as an AudioWorkletProcessor.
+ *
+ *   import { AudioWorkletProcessor } from 'web-audio-api'
+ *   await ctx.audioWorklet.addModule(register(path, AudioWorkletProcessor))
+ *   const node = new AudioWorkletNode(ctx, 'Plugin Name')
+ */
+export function register(path, BaseClass, opts = {}) {
+  const probe = load(path, { ...opts, sampleRate: opts.sampleRate || 44100 })
+  const name = probe.name
+  const descriptors = probe.params.map(p => ({
+    name: p.name,
+    defaultValue: p.defaultValue,
+    minValue: p.min,
+    maxValue: p.max,
+    automationRate: 'k-rate'
+  }))
+  probe.close()
+
+  return function(scope) {
+    class PluginProcessor extends BaseClass {
+      static get parameterDescriptors() { return descriptors }
+
+      constructor(options) {
+        super(options)
+        this._handle = addon.open(path, scope.sampleRate,
+          opts.channels || 2, opts.blockSize || 128)
+      }
+
+      process(inputs, outputs) {
+        const input = inputs[0], output = outputs[0]
+        if (!output || !output.length) return true
+        addon.process(this._handle, input.length ? input : null, output)
+        return true
+      }
+    }
+
+    scope.registerProcessor(name, PluginProcessor)
+  }
+}
+
+function defaultPaths(map) {
+  const plat = process.platform
+  return (map[plat] || []).map(p =>
+    p.replace('$HOME', process.env.HOME || process.env.USERPROFILE || '')
+     .replace('$PROGRAMFILES', process.env.PROGRAMFILES || 'C:\\Program Files'))
+}
+
+function scanDir(dirs, ext, format) {
+  /* Collect all plugin paths */
+  const paths = []
+  for (const dir of dirs) {
+    let entries
+    try { entries = readdirSync(dir) } catch { continue }
+    for (const name of entries) {
+      const full = join(dir, name)
+      if (name.endsWith(ext)) { paths.push(full); continue }
+      try {
+        if (statSync(full).isDirectory())
+          for (const sub of readdirSync(full))
+            if (sub.endsWith(ext)) paths.push(join(full, sub))
+      } catch {}
+    }
+  }
+
+  /* Probe each in a subprocess — isolates crashes and ObjC class conflicts */
+  const results = []
+  for (const path of paths) {
+    try {
+      const code = `import{load}from'${import.meta.url}';try{const p=load(${JSON.stringify(path)});console.log(JSON.stringify({path:${JSON.stringify(path)},name:p.name,vendor:p.vendor,format:'${format}'}));p.close()}catch{}`
+      const out = execFileSync(process.execPath, ['--input-type=module', '-e', code],
+        { timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] })
+      const line = out.toString().trim()
+      if (line) results.push(JSON.parse(line))
+    } catch {}
+  }
+  return results
+}
+
+function processBlocks(addon, handle, channels, blockSize) {
+  const len = channels[0].length, numCh = channels.length
+  const out = Array.from({ length: numCh }, () => new Float32Array(len))
+
+  const inBlock = Array.from({ length: numCh }, () => new Float32Array(blockSize))
+  const outBlock = Array.from({ length: numCh }, () => new Float32Array(blockSize))
+
+  for (let off = 0; off < len; off += blockSize) {
+    const n = Math.min(blockSize, len - off)
+    if (n === blockSize) {
+      const inSub = [], outSub = []
+      for (let c = 0; c < numCh; c++) {
+        inSub[c] = channels[c].subarray(off, off + blockSize)
+        outSub[c] = out[c].subarray(off, off + blockSize)
+      }
+      addon.process(handle, inSub, outSub)
+    } else {
+      for (let c = 0; c < numCh; c++) {
+        inBlock[c].fill(0)
+        inBlock[c].set(channels[c].subarray(off, off + n))
+        outBlock[c].fill(0)
+      }
+      addon.process(handle, inBlock, outBlock)
+      for (let c = 0; c < numCh; c++) out[c].set(outBlock[c].subarray(0, n), off)
+    }
+  }
+  return out
+}

package/native/binding.cpp

@@ -0,0 +1,235 @@
+/*
+ * binding.cpp — NAPI bindings for VST3 host
+ */
+#include <node_api.h>
+#include "host.h"
+
+#define NAPI_CALL(env, call) do { \
+  napi_status s = (call); \
+  if (s != napi_ok) { napi_throw_error(env, NULL, #call " failed"); return NULL; } \
+} while(0)
+
+static void destructor(napi_env env, void* data, void* hint) {
+  (void)env; (void)hint;
+  vst3_destroy((vst3_plugin_t*)data);
+}
+
+/* open(path, sampleRate, channels, blockSize) → external */
+static napi_value node_open(napi_env env, napi_callback_info info) {
+  size_t argc = 4;
+  napi_value argv[4];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+  char path[2048];
+  size_t len;
+  NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], path, sizeof(path), &len));
+
+  double sampleRate = 44100; int channels = 2, blockSize = 128;
+  if (argc > 1) napi_get_value_double(env, argv[1], &sampleRate);
+  if (argc > 2) napi_get_value_int32(env, argv[2], &channels);
+  if (argc > 3) napi_get_value_int32(env, argv[3], &blockSize);
+
+  vst3_plugin_t* plugin = vst3_open(path, sampleRate, channels, blockSize);
+  if (!plugin) {
+    const char* err = vst3_get_error();
+    napi_throw_error(env, NULL, err[0] ? err : "Failed to load VST3 plugin");
+    return NULL;
+  }
+
+  napi_value ext;
+  NAPI_CALL(env, napi_create_external(env, plugin, destructor, NULL, &ext));
+  return ext;
+}
+
+/* close(handle) */
+static napi_value node_close(napi_env env, napi_callback_info info) {
+  size_t argc = 1; napi_value argv[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  vst3_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+  vst3_close(p);
+  return NULL;
+}
+
+/* getName(handle) → string */
+static napi_value node_getName(napi_env env, napi_callback_info info) {
+  size_t argc = 1; napi_value argv[1];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  vst3_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+  napi_value result;
+  napi_create_string_utf8(env, vst3_get_name(p), NAPI_AUTO_LENGTH, &result);
+  return result;
+}
+
+/* getVendor(handle) → string */
+static napi_value node_getVendor(napi_env env, napi_callback_info info) {
+  size_t argc = 1; napi_value argv[1];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  vst3_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+  napi_value result;
+  napi_create_string_utf8(env, vst3_get_vendor(p), NAPI_AUTO_LENGTH, &result);
+  return result;
+}
+
+/* getChannels(handle, dir) → number */
+static napi_value node_getChannels(napi_env env, napi_callback_info info) {
+  size_t argc = 2; napi_value argv[2];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  vst3_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+  int dir = 0; if (argc > 1) napi_get_value_int32(env, argv[1], &dir);
+  napi_value result;
+  napi_create_int32(env, vst3_get_channels(p, dir), &result);
+  return result;
+}
+
+/* getParamCount(handle) → number */
+static napi_value node_getParamCount(napi_env env, napi_callback_info info) {
+  size_t argc = 1; napi_value argv[1];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  vst3_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+  napi_value result;
+  napi_create_int32(env, vst3_get_param_count(p), &result);
+  return result;
+}
+
+/* getParamInfo(handle, index) → { id, name, min, max, defaultValue, stepCount } */
+static napi_value node_getParamInfo(napi_env env, napi_callback_info info) {
+  size_t argc = 2; napi_value argv[2];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  vst3_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+  int index; napi_get_value_int32(env, argv[1], &index);
+
+  vst3_param_info_t pi;
+  if (vst3_get_param_info(p, index, &pi) != 0) return NULL;
+
+  napi_value obj, val;
+  napi_create_object(env, &obj);
+
+  napi_create_uint32(env, pi.id, &val); napi_set_named_property(env, obj, "id", val);
+  napi_create_string_utf8(env, pi.name, NAPI_AUTO_LENGTH, &val); napi_set_named_property(env, obj, "name", val);
+  napi_create_double(env, pi.min, &val); napi_set_named_property(env, obj, "min", val);
+  napi_create_double(env, pi.max, &val); napi_set_named_property(env, obj, "max", val);
+  napi_create_double(env, pi.defaultValue, &val); napi_set_named_property(env, obj, "defaultValue", val);
+  napi_create_int32(env, pi.stepCount, &val); napi_set_named_property(env, obj, "stepCount", val);
+
+  return obj;
+}
+
+/* getParam(handle, id) → number */
+static napi_value node_getParam(napi_env env, napi_callback_info info) {
+  size_t argc = 2; napi_value argv[2];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  vst3_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+  uint32_t id; napi_get_value_uint32(env, argv[1], &id);
+  napi_value result;
+  napi_create_double(env, vst3_get_param(p, id), &result);
+  return result;
+}
+
+/* setParam(handle, id, value) */
+static napi_value node_setParam(napi_env env, napi_callback_info info) {
+  size_t argc = 3; napi_value argv[3];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  vst3_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+  uint32_t id; napi_get_value_uint32(env, argv[1], &id);
+  double val; napi_get_value_double(env, argv[2], &val);
+  vst3_set_param(p, id, val);
+  return NULL;
+}
+
+/* process(handle, inputs, outputs) — inputs/outputs are arrays of Float32Array */
+static napi_value node_process(napi_env env, napi_callback_info info) {
+  size_t argc = 3; napi_value argv[3];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  vst3_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+
+  float* inPtrs[8] = {};
+  float* outPtrs[8] = {};
+  uint32_t numCh = 0;
+  size_t numSamples = 0;
+
+  /* Extract input channel pointers */
+  bool hasInputs = false;
+  napi_valuetype inputType;
+  napi_typeof(env, argv[1], &inputType);
+  if (inputType != napi_null && inputType != napi_undefined) {
+    hasInputs = true;
+    napi_get_array_length(env, argv[1], &numCh);
+    for (uint32_t i = 0; i < numCh && i < 8; i++) {
+      napi_value el; napi_get_element(env, argv[1], i, &el);
+      void* data; size_t len;
+      napi_get_typedarray_info(env, el, NULL, &len, &data, NULL, NULL);
+      inPtrs[i] = (float*)data;
+      if (i == 0) numSamples = len;
+    }
+  }
+
+  /* Extract output channel pointers */
+  uint32_t outCh;
+  napi_get_array_length(env, argv[2], &outCh);
+  for (uint32_t i = 0; i < outCh && i < 8; i++) {
+    napi_value el; napi_get_element(env, argv[2], i, &el);
+    void* data;
+    napi_get_typedarray_info(env, el, NULL, NULL, &data, NULL, NULL);
+    outPtrs[i] = (float*)data;
+  }
+  if (!numCh) numCh = outCh;
+  if (!numSamples) {
+    /* Get length from output if no input */
+    napi_value el; napi_get_element(env, argv[2], 0, &el);
+    size_t len; napi_get_typedarray_info(env, el, NULL, &len, NULL, NULL, NULL);
+    numSamples = len;
+  }
+
+  vst3_process(p, hasInputs ? inPtrs : NULL, outPtrs, numCh, (int)numSamples);
+  return NULL;
+}
+
+/* getState(handle) → Buffer */
+static napi_value node_getState(napi_env env, napi_callback_info info) {
+  size_t argc = 1; napi_value argv[1];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  vst3_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+
+  void* data; int size;
+  if (vst3_get_state(p, &data, &size) != 0) return NULL;
+
+  napi_value buf;
+  void* bufData;
+  napi_create_buffer_copy(env, size, data, &bufData, &buf);
+  vst3_free_state(data);
+  return buf;
+}
+
+/* setState(handle, buffer) */
+static napi_value node_setState(napi_env env, napi_callback_info info) {
+  size_t argc = 2; napi_value argv[2];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  vst3_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+
+  void* data; size_t len;
+  napi_get_buffer_info(env, argv[1], &data, &len);
+  vst3_set_state(p, data, (int)len);
+  return NULL;
+}
+
+/* Module init */
+static napi_value init(napi_env env, napi_value exports) {
+  napi_property_descriptor props[] = {
+    { "open",          NULL, node_open,          NULL, NULL, NULL, napi_default, NULL },
+    { "close",         NULL, node_close,         NULL, NULL, NULL, napi_default, NULL },
+    { "getName",       NULL, node_getName,       NULL, NULL, NULL, napi_default, NULL },
+    { "getVendor",     NULL, node_getVendor,     NULL, NULL, NULL, napi_default, NULL },
+    { "getChannels",   NULL, node_getChannels,   NULL, NULL, NULL, napi_default, NULL },
+    { "getParamCount", NULL, node_getParamCount, NULL, NULL, NULL, napi_default, NULL },
+    { "getParamInfo",  NULL, node_getParamInfo,  NULL, NULL, NULL, napi_default, NULL },
+    { "getParam",      NULL, node_getParam,      NULL, NULL, NULL, napi_default, NULL },
+    { "setParam",      NULL, node_setParam,      NULL, NULL, NULL, napi_default, NULL },
+    { "process",       NULL, node_process,       NULL, NULL, NULL, napi_default, NULL },
+    { "getState",      NULL, node_getState,      NULL, NULL, NULL, napi_default, NULL },
+    { "setState",      NULL, node_setState,      NULL, NULL, NULL, napi_default, NULL },
+  };
+  napi_define_properties(env, exports, 12, props);
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, init)

package/native/host.cpp

@@ -0,0 +1,423 @@
+/*
+ * host.cpp — VST3 plugin host implementation
+ */
+#include "vst3.h"
+#include "host.h"
+#include <string>
+#include <vector>
+#include <cstring>
+
+#ifdef _WIN32
+  #define WIN32_LEAN_AND_MEAN
+  #include <windows.h>
+#else
+  #include <dlfcn.h>
+  #include <dirent.h>
+#endif
+
+#ifdef __APPLE__
+  #include <CoreFoundation/CoreFoundation.h>
+#endif
+
+using namespace Steinberg;
+using namespace Steinberg::Vst;
+
+/* Non-COM TUIDs for factory->createInstance */
+static const TUID IID_IComponent = {
+  (int8)0xE8,0x31,(int8)0xFF,0x31, (int8)0xF2,(int8)0xD5,0x43,0x01,
+  (int8)0x92,(int8)0x8E,(int8)0xBB,(int8)0xEE, 0x25,0x69,0x78,0x02 };
+static const TUID IID_FUnknown = {
+  0,0,0,0, 0,0,0,0, (int8)0xC0,0,0,0, 0,0,0,0x46 };
+
+/* --- Cross-platform dynamic loading --- */
+
+#ifdef _WIN32
+  static inline void* lib_open(const char* path) { return (void*)LoadLibraryA(path); }
+  static inline void* lib_sym(void* lib, const char* name) { return (void*)GetProcAddress((HMODULE)lib, name); }
+  static inline void  lib_close(void* lib) { FreeLibrary((HMODULE)lib); }
+  static inline const char* lib_error() { static char buf[128]; snprintf(buf, sizeof(buf), "error %lu", GetLastError()); return buf; }
+#else
+  static inline void* lib_open(const char* path) { return dlopen(path, RTLD_NOW); }
+  static inline void* lib_sym(void* lib, const char* name) { return dlsym(lib, name); }
+  static inline void  lib_close(void* lib) { dlclose(lib); }
+  static inline const char* lib_error() { return dlerror(); }
+#endif
+
+static thread_local char s_error[512] = {0};
+static void set_error(const char* fmt, const char* detail = "") {
+  snprintf(s_error, sizeof(s_error), "%s%s", fmt, detail);
+}
+
+/* --- Host-side COM implementations --- */
+
+class HostContext : public IHostApplication {
+  uint32 ref = 1;
+public:
+  tresult queryInterface(const TUID _iid, void** obj) override {
+    if (tuid_match(_iid, UID_FUnknown) || tuid_match(_iid, UID_IHostApplication)) {
+      addRef(); *obj = this; return kResultOk;
+    }
+    *obj = nullptr; return kResultFalse;
+  }
+  uint32 addRef() override { return ++ref; }
+  uint32 release() override { if (--ref == 0) { delete this; return 0; } return ref; }
+  tresult getName(String128 name) override {
+    const char16 n[] = u"audio-host";
+    memcpy(name, n, sizeof(n));
+    return kResultOk;
+  }
+  tresult createInstance(const TUID, const TUID, void** obj) override {
+    *obj = nullptr; return kNotImplemented;
+  }
+};
+
+class MemStream : public IBStream {
+  std::vector<uint8_t> buf;
+  int64 pos = 0;
+  uint32 ref = 1;
+public:
+  tresult queryInterface(const TUID _iid, void** obj) override {
+    if (tuid_match(_iid, UID_FUnknown) || tuid_match(_iid, UID_IBStream)) {
+      addRef(); *obj = this; return kResultOk;
+    }
+    *obj = nullptr; return kResultFalse;
+  }
+  uint32 addRef() override { return ++ref; }
+  uint32 release() override { if (--ref == 0) { delete this; return 0; } return ref; }
+  tresult read(void* buffer, int32 numBytes, int32* numBytesRead) override {
+    int32 avail = (int32)buf.size() - (int32)pos;
+    int32 n = numBytes < avail ? numBytes : (avail > 0 ? avail : 0);
+    if (n > 0) memcpy(buffer, buf.data() + pos, n);
+    pos += n;
+    if (numBytesRead) *numBytesRead = n;
+    return kResultOk;
+  }
+  tresult write(void* buffer, int32 numBytes, int32* numBytesWritten) override {
+    if (pos + numBytes > (int64)buf.size()) buf.resize(pos + numBytes);
+    memcpy(buf.data() + pos, buffer, numBytes);
+    pos += numBytes;
+    if (numBytesWritten) *numBytesWritten = numBytes;
+    return kResultOk;
+  }
+  tresult seek(int64 p, int32 mode, int64* result) override {
+    if (mode == 0) pos = p;
+    else if (mode == 1) pos += p;
+    else pos = (int64)buf.size() + p;
+    if (pos < 0) pos = 0;
+    if (result) *result = pos;
+    return kResultOk;
+  }
+  tresult tell(int64* p) override { *p = pos; return kResultOk; }
+  const uint8_t* data() const { return buf.data(); }
+  size_t size() const { return buf.size(); }
+  void setData(const uint8_t* d, size_t s) { buf.assign(d, d + s); pos = 0; }
+};
+
+/* --- Plugin handle --- */
+
+struct vst3_plugin {
+  void* lib;
+  IPluginFactory* factory;
+  IComponent* component;
+  IAudioProcessor* processor;
+  IEditController* controller;
+  bool ctrlSeparate;
+  HostContext* ctx;
+  int32 inCh, outCh;
+  double sampleRate;
+  int32 blockSize;
+  char name[64];
+  char vendor[64];
+#ifdef __APPLE__
+  CFBundleRef bundle;
+#endif
+};
+
+/* --- Helpers --- */
+
+/* Find the shared library inside a .vst3 bundle */
+static std::string findBinary(const char* bundlePath) {
+  std::string base(bundlePath);
+  while (!base.empty() && (base.back() == '/' || base.back() == '\\')) base.pop_back();
+
+#ifdef _WIN32
+  /* Windows: Contents/x86_64-win/*.vst3 */
+  std::string archDir = base + "\\Contents\\x86_64-win";
+  WIN32_FIND_DATAA fd;
+  HANDLE h = FindFirstFileA((archDir + "\\*.vst3").c_str(), &fd);
+  if (h != INVALID_HANDLE_VALUE) {
+    std::string result = archDir + "\\" + fd.cFileName;
+    FindClose(h);
+    return result;
+  }
+  /* Flat .vst3 file (not a bundle) */
+  return base;
+#else
+  /* macOS: Contents/MacOS/<binary> */
+  std::string macosDir = base + "/Contents/MacOS";
+  DIR* dir = opendir(macosDir.c_str());
+  if (!dir) return "";
+  std::string result;
+  struct dirent* entry;
+  while ((entry = readdir(dir))) {
+    if (entry->d_name[0] == '.') continue;
+    result = macosDir + "/" + entry->d_name;
+    break;
+  }
+  closedir(dir);
+  return result;
+#endif
+}
+
+static std::string u16to8(const char16* s, int maxLen = 128) {
+  std::string r;
+  for (int i = 0; i < maxLen && s[i]; i++) {
+    char16 c = s[i];
+    if (c < 0x80) r += (char)c;
+    else if (c < 0x800) { r += (char)(0xC0 | (c >> 6)); r += (char)(0x80 | (c & 0x3F)); }
+    else { r += (char)(0xE0 | (c >> 12)); r += (char)(0x80 | ((c >> 6) & 0x3F)); r += (char)(0x80 | (c & 0x3F)); }
+  }
+  return r;
+}
+
+/* --- C API --- */
+
+extern "C" {
+
+const char* vst3_get_error(void) { return s_error; }
+
+vst3_plugin_t* vst3_open(const char* path, double sampleRate, int channels, int blockSize) {
+  s_error[0] = 0;
+
+  std::string dylib = findBinary(path);
+  if (dylib.empty()) { set_error("No binary in bundle: ", path); return nullptr; }
+
+  void* lib = lib_open(dylib.c_str());
+  if (!lib) { set_error("dlopen failed: ", lib_error()); return nullptr; }
+
+#ifdef __APPLE__
+  CFBundleRef bundle = nullptr;
+  {
+    std::string bp(path);
+    while (!bp.empty() && bp.back() == '/') bp.pop_back();
+    CFURLRef url = CFURLCreateFromFileSystemRepresentation(
+      kCFAllocatorDefault, (const UInt8*)bp.c_str(), bp.size(), true);
+    if (url) { bundle = CFBundleCreate(kCFAllocatorDefault, url); CFRelease(url); }
+  }
+  typedef bool (*BundleEntryFn)(CFBundleRef);
+  auto bundleEntry = (BundleEntryFn)lib_sym(lib,"bundleEntry");
+  if (bundleEntry) bundleEntry(bundle);
+#endif
+
+  typedef IPluginFactory* (*GetFactoryFn)();
+  auto getFactory = (GetFactoryFn)lib_sym(lib,"GetPluginFactory");
+  if (!getFactory) { set_error("No GetPluginFactory"); lib_close(lib); return nullptr; }
+
+  IPluginFactory* factory = getFactory();
+  if (!factory) { set_error("GetPluginFactory returned null"); lib_close(lib); return nullptr; }
+
+  PClassInfo ci;
+  int found = -1;
+  for (int32 i = 0; i < factory->countClasses(); i++) {
+    factory->getClassInfo(i, &ci);
+    if (strcmp(ci.category, "Audio Module Class") == 0) { found = i; break; }
+  }
+  if (found < 0) { set_error("No Audio Module Class"); factory->release(); lib_close(lib); return nullptr; }
+  factory->getClassInfo(found, &ci);
+
+  PFactoryInfo fi;
+  factory->getFactoryInfo(&fi);
+
+  IComponent* component = nullptr;
+  if (factory->createInstance(ci.cid, IID_IComponent, (void**)&component) != kResultOk || !component) {
+    set_error("createInstance IComponent failed");
+    factory->release(); lib_close(lib); return nullptr;
+  }
+
+  HostContext* ctx = new HostContext();
+  if (component->initialize((FUnknown*)ctx) != kResultOk) {
+    set_error("IComponent::initialize failed");
+    component->release(); factory->release(); lib_close(lib); delete ctx; return nullptr;
+  }
+
+  IAudioProcessor* processor = nullptr;
+  qi((FUnknown*)component, UID_IAudioProcessor, (void**)&processor);
+  if (!processor) {
+    set_error("No IAudioProcessor");
+    component->terminate(); component->release(); factory->release(); lib_close(lib); delete ctx; return nullptr;
+  }
+
+  /* Get IEditController — may be same object or separate class */
+  IEditController* controller = nullptr;
+  bool ctrlSeparate = false;
+  if (qi((FUnknown*)component, UID_IEditController, (void**)&controller) != kResultOk || !controller) {
+    TUID ctrlCid;
+    if (component->getControllerClassId(ctrlCid) == kResultOk) {
+      FUnknown* ctrlObj = nullptr;
+      if (factory->createInstance(ctrlCid, IID_FUnknown, (void**)&ctrlObj) == kResultOk && ctrlObj) {
+        qi(ctrlObj, UID_IEditController, (void**)&controller);
+        if (controller) {
+          ctrlSeparate = true;
+          controller->initialize((FUnknown*)ctx);
+          /* Connect component ↔ controller via IConnectionPoint */
+          IConnectionPoint *compCP = nullptr, *ctrlCP = nullptr;
+          qi((FUnknown*)component, UID_IConnectionPoint, (void**)&compCP);
+          qi((FUnknown*)controller, UID_IConnectionPoint, (void**)&ctrlCP);
+          if (compCP && ctrlCP) { compCP->connect(ctrlCP); ctrlCP->connect(compCP); }
+          if (compCP) compCP->release();
+          if (ctrlCP) ctrlCP->release();
+        }
+        ctrlObj->release();
+      }
+    }
+  }
+
+  ProcessSetup setup = { kRealtime, kSample32, blockSize, sampleRate };
+  processor->setupProcessing(setup);
+
+  int32 inCh = 0, outCh = 0;
+  if (component->getBusCount(kAudio, kInput) > 0) {
+    BusInfo bi; component->getBusInfo(kAudio, kInput, 0, bi);
+    inCh = bi.channelCount;
+    component->activateBus(kAudio, kInput, 0, true);
+  }
+  if (component->getBusCount(kAudio, kOutput) > 0) {
+    BusInfo bi; component->getBusInfo(kAudio, kOutput, 0, bi);
+    outCh = bi.channelCount;
+    component->activateBus(kAudio, kOutput, 0, true);
+  }
+  if (inCh == 0) inCh = channels;
+  if (outCh == 0) outCh = channels;
+
+  component->setActive(true);
+  processor->setProcessing(true);
+
+  auto* p = new vst3_plugin();
+  p->lib = lib; p->factory = factory; p->component = component;
+  p->processor = processor; p->controller = controller; p->ctrlSeparate = ctrlSeparate;
+  p->ctx = ctx; p->inCh = inCh; p->outCh = outCh;
+  p->sampleRate = sampleRate; p->blockSize = blockSize;
+  strncpy(p->name, ci.name, 63); p->name[63] = 0;
+  strncpy(p->vendor, fi.vendor, 63); p->vendor[63] = 0;
+#ifdef __APPLE__
+  p->bundle = bundle;
+#endif
+  return (vst3_plugin_t*)p;
+}
+
+void vst3_close(vst3_plugin_t* handle) {
+  if (!handle) return;
+  auto* p = (vst3_plugin*)handle;
+  if (!p->lib) return; /* already closed */
+
+  if (p->processor) { p->processor->setProcessing(false); p->processor->release(); p->processor = nullptr; }
+  if (p->component) { p->component->setActive(false); p->component->terminate(); p->component->release(); p->component = nullptr; }
+  if (p->controller && p->ctrlSeparate) { p->controller->terminate(); p->controller->release(); }
+  p->controller = nullptr;
+  if (p->factory) { p->factory->release(); p->factory = nullptr; }
+
+  typedef bool (*BundleExitFn)();
+  auto bundleExit = (BundleExitFn)lib_sym(p->lib,"bundleExit");
+  if (bundleExit) bundleExit();
+  lib_close(p->lib);
+  p->lib = nullptr;
+
+#ifdef __APPLE__
+  if (p->bundle) { CFRelease(p->bundle); p->bundle = nullptr; }
+#endif
+  if (p->ctx) { p->ctx->release(); p->ctx = nullptr; }
+}
+
+void vst3_destroy(vst3_plugin_t* handle) {
+  if (!handle) return;
+  vst3_close(handle);
+  delete (vst3_plugin*)handle;
+}
+
+void vst3_process(vst3_plugin_t* handle, float** inputs, float** outputs, int numChannels, int numSamples) {
+  auto* p = (vst3_plugin*)handle;
+  if (!p || !p->processor) return;
+
+  AudioBusBuffers inBus = { numChannels, 0, {} };
+  inBus.channelBuffers32 = inputs;
+  AudioBusBuffers outBus = { numChannels, 0, {} };
+  outBus.channelBuffers32 = outputs;
+
+  ProcessData data = {};
+  data.processMode = kRealtime;
+  data.symbolicSampleSize = kSample32;
+  data.numSamples = numSamples;
+  data.numInputs = inputs ? 1 : 0;
+  data.numOutputs = 1;
+  data.inputs = inputs ? &inBus : nullptr;
+  data.outputs = &outBus;
+  data.inputParameterChanges = nullptr;
+  data.outputParameterChanges = nullptr;
+  data.inputEvents = nullptr;
+  data.outputEvents = nullptr;
+
+  p->processor->process(data);
+}
+
+const char* vst3_get_name(vst3_plugin_t* h) { return h ? ((vst3_plugin*)h)->name : ""; }
+const char* vst3_get_vendor(vst3_plugin_t* h) { return h ? ((vst3_plugin*)h)->vendor : ""; }
+int vst3_get_channels(vst3_plugin_t* h, int dir) {
+  if (!h) return 0;
+  return dir == 0 ? ((vst3_plugin*)h)->inCh : ((vst3_plugin*)h)->outCh;
+}
+
+int vst3_get_param_count(vst3_plugin_t* h) {
+  auto* p = (vst3_plugin*)h;
+  return (p && p->controller) ? p->controller->getParameterCount() : 0;
+}
+
+int vst3_get_param_info(vst3_plugin_t* h, int index, vst3_param_info_t* out) {
+  auto* p = (vst3_plugin*)h;
+  if (!p || !p->controller) return -1;
+  ParameterInfo info;
+  if (p->controller->getParameterInfo(index, info) != kResultOk) return -1;
+  out->id = info.id;
+  std::string name = u16to8(info.title);
+  strncpy(out->name, name.c_str(), 255); out->name[255] = 0;
+  out->defaultValue = info.defaultNormalizedValue;
+  out->stepCount = info.stepCount;
+  out->min = p->controller->normalizedParamToPlain(info.id, 0.0);
+  out->max = p->controller->normalizedParamToPlain(info.id, 1.0);
+  return 0;
+}
+
+double vst3_get_param(vst3_plugin_t* h, uint32_t id) {
+  auto* p = (vst3_plugin*)h;
+  return (p && p->controller) ? p->controller->getParamNormalized(id) : 0;
+}
+
+void vst3_set_param(vst3_plugin_t* h, uint32_t id, double value) {
+  auto* p = (vst3_plugin*)h;
+  if (p && p->controller) p->controller->setParamNormalized(id, value);
+}
+
+int vst3_get_state(vst3_plugin_t* h, void** data, int* size) {
+  auto* p = (vst3_plugin*)h;
+  if (!p || !p->component) return -1;
+  auto* s = new MemStream();
+  if (p->component->getState(s) != kResultOk) { s->release(); return -1; }
+  *size = (int)s->size();
+  *data = malloc(*size);
+  memcpy(*data, s->data(), *size);
+  s->release();
+  return 0;
+}
+
+int vst3_set_state(vst3_plugin_t* h, const void* data, int size) {
+  auto* p = (vst3_plugin*)h;
+  if (!p || !p->component) return -1;
+  auto* s = new MemStream();
+  s->setData((const uint8_t*)data, size);
+  tresult r = p->component->setState(s);
+  s->release();
+  return r == kResultOk ? 0 : -1;
+}
+
+void vst3_free_state(void* data) { free(data); }
+
+} /* extern "C" */

package/native/host.h

@@ -0,0 +1,45 @@
+/*
+ * host.h — C API for the VST3 host
+ */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+typedef struct vst3_plugin vst3_plugin_t;
+
+typedef struct {
+  uint32_t id;
+  char name[256];
+  double min;
+  double max;
+  double defaultValue;
+  int32_t stepCount;
+} vst3_param_info_t;
+
+vst3_plugin_t* vst3_open(const char* path, double sampleRate, int channels, int blockSize);
+void vst3_close(vst3_plugin_t* handle);  /* idempotent deactivate */
+void vst3_destroy(vst3_plugin_t* handle); /* close + free */
+void vst3_process(vst3_plugin_t* handle, float** inputs, float** outputs, int numChannels, int numSamples);
+
+const char* vst3_get_name(vst3_plugin_t* handle);
+const char* vst3_get_vendor(vst3_plugin_t* handle);
+int vst3_get_channels(vst3_plugin_t* handle, int dir); /* 0=in, 1=out */
+
+int vst3_get_param_count(vst3_plugin_t* handle);
+int vst3_get_param_info(vst3_plugin_t* handle, int index, vst3_param_info_t* info);
+double vst3_get_param(vst3_plugin_t* handle, uint32_t id);
+void vst3_set_param(vst3_plugin_t* handle, uint32_t id, double value);
+
+int vst3_get_state(vst3_plugin_t* handle, void** data, int* size);
+int vst3_set_state(vst3_plugin_t* handle, const void* data, int size);
+void vst3_free_state(void* data);
+
+const char* vst3_get_error(void);
+
+#ifdef __cplusplus
+}
+#endif

package/native/vst3.h

@@ -0,0 +1,232 @@
+/*
+ * vst3.h — Minimal VST3 COM interface definitions for plugin hosting
+ *
+ * ABI-compatible reimplementation of Steinberg VST3 interfaces.
+ * https://github.com/steinbergmedia/vst3sdk
+ */
+
+#pragma once
+#include <cstdint>
+#include <cstring>
+
+namespace Steinberg {
+
+typedef int32_t tresult;
+typedef int8_t int8;
+typedef int32_t int32;
+typedef int64_t int64;
+typedef uint32_t uint32;
+typedef uint64_t uint64;
+typedef char16_t char16;
+typedef int8 TUID[16];
+typedef char16 String128[128];
+
+enum { kResultOk = 0, kResultFalse = 1, kInvalidArgument = 2,
+       kNotImplemented = 3, kInternalError = 4, kNotInitialized = 5 };
+
+/* Build TUID at runtime — non-COM (Steinberg SDK) or COM (JUCE) byte order */
+static inline void make_tuid(TUID out, uint32_t l1, uint32_t l2, uint32_t l3, uint32_t l4, bool com) {
+  if (!com) {
+    out[0]=(int8)(l1>>24); out[1]=(int8)(l1>>16); out[2]=(int8)(l1>>8); out[3]=(int8)l1;
+    out[4]=(int8)(l2>>24); out[5]=(int8)(l2>>16); out[6]=(int8)(l2>>8); out[7]=(int8)l2;
+  } else {
+    out[0]=(int8)l1; out[1]=(int8)(l1>>8); out[2]=(int8)(l1>>16); out[3]=(int8)(l1>>24);
+    out[4]=(int8)(l2>>16); out[5]=(int8)(l2>>24); out[6]=(int8)l2; out[7]=(int8)(l2>>8);
+  }
+  out[8]=(int8)(l3>>24); out[9]=(int8)(l3>>16); out[10]=(int8)(l3>>8); out[11]=(int8)l3;
+  out[12]=(int8)(l4>>24); out[13]=(int8)(l4>>16); out[14]=(int8)(l4>>8); out[15]=(int8)l4;
+}
+
+/* Match TUID against 4x uint32 in either byte order */
+static inline bool tuid_match(const TUID a, uint32_t l1, uint32_t l2, uint32_t l3, uint32_t l4) {
+  TUID b;
+  make_tuid(b, l1, l2, l3, l4, false);
+  if (memcmp(a, b, 16) == 0) return true;
+  make_tuid(b, l1, l2, l3, l4, true);
+  return memcmp(a, b, 16) == 0;
+}
+
+/* Well-known interface IDs (byte-order-independent form) */
+#define UID_FUnknown          0x00000000, 0x00000000, 0xC0000000, 0x00000046
+#define UID_IComponent        0xE831FF31, 0xF2D54301, 0x928EBBEE, 0x25697802
+#define UID_IAudioProcessor   0x42043F99, 0xB7DA453C, 0xA569E79D, 0x9AAEC33D
+#define UID_IEditController   0xDCD7BBE3, 0x7742448D, 0xA874AACC, 0x979C759E
+#define UID_IConnectionPoint  0x70A4156F, 0x6E6E4026, 0x989148BF, 0xAA60D8D1
+#define UID_IHostApplication  0x58E595CC, 0xDB2D4369, 0xA2BF7201, 0x1B2B26B2
+#define UID_IBStream          0xC3BF6EA2, 0x30994523, 0x9124FE83, 0x0C727026
+
+/* --- Base interfaces --- */
+
+class FUnknown {
+public:
+  virtual tresult queryInterface(const TUID _iid, void** obj) = 0;
+  virtual uint32 addRef() = 0;
+  virtual uint32 release() = 0;
+};
+
+/* queryInterface trying both byte orders (Steinberg SDK vs JUCE) */
+static inline tresult qi(FUnknown* obj, uint32_t l1, uint32_t l2, uint32_t l3, uint32_t l4, void** out) {
+  TUID id;
+  make_tuid(id, l1, l2, l3, l4, false);
+  tresult r = obj->queryInterface(id, out);
+  if (r == kResultOk && *out) return r;
+  make_tuid(id, l1, l2, l3, l4, true);
+  return obj->queryInterface(id, out);
+}
+
+class IBStream : public FUnknown {
+public:
+  virtual tresult read(void* buffer, int32 numBytes, int32* numBytesRead) = 0;
+  virtual tresult write(void* buffer, int32 numBytes, int32* numBytesWritten) = 0;
+  virtual tresult seek(int64 pos, int32 mode, int64* result) = 0;
+  virtual tresult tell(int64* pos) = 0;
+};
+
+class IPluginBase : public FUnknown {
+public:
+  virtual tresult initialize(FUnknown* context) = 0;
+  virtual tresult terminate() = 0;
+};
+
+/* --- Factory --- */
+
+struct PClassInfo {
+  TUID cid;
+  int32 cardinality;
+  char category[32];
+  char name[64];
+};
+
+struct PFactoryInfo {
+  char vendor[64];
+  char url[256];
+  char email[128];
+  int32 flags;
+};
+
+class IPluginFactory : public FUnknown {
+public:
+  virtual tresult getFactoryInfo(PFactoryInfo* info) = 0;
+  virtual int32 countClasses() = 0;
+  virtual tresult getClassInfo(int32 index, PClassInfo* info) = 0;
+  virtual tresult createInstance(const TUID cid, const TUID iid, void** obj) = 0;
+};
+
+/* --- VST-specific --- */
+
+namespace Vst {
+
+enum MediaTypes { kAudio = 0, kEvent = 1 };
+enum BusDirections { kInput = 0, kOutput = 1 };
+enum { kSample32 = 0, kSample64 = 1, kRealtime = 0 };
+typedef uint32 ParamID;
+typedef double ParamValue;
+
+struct BusInfo {
+  int32 mediaType;
+  int32 direction;
+  int32 channelCount;
+  String128 name;
+  int32 busType;
+  uint32 flags;
+};
+
+struct ProcessSetup {
+  int32 processMode;
+  int32 symbolicSampleSize;
+  int32 maxSamplesPerBlock;
+  double sampleRate;
+};
+
+struct AudioBusBuffers {
+  int32 numChannels;
+  uint64 silenceFlags;
+  union {
+    float** channelBuffers32;
+    double** channelBuffers64;
+  };
+};
+
+struct ProcessData {
+  int32 processMode;
+  int32 symbolicSampleSize;
+  int32 numSamples;
+  int32 numInputs;
+  int32 numOutputs;
+  AudioBusBuffers* inputs;
+  AudioBusBuffers* outputs;
+  void* inputParameterChanges;
+  void* outputParameterChanges;
+  void* inputEvents;
+  void* outputEvents;
+  void* processContext;
+};
+
+struct ParameterInfo {
+  ParamID id;
+  String128 title;
+  String128 shortTitle;
+  String128 units;
+  int32 stepCount;
+  ParamValue defaultNormalizedValue;
+  int32 unitId;
+  int32 flags;
+};
+
+class IComponent : public IPluginBase {
+public:
+  virtual tresult getControllerClassId(TUID classId) = 0;
+  virtual tresult setIoMode(int32 mode) = 0;
+  virtual int32 getBusCount(int32 type, int32 dir) = 0;
+  virtual tresult getBusInfo(int32 type, int32 dir, int32 index, BusInfo& bus) = 0;
+  virtual tresult getRoutingInfo(void* inInfo, void* outInfo) = 0;
+  virtual tresult activateBus(int32 type, int32 dir, int32 index, bool state) = 0;
+  virtual tresult setActive(bool state) = 0;
+  virtual tresult setState(IBStream* state) = 0;
+  virtual tresult getState(IBStream* state) = 0;
+};
+
+class IAudioProcessor : public FUnknown {
+public:
+  virtual tresult setBusArrangements(uint64* inputs, int32 numIns, uint64* outputs, int32 numOuts) = 0;
+  virtual tresult getBusArrangement(int32 dir, int32 index, uint64& arr) = 0;
+  virtual tresult canProcessSampleSize(int32 symbolicSampleSize) = 0;
+  virtual uint32 getLatencySamples() = 0;
+  virtual tresult setupProcessing(ProcessSetup& setup) = 0;
+  virtual tresult setProcessing(bool state) = 0;
+  virtual tresult process(ProcessData& data) = 0;
+  virtual uint32 getTailSamples() = 0;
+};
+
+class IEditController : public IPluginBase {
+public:
+  virtual tresult setComponentState(IBStream* state) = 0;
+  virtual tresult setState(IBStream* state) = 0;
+  virtual tresult getState(IBStream* state) = 0;
+  virtual int32 getParameterCount() = 0;
+  virtual tresult getParameterInfo(int32 paramIndex, ParameterInfo& info) = 0;
+  virtual tresult getParamStringByValue(ParamID id, ParamValue valueNormalized, String128 string) = 0;
+  virtual tresult getParamValueByString(ParamID id, char16* string, ParamValue& valueNormalized) = 0;
+  virtual ParamValue normalizedParamToPlain(ParamID id, ParamValue valueNormalized) = 0;
+  virtual ParamValue plainParamToNormalized(ParamID id, ParamValue plainValue) = 0;
+  virtual ParamValue getParamNormalized(ParamID id) = 0;
+  virtual tresult setParamNormalized(ParamID id, ParamValue value) = 0;
+  virtual tresult setComponentHandler(FUnknown* handler) = 0;
+  virtual void* createView(const char* name) = 0;
+};
+
+class IConnectionPoint : public FUnknown {
+public:
+  virtual tresult connect(IConnectionPoint* other) = 0;
+  virtual tresult disconnect(IConnectionPoint* other) = 0;
+  virtual tresult notify(void* message) = 0;
+};
+
+class IHostApplication : public FUnknown {
+public:
+  virtual tresult getName(String128 name) = 0;
+  virtual tresult createInstance(const TUID cid, const TUID iid, void** obj) = 0;
+};
+
+} // namespace Vst
+} // namespace Steinberg

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@audio/host-vst",
+  "version": "0.1.0",
+  "description": "VST3 plugin host for audiojs",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "gypfile": true,
+  "scripts": {
+    "build": "node-gyp rebuild",
+    "test": "node test.js"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "src/",
+    "native/",
+    "binding.gyp"
+  ],
+  "optionalDependencies": {
+    "@audio/host-vst-darwin-arm64": ">=0.1.0",
+    "@audio/host-vst-darwin-x64": ">=0.1.0",
+    "@audio/host-vst-linux-x64": ">=0.1.0",
+    "@audio/host-vst-linux-arm64": ">=0.1.0",
+    "@audio/host-vst-win32-x64": ">=0.1.0"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "tst": "^9.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/addon.js

@@ -0,0 +1,26 @@
+/**
+ * NAPI addon loader — tries prebuilt, then local build
+ */
+import { createRequire } from 'node:module'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { arch, platform } from 'node:os'
+
+const require = createRequire(import.meta.url)
+const root = join(dirname(fileURLToPath(import.meta.url)), '..')
+const plat = `${platform()}-${arch()}`
+
+let addon
+const loaders = [
+  () => require(`@audio/host-vst-${plat}`),
+  () => require(join(root, 'packages', `host-vst-${plat}`, 'host_vst.node')),
+  () => require(join(root, 'prebuilds', plat, 'host_vst.node')),
+  () => require(join(root, 'build', 'Release', 'host_vst.node')),
+  () => require(join(root, 'build', 'Debug', 'host_vst.node')),
+]
+for (const load of loaders) {
+  try { addon = load(); break } catch {}
+}
+if (!addon) throw new Error('host-vst addon not found — run `npm run build` or install @audio/host-vst-' + plat)
+
+export default addon