@wuyuchentr/webassembly-runtime-embed 2.0.0 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wuyuchentr/webassembly-runtime-embed",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Embed WebAssembly runtime in Node.js with WASI support, multi-instance isolation, resource limits, and remote loading with cache.",
   "bin": {
     "webassembly-runtime-embed": "bin/cli.js"

package/src/index.js

@@ -3,6 +3,8 @@ const { MemoryView } = require('./memory.js');
 const { HostRegistry } = require('./host.js');
 const { ResourceLimits } = require('./limits.js');
 const { WasiContext } = require('./wasi.js');
+const { WasmPool, InstanceLease } = require('./pool.js');
+const { HotReload } = require('./watcher.js');
 const loader = require('./loader.js');
 
 function createRuntime(options = {}) {
@@ -24,5 +26,8 @@ module.exports = {
   HostRegistry,
   ResourceLimits,
   WasiContext,
+  WasmPool,
+  InstanceLease,
+  HotReload,
   loader,
 };

package/src/pool.js

@@ -0,0 +1,204 @@
+const crypto = require('crypto');
+
+class InstanceLease {
+  constructor(pool, instance) {
+    this.pool = pool;
+    this.instance = instance;
+    this._released = false;
+    this.id = crypto.randomUUID();
+  }
+
+  release() {
+    if (this._released) return false;
+    this._released = true;
+    this.pool._release(this);
+    return true;
+  }
+
+  async call(name, ...args) {
+    return this.instance.call(name, ...args);
+  }
+}
+
+class WasmPool {
+  constructor(runtime, options = {}) {
+    this.runtime = runtime;
+    this.source = options.source || null;
+    this.sourceOptions = options.sourceOptions || {};
+    this.maxSize = options.maxSize || 10;
+    this.minSize = options.minSize || 0;
+    this.acquireTimeout = options.acquireTimeout || 0;
+    this.idleTimeout = options.idleTimeout || 60000;
+    this._idle = [];
+    this._busy = new Map();
+    this._pending = [];
+    this._closed = false;
+    this._warmPromise = null;
+    this._reaperTimer = null;
+    this._instanceIdCounter = 0;
+    this._creating = 0;
+
+    if (this.idleTimeout > 0) {
+      this._startReaper();
+    }
+  }
+
+  _startReaper() {
+    this._reaperTimer = setInterval(() => {
+      this._reapIdle();
+    }, Math.min(this.idleTimeout, 30000));
+    if (this._reaperTimer.unref) this._reaperTimer.unref();
+  }
+
+  async warm() {
+    if (this._warmPromise) return this._warmPromise;
+    this._warmPromise = this._warmInternal();
+    return this._warmPromise;
+  }
+
+  async _warmInternal() {
+    const target = this.minSize;
+    const toCreate = Math.max(0, target - this._countTotal());
+    const tasks = [];
+    for (let i = 0; i < toCreate; i++) {
+      tasks.push(this._createInstance());
+    }
+    const instances = await Promise.all(tasks);
+    for (const inst of instances) {
+      this._idle.push(inst);
+    }
+  }
+
+  async _createInstance() {
+    const id = ++this._instanceIdCounter;
+    const inst = await this.runtime.load(this.source, this.sourceOptions);
+    inst._poolId = id;
+    inst._createdAt = Date.now();
+    return inst;
+  }
+
+  _countTotal() {
+    return this._idle.length + this._busy.size;
+  }
+
+  async acquire() {
+    if (this._closed) throw new Error('Pool is closed');
+
+    if (this._idle.length > 0) {
+      const inst = this._idle.pop();
+      this._busy.set(inst._poolId, inst);
+      return new InstanceLease(this, inst);
+    }
+
+    if (this._countTotal() + this._creating >= this.maxSize) {
+      return this._enqueue();
+    }
+
+    this._creating++;
+    try {
+      const inst = await this._createInstance();
+      this._creating--;
+      this._busy.set(inst._poolId, inst);
+      return new InstanceLease(this, inst);
+    } catch (err) {
+      this._creating--;
+      throw err;
+    }
+  }
+
+  _enqueue() {
+    return new Promise((resolve, reject) => {
+      let timer = null;
+      const entry = { resolve, reject, timer: null };
+
+      if (this.acquireTimeout > 0) {
+        timer = setTimeout(() => {
+          const idx = this._pending.indexOf(entry);
+          if (idx !== -1) this._pending.splice(idx, 1);
+          reject(new Error(`Acquire timed out after ${this.acquireTimeout}ms`));
+        }, this.acquireTimeout);
+        entry.timer = timer;
+      }
+
+      this._pending.push(entry);
+    });
+  }
+
+  _release(lease) {
+    const inst = lease.instance;
+    this._busy.delete(inst._poolId);
+
+    if (this._closed) return;
+
+    if (this._pending.length > 0) {
+      this._busy.set(inst._poolId, inst);
+      const entry = this._pending.shift();
+      if (entry.timer) clearTimeout(entry.timer);
+      entry.resolve(new InstanceLease(this, inst));
+      return;
+    }
+
+    inst._lastUsedAt = Date.now();
+    this._idle.push(inst);
+  }
+
+  async exec(fn) {
+    const lease = await this.acquire();
+    try {
+      return await fn(lease.instance, lease);
+    } finally {
+      lease.release();
+    }
+  }
+
+  async drain() {
+    this._closed = true;
+
+    for (const entry of this._pending) {
+      if (entry.timer) clearTimeout(entry.timer);
+      entry.reject(new Error('Pool is draining'));
+    }
+    this._pending = [];
+
+    const all = [...this._idle, ...Array.from(this._busy.values())];
+    this._idle = [];
+    this._busy.clear();
+
+    if (this._reaperTimer) {
+      clearInterval(this._reaperTimer);
+      this._reaperTimer = null;
+    }
+  }
+
+  _reapIdle() {
+    if (this._idle.length === 0) return;
+    const now = Date.now();
+    const keep = Math.max(0, this.minSize);
+    const reapable = this._idle
+      .filter(i => now - (i._lastUsedAt || i._createdAt) > this.idleTimeout)
+      .sort((a, b) => (a._lastUsedAt || a._createdAt) - (b._lastUsedAt || b._createdAt));
+
+    const toRemove = Math.max(0, reapable.length - keep);
+    const removeSet = new Set(reapable.slice(0, toRemove).map(i => i._poolId));
+    this._idle = this._idle.filter(i => {
+      if (removeSet.has(i._poolId)) {
+        this.runtime.removeInstance(i);
+        return false;
+      }
+      return true;
+    });
+  }
+
+  stats() {
+    return {
+      idle: this._idle.length,
+      busy: this._busy.size,
+      pending: this._pending.length,
+      total: this._countTotal(),
+      maxSize: this.maxSize,
+      minSize: this.minSize,
+    };
+  }
+}
+
+module.exports = { WasmPool, InstanceLease };

package/src/runtime.js

@@ -1,6 +1,8 @@
 const { MemoryView } = require('./memory.js');
 const { HostRegistry } = require('./host.js');
 const { ResourceLimits } = require('./limits.js');
+const { WasmPool } = require('./pool.js');
+const { HotReload } = require('./watcher.js');
 const loader = require('./loader.js');
 
 class WasmInstance {
@@ -135,6 +137,18 @@ class WasmRuntime {
     this.instances = [];
   }
 
+  createPool(options = {}) {
+    if (!options.source && !options.sourceOptions) {
+      options.sourceOptions = { ...this.options };
+    }
+    return new WasmPool(this, options);
+  }
+
+  watch(source, options = {}) {
+    const hr = new HotReload(this, source, options);
+    return hr;
+  }
+
   getStats() {
     return {
       instances: this.instances.length,

package/src/watcher.js

@@ -0,0 +1,128 @@
+const fs = require('fs');
+const path = require('path');
+const EventEmitter = require('events');
+
+class HotReload extends EventEmitter {
+  constructor(runtime, source, options = {}) {
+    super();
+    this.runtime = runtime;
+    this.source = path.resolve(source);
+    this.options = options;
+    this.pollInterval = options.pollInterval || 1000;
+    this._currentModule = null;
+    this._currentInstance = null;
+    this._watcher = null;
+    this._pollTimer = null;
+    this._active = false;
+    this._reloading = false;
+  }
+
+  async start() {
+    if (this._active) return;
+    this._active = true;
+
+    const mode = this.options.mode || 'poll';
+
+    if (mode === 'watch') {
+      this._startWatcher();
+    } else {
+      this._startPolling();
+    }
+
+    await this._loadModule();
+  }
+
+  _startWatcher() {
+    try {
+      this._watcher = fs.watch(this.source, (eventType) => {
+        if (eventType === 'change') {
+          this._scheduleReload();
+        }
+      });
+    } catch {
+      this._startPolling();
+    }
+  }
+
+  _startPolling() {
+    this._lastMtime = this._getMtime();
+    this._pollTimer = setInterval(() => {
+      const mtime = this._getMtime();
+      if (mtime && mtime !== this._lastMtime) {
+        this._lastMtime = mtime;
+        this._scheduleReload();
+      }
+    }, this.pollInterval);
+    if (this._pollTimer.unref) this._pollTimer.unref();
+  }
+
+  _getMtime() {
+    try {
+      return fs.statSync(this.source).mtimeMs;
+    } catch {
+      return null;
+    }
+  }
+
+  _scheduleReload() {
+    if (this._reloading) return;
+    this._reloading = true;
+
+    const debounceMs = this.options.debounce || 200;
+    if (this._reloadTimer) clearTimeout(this._reloadTimer);
+
+    this._reloadTimer = setTimeout(async () => {
+      try {
+        await this._loadModule();
+        this.emit('reload', this._currentInstance);
+      } catch (err) {
+        this.emit('error', err);
+      } finally {
+        this._reloading = false;
+      }
+    }, debounceMs);
+  }
+
+  async _loadModule() {
+    const oldInstance = this._currentInstance;
+    const newInstance = await this.runtime.load(this.source, this.options.sourceOptions);
+
+    this._currentInstance = newInstance;
+    this._currentModule = true;
+    this.emit('load', newInstance);
+
+    if (oldInstance) {
+      this.runtime.removeInstance(oldInstance);
+    }
+  }
+
+  getInstance() {
+    return this._currentInstance;
+  }
+
+  async call(name, ...args) {
+    if (!this._currentInstance) {
+      throw new Error('Module not loaded yet');
+    }
+    return this._currentInstance.call(name, ...args);
+  }
+
+  close() {
+    this._active = false;
+    if (this._watcher) {
+      this._watcher.close();
+      this._watcher = null;
+    }
+    if (this._pollTimer) {
+      clearInterval(this._pollTimer);
+      this._pollTimer = null;
+    }
+    if (this._reloadTimer) {
+      clearTimeout(this._reloadTimer);
+      this._reloadTimer = null;
+    }
+    this.removeAllListeners();
+  }
+}
+
+module.exports = { HotReload };