@audio/host-clap 0.1.0

package/binding.gyp

@@ -0,0 +1,18 @@
+{
+  "targets": [{
+    "target_name": "host_clap",
+    "sources": ["native/host.c", "native/binding.c"],
+    "include_dirs": ["native"],
+    "cflags": ["-std=c99", "-O2"],
+    "xcode_settings": {
+      "OTHER_CFLAGS": ["-std=c99", "-O2"],
+      "MACOSX_DEPLOYMENT_TARGET": "10.13"
+    },
+    "msvs_settings": {
+      "VCCLCompilerTool": { "AdditionalOptions": ["/O2"] }
+    },
+    "conditions": [
+      ["OS=='linux'", { "libraries": ["-ldl"] }]
+    ]
+  }]
+}

package/index.js

@@ -0,0 +1,159 @@
+/**
+ * @module @audio/host-clap
+ * CLAP 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) },
+    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) },
+
+    process(inputs, outputs) { addon.process(handle, inputs, outputs) },
+    processAll(ch) { return processBlocks(addon, handle, ch, blockSize) },
+
+    close() {
+      if (closed) return
+      closed = true
+      addon.close(handle)
+    }
+  }
+}
+
+/**
+ * Scan system for installed CLAP 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/CLAP', '$HOME/Library/Audio/Plug-Ins/CLAP'],
+    linux: ['$HOME/.clap', '/usr/lib/clap', '/usr/local/lib/clap'],
+    win32: ['$PROGRAMFILES/Common Files/CLAP'],
+  }), '.clap', 'clap')
+}
+
+/**
+ * Register a CLAP 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) {
+  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 {}
+    }
+  }
+
+  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.c

@@ -0,0 +1,160 @@
+/*
+ * binding.c — NAPI bindings for CLAP 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;
+  clap_host_destroy((clap_host_plugin_t*)data);
+}
+
+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);
+
+  clap_host_plugin_t* plugin = clap_host_open(path, sampleRate, channels, blockSize);
+  if (!plugin) {
+    const char* err = clap_host_get_error();
+    napi_throw_error(env, NULL, err[0] ? err : "Failed to load CLAP plugin");
+    return NULL;
+  }
+
+  napi_value ext;
+  NAPI_CALL(env, napi_create_external(env, plugin, destructor, NULL, &ext));
+  return ext;
+}
+
+static napi_value node_close(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);
+  clap_host_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+  clap_host_close(p);
+  return NULL;
+}
+
+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);
+  clap_host_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+  napi_value r; napi_create_string_utf8(env, clap_host_get_name(p), NAPI_AUTO_LENGTH, &r);
+  return r;
+}
+
+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);
+  clap_host_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+  napi_value r; napi_create_string_utf8(env, clap_host_get_vendor(p), NAPI_AUTO_LENGTH, &r);
+  return r;
+}
+
+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);
+  clap_host_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+  napi_value r; napi_create_int32(env, clap_host_get_param_count(p), &r);
+  return r;
+}
+
+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);
+  clap_host_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+  int index; napi_get_value_int32(env, argv[1], &index);
+
+  clap_host_param_info_t pi;
+  if (clap_host_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);
+  return obj;
+}
+
+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);
+  clap_host_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 r; napi_create_double(env, clap_host_get_param(p, id), &r);
+  return r;
+}
+
+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);
+  clap_host_plugin_t* p; napi_get_value_external(env, argv[0], (void**)&p);
+
+  float* inPtrs[8] = {0};
+  float* outPtrs[8] = {0};
+  uint32_t numCh = 0;
+  size_t numSamples = 0;
+  int hasInputs = 0;
+
+  napi_valuetype inputType;
+  napi_typeof(env, argv[1], &inputType);
+  if (inputType != napi_null && inputType != napi_undefined) {
+    hasInputs = 1;
+    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;
+    }
+  }
+
+  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) {
+    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;
+  }
+
+  clap_host_process(p, hasInputs ? inPtrs : NULL, outPtrs, numCh, (int)numSamples);
+  return NULL;
+}
+
+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 },
+    { "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 },
+    { "process",       NULL, node_process,       NULL, NULL, NULL, napi_default, NULL },
+  };
+  napi_define_properties(env, exports, 8, props);
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, init)

package/native/clap.h

@@ -0,0 +1,163 @@
+/*
+ * clap.h — Minimal CLAP interface definitions for plugin hosting
+ *
+ * Based on CLAP SDK (https://github.com/free-audio/clap), MIT License.
+ * Only types needed for basic audio hosting are included.
+ */
+
+#pragma once
+#include <stdint.h>
+#include <stdbool.h>
+
+#define CLAP_VERSION_MAJOR 1
+#define CLAP_VERSION_MINOR 2
+#define CLAP_VERSION_REVISION 2
+#define CLAP_VERSION_INIT { CLAP_VERSION_MAJOR, CLAP_VERSION_MINOR, CLAP_VERSION_REVISION }
+
+typedef struct { uint32_t major, minor, revision; } clap_version_t;
+
+/* --- Entry point (exported from .clap binary) --- */
+
+typedef struct clap_plugin_entry {
+  clap_version_t clap_version;
+  bool (*init)(const char* plugin_path);
+  void (*deinit)(void);
+  const void* (*get_factory)(const char* factory_id);
+} clap_plugin_entry_t;
+
+/* --- Plugin factory --- */
+
+#define CLAP_PLUGIN_FACTORY_ID "clap.plugin-factory"
+
+typedef struct clap_plugin_descriptor {
+  clap_version_t clap_version;
+  const char* id;
+  const char* name;
+  const char* vendor;
+  const char* url;
+  const char* manual_url;
+  const char* support_url;
+  const char* version;
+  const char* description;
+  const char* const* features;
+} clap_plugin_descriptor_t;
+
+typedef struct clap_plugin clap_plugin_t;
+typedef struct clap_host clap_host_t;
+
+typedef struct clap_plugin_factory {
+  uint32_t (*get_plugin_count)(const struct clap_plugin_factory* factory);
+  const clap_plugin_descriptor_t* (*get_plugin_descriptor)(const struct clap_plugin_factory* factory, uint32_t index);
+  const clap_plugin_t* (*create_plugin)(const struct clap_plugin_factory* factory, const clap_host_t* host, const char* plugin_id);
+} clap_plugin_factory_t;
+
+/* --- Host (we implement this) --- */
+
+struct clap_host {
+  clap_version_t clap_version;
+  void* host_data;
+  const char* name;
+  const char* vendor;
+  const char* url;
+  const char* version;
+  const void* (*get_extension)(const clap_host_t* host, const char* extension_id);
+  void (*request_restart)(const clap_host_t* host);
+  void (*request_process)(const clap_host_t* host);
+  void (*request_callback)(const clap_host_t* host);
+};
+
+/* --- Audio buffer --- */
+
+typedef struct clap_audio_buffer {
+  float** data32;
+  double** data64;
+  uint32_t channel_count;
+  uint32_t latency;
+  uint64_t constant_mask;
+} clap_audio_buffer_t;
+
+/* --- Events --- */
+
+typedef struct clap_event_header {
+  uint32_t size;
+  uint32_t time;
+  uint16_t space_id;
+  uint16_t type;
+  uint32_t flags;
+} clap_event_header_t;
+
+typedef struct clap_input_events {
+  void* ctx;
+  uint32_t (*size)(const struct clap_input_events* list);
+  const clap_event_header_t* (*get)(const struct clap_input_events* list, uint32_t index);
+} clap_input_events_t;
+
+typedef struct clap_output_events {
+  void* ctx;
+  bool (*try_push)(const struct clap_output_events* list, const clap_event_header_t* event);
+} clap_output_events_t;
+
+/* --- Process --- */
+
+typedef enum {
+  CLAP_PROCESS_ERROR = 0,
+  CLAP_PROCESS_CONTINUE = 1,
+  CLAP_PROCESS_CONTINUE_IF_NOT_QUIET = 2,
+  CLAP_PROCESS_TAIL = 3,
+  CLAP_PROCESS_SLEEP = 4,
+} clap_process_status;
+
+typedef struct clap_process {
+  int64_t steady_time;
+  uint32_t frames_count;
+  const clap_input_events_t* in_events;
+  const clap_output_events_t* out_events;
+  const clap_audio_buffer_t* audio_inputs;
+  clap_audio_buffer_t* audio_outputs;
+  uint32_t audio_inputs_count;
+  uint32_t audio_outputs_count;
+  const void* transport;
+} clap_process_t;
+
+/* --- Plugin interface --- */
+
+struct clap_plugin {
+  const clap_plugin_descriptor_t* desc;
+  void* plugin_data;
+  bool (*init)(const clap_plugin_t* plugin);
+  void (*destroy)(const clap_plugin_t* plugin);
+  bool (*activate)(const clap_plugin_t* plugin, double sample_rate, uint32_t min_frames, uint32_t max_frames);
+  void (*deactivate)(const clap_plugin_t* plugin);
+  bool (*start_processing)(const clap_plugin_t* plugin);
+  void (*stop_processing)(const clap_plugin_t* plugin);
+  void (*reset)(const clap_plugin_t* plugin);
+  clap_process_status (*process)(const clap_plugin_t* plugin, const clap_process_t* process);
+  const void* (*get_extension)(const clap_plugin_t* plugin, const char* id);
+  void (*on_main_thread)(const clap_plugin_t* plugin);
+};
+
+/* --- Params extension --- */
+
+#define CLAP_EXT_PARAMS "clap.params"
+typedef uint32_t clap_id;
+
+typedef struct clap_param_info {
+  clap_id id;
+  uint32_t flags;
+  void* cookie;
+  char name[256];
+  char module[1024];
+  double min_value;
+  double max_value;
+  double default_value;
+} clap_param_info_t;
+
+typedef struct clap_plugin_params {
+  uint32_t (*count)(const clap_plugin_t* plugin);
+  bool (*get_info)(const clap_plugin_t* plugin, uint32_t param_index, clap_param_info_t* param_info);
+  bool (*get_value)(const clap_plugin_t* plugin, clap_id param_id, double* out_value);
+  bool (*value_to_text)(const clap_plugin_t* plugin, clap_id param_id, double value, char* out_buffer, uint32_t out_buffer_capacity);
+  bool (*text_to_value)(const clap_plugin_t* plugin, clap_id param_id, const char* param_value_text, double* out_value);
+  void (*flush)(const clap_plugin_t* plugin, const clap_input_events_t* in, const clap_output_events_t* out);
+} clap_plugin_params_t;
+

package/native/host.c

@@ -0,0 +1,184 @@
+/*
+ * host.c — CLAP plugin host implementation
+ */
+#include "clap.h"
+#include "host.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef _WIN32
+  #define WIN32_LEAN_AND_MEAN
+  #include <windows.h>
+  static void* lib_open(const char* p) { return (void*)LoadLibraryA(p); }
+  static void* lib_sym(void* l, const char* n) { return (void*)GetProcAddress((HMODULE)l, n); }
+  static void  lib_close(void* l) { FreeLibrary((HMODULE)l); }
+  static const char* lib_error(void) { static char b[128]; snprintf(b, sizeof(b), "error %lu", GetLastError()); return b; }
+#else
+  #include <dlfcn.h>
+  #include <dirent.h>
+  static void* lib_open(const char* p) { return dlopen(p, RTLD_NOW); }
+  static void* lib_sym(void* l, const char* n) { return dlsym(l, n); }
+  static void  lib_close(void* l) { dlclose(l); }
+  static const char* lib_error(void) { return dlerror(); }
+#endif
+
+static _Thread_local char s_error[512] = {0};
+
+/* --- Empty events --- */
+
+static uint32_t empty_size(const clap_input_events_t* l) { (void)l; return 0; }
+static const clap_event_header_t* empty_get(const clap_input_events_t* l, uint32_t i) { (void)l; (void)i; return NULL; }
+static bool empty_push(const clap_output_events_t* l, const clap_event_header_t* e) { (void)l; (void)e; return true; }
+
+static const clap_input_events_t s_in_events = { NULL, empty_size, empty_get };
+static const clap_output_events_t s_out_events = { NULL, empty_push };
+
+/* --- Host callbacks --- */
+
+static const void* host_get_ext(const clap_host_t* h, const char* id) { (void)h; (void)id; return NULL; }
+static void host_noop(const clap_host_t* h) { (void)h; }
+
+static const clap_host_t s_host = {
+  CLAP_VERSION_INIT,
+  NULL,
+  "audio-host", "audiojs", "https://github.com/audiojs/host", "0.1.0",
+  host_get_ext, host_noop, host_noop, host_noop
+};
+
+/* --- Plugin handle --- */
+
+struct clap_host_plugin {
+  void* lib;
+  const clap_plugin_entry_t* entry;
+  const clap_plugin_t* plugin;
+  const clap_plugin_params_t* params;
+  char name[256];
+  char vendor[256];
+};
+
+/* Find binary inside .clap bundle (macOS) or use path directly */
+static const char* find_clap_binary(const char* path, char* out, size_t outSize) {
+#ifndef _WIN32
+  char macosDir[2048];
+  snprintf(macosDir, sizeof(macosDir), "%s/Contents/MacOS", path);
+  DIR* dir = opendir(macosDir);
+  if (dir) {
+    struct dirent* entry;
+    while ((entry = readdir(dir))) {
+      if (entry->d_name[0] == '.') continue;
+      snprintf(out, outSize, "%s/%s", macosDir, entry->d_name);
+      closedir(dir);
+      return out;
+    }
+    closedir(dir);
+  }
+#endif
+  strncpy(out, path, outSize - 1);
+  out[outSize - 1] = 0;
+  return out;
+}
+
+/* --- C API --- */
+
+const char* clap_host_get_error(void) { return s_error; }
+
+clap_host_plugin_t* clap_host_open(const char* path, double sampleRate, int channels, int blockSize) {
+  s_error[0] = 0;
+
+  char binPath[2048];
+  find_clap_binary(path, binPath, sizeof(binPath));
+
+  void* lib = lib_open(binPath);
+  if (!lib) { snprintf(s_error, sizeof(s_error), "dlopen: %s", lib_error()); return NULL; }
+
+  const clap_plugin_entry_t* entry = (const clap_plugin_entry_t*)lib_sym(lib, "clap_entry");
+  if (!entry) { strcpy(s_error, "No clap_entry symbol"); lib_close(lib); return NULL; }
+
+  if (!entry->init(path)) { strcpy(s_error, "clap_entry.init failed"); lib_close(lib); return NULL; }
+
+  const clap_plugin_factory_t* factory = (const clap_plugin_factory_t*)entry->get_factory(CLAP_PLUGIN_FACTORY_ID);
+  if (!factory || factory->get_plugin_count(factory) == 0) {
+    strcpy(s_error, "No plugins in factory");
+    entry->deinit(); lib_close(lib); return NULL;
+  }
+
+  const clap_plugin_descriptor_t* desc = factory->get_plugin_descriptor(factory, 0);
+  const clap_plugin_t* plugin = factory->create_plugin(factory, &s_host, desc->id);
+  if (!plugin) { strcpy(s_error, "create_plugin failed"); entry->deinit(); lib_close(lib); return NULL; }
+
+  if (!plugin->init(plugin)) { plugin->destroy(plugin); entry->deinit(); lib_close(lib); strcpy(s_error, "plugin.init failed"); return NULL; }
+  if (!plugin->activate(plugin, sampleRate, 1, blockSize)) { plugin->destroy(plugin); entry->deinit(); lib_close(lib); strcpy(s_error, "plugin.activate failed"); return NULL; }
+  plugin->start_processing(plugin);
+
+  clap_host_plugin_t* p = (clap_host_plugin_t*)calloc(1, sizeof(clap_host_plugin_t));
+  p->lib = lib; p->entry = entry; p->plugin = plugin;
+  p->params = (const clap_plugin_params_t*)plugin->get_extension(plugin, CLAP_EXT_PARAMS);
+  if (desc->name) strncpy(p->name, desc->name, 255);
+  if (desc->vendor) strncpy(p->vendor, desc->vendor, 255);
+
+  return p;
+}
+
+void clap_host_close(clap_host_plugin_t* h) {
+  if (!h || !h->lib) return; /* already closed */
+  if (h->plugin) {
+    h->plugin->stop_processing(h->plugin);
+    h->plugin->deactivate(h->plugin);
+    h->plugin->destroy(h->plugin);
+    h->plugin = NULL;
+  }
+  if (h->entry) { h->entry->deinit(); h->entry = NULL; }
+  lib_close(h->lib);
+  h->lib = NULL;
+  h->params = NULL;
+}
+
+void clap_host_destroy(clap_host_plugin_t* h) {
+  if (!h) return;
+  clap_host_close(h);
+  free(h);
+}
+
+void clap_host_process(clap_host_plugin_t* h, float** inputs, float** outputs, int numChannels, int numSamples) {
+  if (!h || !h->plugin) return;
+
+  clap_audio_buffer_t in_buf = { inputs, NULL, (uint32_t)numChannels, 0, 0 };
+  clap_audio_buffer_t out_buf = { outputs, NULL, (uint32_t)numChannels, 0, 0 };
+
+  clap_process_t proc = {
+    -1, (uint32_t)numSamples,
+    &s_in_events, &s_out_events,
+    inputs ? &in_buf : NULL, &out_buf,
+    inputs ? 1u : 0u, 1u,
+    NULL
+  };
+
+  h->plugin->process(h->plugin, &proc);
+}
+
+const char* clap_host_get_name(clap_host_plugin_t* h) { return h ? h->name : ""; }
+const char* clap_host_get_vendor(clap_host_plugin_t* h) { return h ? h->vendor : ""; }
+
+int clap_host_get_param_count(clap_host_plugin_t* h) {
+  return (h && h->params) ? (int)h->params->count(h->plugin) : 0;
+}
+
+int clap_host_get_param_info(clap_host_plugin_t* h, int index, clap_host_param_info_t* out) {
+  if (!h || !h->params) return -1;
+  clap_param_info_t info;
+  if (!h->params->get_info(h->plugin, index, &info)) return -1;
+  out->id = info.id;
+  strncpy(out->name, info.name, 255); out->name[255] = 0;
+  out->min = info.min_value;
+  out->max = info.max_value;
+  out->defaultValue = info.default_value;
+  return 0;
+}
+
+double clap_host_get_param(clap_host_plugin_t* h, uint32_t id) {
+  if (!h || !h->params) return 0;
+  double val = 0;
+  h->params->get_value(h->plugin, id, &val);
+  return val;
+}

package/native/host.h

@@ -0,0 +1,29 @@
+/*
+ * host.h — C API for the CLAP host
+ */
+#pragma once
+#include <stdint.h>
+
+typedef struct clap_host_plugin clap_host_plugin_t;
+
+typedef struct {
+  uint32_t id;
+  char name[256];
+  double min;
+  double max;
+  double defaultValue;
+} clap_host_param_info_t;
+
+clap_host_plugin_t* clap_host_open(const char* path, double sampleRate, int channels, int blockSize);
+void clap_host_close(clap_host_plugin_t* handle);  /* idempotent deactivate */
+void clap_host_destroy(clap_host_plugin_t* handle); /* close + free */
+void clap_host_process(clap_host_plugin_t* handle, float** inputs, float** outputs, int numChannels, int numSamples);
+
+const char* clap_host_get_name(clap_host_plugin_t* handle);
+const char* clap_host_get_vendor(clap_host_plugin_t* handle);
+
+int clap_host_get_param_count(clap_host_plugin_t* handle);
+int clap_host_get_param_info(clap_host_plugin_t* handle, int index, clap_host_param_info_t* info);
+double clap_host_get_param(clap_host_plugin_t* handle, uint32_t id);
+
+const char* clap_host_get_error(void);

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@audio/host-clap",
+  "version": "0.1.0",
+  "description": "CLAP 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-clap-darwin-arm64": ">=0.1.0",
+    "@audio/host-clap-darwin-x64": ">=0.1.0",
+    "@audio/host-clap-linux-x64": ">=0.1.0",
+    "@audio/host-clap-linux-arm64": ">=0.1.0",
+    "@audio/host-clap-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-clap-${plat}`),
+  () => require(join(root, 'packages', `host-clap-${plat}`, 'host_clap.node')),
+  () => require(join(root, 'prebuilds', plat, 'host_clap.node')),
+  () => require(join(root, 'build', 'Release', 'host_clap.node')),
+  () => require(join(root, 'build', 'Debug', 'host_clap.node')),
+]
+for (const load of loaders) {
+  try { addon = load(); break } catch {}
+}
+if (!addon) throw new Error('host-clap addon not found — run `npm run build` or install @audio/host-clap-' + plat)
+
+export default addon