@wuyuchentr/webassembly-runtime-embed 1.0.0 → 3.0.0

package/README.md

@@ -16,7 +16,6 @@ const { createRuntime } = require('@wuyuchentr/webassembly-runtime-embed');
 async function main() {
   const runtime = createRuntime();
 
-  // Load and run a WASM module
   const inst = await runtime.load('./add.wasm');
   const result = inst.call('add', 1, 2);
   console.log(result); // 3
@@ -26,16 +25,49 @@ async function main() {
 ## CLI
 
 ```bash
-# Run a WASM function
 webassembly-runtime-embed run add.wasm --export add --args 1 2
-
-# Inspect module imports/exports
 webassembly-runtime-embed info module.wasm
-
-# Clear module cache
 webassembly-runtime-embed cache clear
 ```
 
+## WASI support (v2)
+
+Full `wasi_snapshot_preview1` implementation with filesystem sandboxing.
+
+```js
+const runtime = createRuntime();
+
+runtime.registerWASI({
+  args: ['myapp.wasm', '--verbose'],
+  env: { HOME: '/data', DEBUG: '1' },
+  preopens: [
+    { virtual: '/sandbox', real: '/path/to/host/dir' },
+  ],
+});
+
+const inst = await runtime.load('./myapp.wasm');
+// WASM can now use stdin/stdout/stderr, file I/O, clock, random, etc.
+```
+
+### Supported WASI functions
+
+| Category | Functions |
+|----------|-----------|
+| **Args** | `args_sizes_get`, `args_get` |
+| **Environ** | `environ_sizes_get`, `environ_get` |
+| **Clock** | `clock_time_get`, `clock_res_get` |
+| **Random** | `random_get` |
+| **Stdio** | `fd_read` (stdin), `fd_write` (stdout/stderr) |
+| **File I/O** | `fd_read`, `fd_write`, `fd_close`, `fd_seek`, `fd_tell`, `fd_fdstat_get`, `fd_fdstat_set_flags`, `fd_filestat_get`, `fd_readdir`, `fd_datasync`, `fd_sync`, `fd_advise`, `fd_allocate`, `fd_renumber` |
+| **Filesystem** | `path_open`, `path_create_directory`, `path_remove_directory`, `path_unlink_file`, `path_rename`, `path_filestat_get`, `path_readlink`, `path_symlink` |
+| **Preopens** | `fd_prestat_get`, `fd_prestat_dir_name` |
+| **Process** | `proc_exit` |
+| **Poll** | `poll_oneoff`, `sched_yield` |
+
+### Filesystem sandboxing
+
+All WASM file operations are sandboxed within preopened directories. Paths like `/sandbox/file.txt` are transparently mapped to real host paths. Path traversal outside the preopened root is rejected.
+
 ## Features
 
 ### Function calling with type conversion
@@ -50,9 +82,8 @@ inst.call('multiply', 2.5, 3.0);    // f64 → f64
 ```js
 const mem = inst.getMemory();
 mem.writeCString(0, 'hello world');
-const str = mem.readCString(0);      // 'hello world'
+const str = mem.readCString(0);
 mem.writeF64(1024, 3.14159);
-const pi = mem.readF64(1024);        // 3.14159
 ```
 
 ### Host function registration
@@ -68,8 +99,8 @@ runtime.registerFunction('env', 'js_log', (ptr, len) => {
 
 ```js
 const inst = await runtime.load('./module.wasm', {
-  maxMemory: 65536 * 4,  // 4 pages max
-  timeout: 1000,          // 1s execution timeout
+  maxMemory: 65536 * 4,
+  timeout: 1000,
 });
 ```
 
@@ -77,7 +108,7 @@ const inst = await runtime.load('./module.wasm', {
 
 ```js
 const inst = await runtime.loadRemote('https://example.com/module.wasm', {
-  ttl: 3600,  // cache for 1 hour
+  ttl: 3600,
 });
 ```
 
@@ -85,31 +116,29 @@ const inst = await runtime.loadRemote('https://example.com/module.wasm', {
 
 ### `createRuntime(options)`
 
-Create a new WASM runtime.
-
 ### `runtime.load(source, options)`
 
-Load a WASM module from file path, buffer, or URL. Returns a `WasmInstance`.
-
 | Option | Default | Description |
 |--------|---------|-------------|
-| `maxMemory` | `0` | Maximum memory in bytes (0 = unlimited) |
-| `timeout` | `0` | Execution timeout in ms (0 = no timeout) |
+| `maxMemory` | `0` | Maximum memory in bytes |
+| `timeout` | `0` | Execution timeout in ms |
 | `argTypes` | `[]` | Argument types for auto-conversion |
 | `returnType` | `null` | Return type for auto-conversion |
 
-### `runtime.registerFunction(module, name, fn)`
+### `runtime.registerWASI(options)`
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `args` | `[]` | Command-line arguments |
+| `env` | `{}` | Environment variables |
+| `preopens` | `[]` | Array of `{ virtual, real }` path mappings |
 
-Register a host function that WASM can call.
+### `runtime.registerFunction(module, name, fn)`
 
 ### `inst.call(name, ...args)`
 
-Call an exported WASM function.
-
 ### `inst.getMemory()`
 
-Get a `MemoryView` for reading/writing WASM linear memory.
-
 ### `MemoryView` methods
 
 - `readU8/16/32(offset)`, `readI32(offset)`, `readF32/64(offset)`
@@ -118,14 +147,6 @@ Get a `MemoryView` for reading/writing WASM linear memory.
 - `writeF32/64(offset, value)`, `writeString(offset, str)`, `writeCString(offset, str)`
 - `alloc(size)`, `allocString(str)`, `free()`
 
-## Roadmap
-
-- **v1** (current) — Basic WASM calls (i32/f64), memory management, host functions, resource limits, remote loading
-- **v2** — WASI support (filesystem, networking)
-- **v3** — Multi-instance pool + hot reload
-- **v4** — Distributed WASM function scheduling
-- **v5** — Component Model integration
-
 ## License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wuyuchentr/webassembly-runtime-embed",
-  "version": "1.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/host.js

@@ -1,13 +1,14 @@
+const { WasiContext } = require('./wasi.js');
+
 class HostRegistry {
   constructor() {
     this._modules = new Map();
     this._builtins = new Map();
+    this._wasiContext = null;
     this._registerBuiltins();
   }
 
   _registerBuiltins() {
-    this._builtins.set('wasi_unstable', new Map());
-    this._builtins.set('wasi_snapshot_preview1', new Map());
     this._builtins.set('env', new Map());
   }
 
@@ -36,7 +37,13 @@ class HostRegistry {
     }
   }
 
-  buildImportObject(instance) {
+  setWasiMemory(memory) {
+    if (this._wasiContext) {
+      this._wasiContext.setMemory(memory);
+    }
+  }
+
+  buildImportObject() {
     const importObject = {};
 
     const allModules = new Set([
@@ -44,11 +51,27 @@ class HostRegistry {
       ...this._builtins.keys(),
     ]);
 
+    if (this._wasiContext) {
+      const wasiImports = this._wasiContext.toImportObject();
+      for (const [modName, funcs] of Object.entries(wasiImports)) {
+        allModules.add(modName);
+      }
+    }
+
     for (const modName of allModules) {
       const mod = this._modules.get(modName) || new Map();
       const builtin = this._builtins.get(modName) || new Map();
       const merged = new Map([...builtin, ...mod]);
 
+      if (this._wasiContext) {
+        const wasiImports = this._wasiContext.toImportObject();
+        if (wasiImports[modName]) {
+          for (const [name, fn] of Object.entries(wasiImports[modName])) {
+            merged.set(name, fn);
+          }
+        }
+      }
+
       if (merged.size === 0) continue;
 
       importObject[modName] = {};
@@ -68,49 +91,16 @@ class HostRegistry {
   }
 
   registerWASI(options = {}) {
-    const wasi = this._builtins.get('wasi_snapshot_preview1');
-    if (!wasi) return;
-
-    const fdMap = new Map();
-    fdMap.set(0, { type: 'stdin' });
-    fdMap.set(1, { type: 'stdout' });
-    fdMap.set(2, { type: 'stderr' });
-
-    wasi.set('fd_write', (fd, iovs, iovsLen, nwritten) => {
-      if (fd === 1 || fd === 2) {
-        process.stdout.write(`[wasm:${fd > 1 ? 'err' : 'out'}] `);
-      }
-      return 0;
-    });
-
-    wasi.set('fd_close', (fd) => {
-      fdMap.delete(fd);
-      return 0;
-    });
-
-    wasi.set('environ_sizes_get', (countPtr, sizePtr) => {
-      return 0;
-    });
-
-    wasi.set('environ_get', (environPtr, environBufPtr) => {
-      return 0;
-    });
-
-    wasi.set('proc_exit', (code) => {
-      throw new Error(`WASI process exited with code ${code}`);
-    });
-
-    wasi.set('args_sizes_get', (argcPtr, argvBufSizePtr) => {
-      return 0;
-    });
-
-    wasi.set('args_get', (argvPtr, argvBufPtr) => {
-      return 0;
+    const ctx = new WasiContext({
+      args: options.args || [],
+      env: options.env || {},
+      preopens: options.preopens || [],
     });
+    this._wasiContext = ctx;
+  }
 
-    wasi.set('clock_time_get', (id, precision, timePtr) => {
-      return 0;
-    });
+  getWasiContext() {
+    return this._wasiContext;
   }
 }
 

package/src/index.js

@@ -2,6 +2,9 @@ const { WasmRuntime, WasmInstance } = require('./runtime.js');
 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 = {}) {
@@ -22,5 +25,9 @@ module.exports = {
   MemoryView,
   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 {
@@ -101,6 +103,10 @@ class WasmRuntime {
     const inst = new WasmInstance(module, importObject, wasmOptions);
     await inst.instantiate(importObject);
 
+    if (inst.memory) {
+      this.hosts.setWasiMemory(inst.memory);
+    }
+
     inst._meta = { source: result.source, cached: result.cached };
     this.instances.push(inst);
     return inst;
@@ -115,7 +121,11 @@ class WasmRuntime {
   }
 
   registerWASI(options = {}) {
-    this.hosts.registerWASI(options);
+    this.hosts.registerWASI({
+      args: options.args || this.options.wasiArgs || [],
+      env: options.env || this.options.wasiEnv || {},
+      preopens: options.preopens || this.options.wasiPreopens || [],
+    });
   }
 
   removeInstance(instance) {
@@ -127,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/wasi.js

@@ -0,0 +1,744 @@
+const fs = require('fs');
+const path = require('path');
+
+const ERRNO_SUCCESS = 0;
+const ERRNO_BADF = 8;
+const ERRNO_NOSYS = 52;
+const ERRNO_INVAL = 28;
+const ERRNO_EXIST = 20;
+const ERRNO_NOTDIR = 54;
+const ERRNO_ISDIR = 31;
+const ERRNO_ACCES = 2;
+const ERRNO_NOSPC = 58;
+const ERRNO_SPIPE = 70;
+const ERRNO_NOMEM = 33;
+const ERRNO_IO = 29;
+const ERRNO_NFILES = 48;
+const ERRNO_PIPE = 71;
+const ERRNO_MFILE = 42;
+
+const FILETYPE_DIRECTORY = 3;
+const FILETYPE_REGULAR_FILE = 4;
+const FILETYPE_CHARACTER_DEVICE = 2;
+const FILETYPE_BLOCK_DEVICE = 1;
+const FILETYPE_SOCKET_STREAM = 10;
+const FILETYPE_SYMBOLIC_LINK = 7;
+
+const RIGHTS_FD_READ = 1n << 1n;
+const RIGHTS_FD_WRITE = 1n << 5n;
+const RIGHTS_FD_SEEK = 1n << 3n;
+const RIGHTS_PATH_OPEN = 1n << 12n;
+const RIGHTS_FD_TELL = 1n << 4n;
+const RIGHTS_FD_READDIR = 1n << 13n;
+const RIGHTS_FD_FILESTAT_GET = 1n << 14n;
+const RIGHTS_PATH_CREATE_DIRECTORY = 1n << 16n;
+const RIGHTS_PATH_REMOVE_DIRECTORY = 1n << 18n;
+const RIGHTS_PATH_UNLINK_FILE = 1n << 20n;
+const RIGHTS_PATH_RENAME = 1n << 21n;
+const RIGHTS_PATH_FILESTAT_GET = 1n << 23n;
+const RIGHTS_POLL_FD_READWRITE = 1n << 26n;
+
+const WHENCE_SET = 0;
+const WHENCE_CUR = 1;
+const WHENCE_END = 2;
+
+class FdEntry {
+  constructor(type, options = {}) {
+    this.type = type;
+    this.realFd = options.realFd || null;
+    this.virtualPath = options.virtualPath || null;
+    this.realPath = options.realPath || null;
+    this.flags = options.flags || 0;
+    this.position = options.position || 0;
+    this.filetype = options.filetype || FILETYPE_REGULAR_FILE;
+    this.stream = options.stream || null;
+    this.dirEntries = options.dirEntries || null;
+    this.readable = !!options.readable;
+    this.writable = !!options.writable;
+  }
+}
+
+class WasiContext {
+  constructor(options = {}) {
+    this.args = options.args || [];
+    this.env = options.env || {};
+    this.preopens = options.preopens || [];
+    this._memory = null;
+    this._fdMap = new Map();
+    this._nextFd = 3;
+    this._initStdio();
+    this._initPreopens();
+  }
+
+  setMemory(memory) {
+    this._memory = memory;
+  }
+
+  get memory() {
+    return this._memory;
+  }
+
+  get _memView() {
+    return this._memory ? new Uint8Array(this._memory.buffer) : null;
+  }
+
+  _initStdio() {
+    this._fdMap.set(0, new FdEntry('stdio', {
+      stream: process.stdin,
+      filetype: FILETYPE_CHARACTER_DEVICE,
+      readable: true,
+      writable: false,
+    }));
+    this._fdMap.set(1, new FdEntry('stdio', {
+      stream: process.stdout,
+      filetype: FILETYPE_CHARACTER_DEVICE,
+      readable: false,
+      writable: true,
+    }));
+    this._fdMap.set(2, new FdEntry('stdio', {
+      stream: process.stderr,
+      filetype: FILETYPE_CHARACTER_DEVICE,
+      readable: false,
+      writable: true,
+    }));
+  }
+
+  _initPreopens() {
+    for (const preopen of this.preopens) {
+      const fd = this._nextFd++;
+      this._fdMap.set(fd, new FdEntry('preopen', {
+        virtualPath: preopen.virtual || '/',
+        realPath: preopen.real || preopen.virtual || '/',
+        filetype: FILETYPE_DIRECTORY,
+        readable: true,
+        writable: true,
+      }));
+    }
+  }
+
+  _getFd(fd) {
+    const entry = this._fdMap.get(fd);
+    if (!entry) return null;
+    return entry;
+  }
+
+  _resolvePath(virtualPath) {
+    const abs = virtualPath.startsWith('/') ? virtualPath : '/' + virtualPath;
+    for (const [fd, entry] of this._fdMap) {
+      if (entry.type === 'preopen' && abs === entry.virtualPath) {
+        return { realPath: entry.realPath, preopen: entry };
+      }
+      if (entry.type === 'preopen' && (abs + '/').startsWith(entry.virtualPath + '/')) {
+        const relative = abs.slice(entry.virtualPath.length);
+        const realPath = path.join(entry.realPath, relative);
+        const resolved = path.resolve(realPath);
+        if (!resolved.startsWith(path.resolve(entry.realPath))) {
+          return null;
+        }
+        return { realPath: resolved, preopen: entry };
+      }
+    }
+    return null;
+  }
+
+  _readWasmI32(ptr) {
+    if (!this._memory) return 0;
+    const dv = new DataView(this._memory.buffer);
+    return dv.getInt32(ptr, true);
+  }
+
+  _writeWasmI32(ptr, value) {
+    if (!this._memory) return;
+    const dv = new DataView(this._memory.buffer);
+    dv.setInt32(ptr, value, true);
+  }
+
+  _writeWasmI64(ptr, value) {
+    if (!this._memory) return;
+    const dv = new DataView(this._memory.buffer);
+    dv.setBigInt64(ptr, BigInt(value), true);
+  }
+
+  _writeWasmU64(ptr, value) {
+    if (!this._memory) return;
+    const dv = new DataView(this._memory.buffer);
+    dv.setBigUint64(ptr, BigInt(value), true);
+  }
+
+  _writeWasmBytes(ptr, data) {
+    if (!this._memory) return;
+    new Uint8Array(this._memory.buffer, ptr, data.length).set(data);
+  }
+
+  _readIovs(iovsPtr, iovsLen) {
+    const buffers = [];
+    for (let i = 0; i < iovsLen; i++) {
+      const bufPtr = this._readWasmI32(iovsPtr + i * 8);
+      const bufLen = this._readWasmI32(iovsPtr + i * 8 + 4);
+      if (bufLen > 0 && this._memory) {
+        const slice = new Uint8Array(this._memory.buffer, bufPtr, bufLen);
+        buffers.push(slice);
+      }
+    }
+    return buffers;
+  }
+
+  _writeIovs(iovsPtr, iovsLen, data) {
+    let offset = 0;
+    for (let i = 0; i < iovsLen; i++) {
+      const bufPtr = this._readWasmI32(iovsPtr + i * 8);
+      const bufLen = this._readWasmI32(iovsPtr + i * 8 + 4);
+      const remaining = data.length - offset;
+      const toWrite = Math.min(bufLen, remaining);
+      if (toWrite > 0 && this._memory) {
+        new Uint8Array(this._memory.buffer, bufPtr, toWrite).set(data.slice(offset, offset + toWrite));
+        offset += toWrite;
+      }
+    }
+    return offset;
+  }
+
+  fd_write(fd, iovsPtr, iovsLen, nwrittenPtr) {
+    const entry = this._getFd(fd);
+    if (!entry) return ERRNO_BADF;
+    if (!entry.writable) return ERRNO_BADF;
+
+    try {
+      const buffers = this._readIovs(iovsPtr, iovsLen);
+      let totalWritten = 0;
+
+      if (fd <= 2) {
+        for (const buf of buffers) {
+          const str = new TextDecoder().decode(buf);
+          if (fd === 1) process.stdout.write(str);
+          else process.stderr.write(str);
+          totalWritten += buf.length;
+        }
+      } else if (entry.realFd !== null) {
+        const allData = Buffer.concat(buffers.map(b => Buffer.from(b)));
+        const written = fs.writeSync(entry.realFd, allData, 0, allData.length, entry.position);
+        if (written > 0) entry.position += written;
+        totalWritten = written;
+      } else {
+        const allData = Buffer.concat(buffers.map(b => Buffer.from(b)));
+        totalWritten = allData.length;
+      }
+
+      if (nwrittenPtr != null) this._writeWasmI32(nwrittenPtr, totalWritten);
+      return ERRNO_SUCCESS;
+    } catch {
+      return ERRNO_IO;
+    }
+  }
+
+  fd_read(fd, iovsPtr, iovsLen, nreadPtr) {
+    const entry = this._getFd(fd);
+    if (!entry) return ERRNO_BADF;
+    if (!entry.readable) return ERRNO_BADF;
+
+    try {
+      let totalRead = 0;
+      if (fd === 0) {
+      } else if (entry.realFd !== null) {
+        const buffers = this._readIovs(iovsPtr, iovsLen);
+        for (const buf of buffers) {
+          const bytesRead = fs.readSync(entry.realFd, buf, 0, buf.length, entry.position);
+          entry.position += bytesRead;
+          totalRead += bytesRead;
+          if (bytesRead < buf.length) break;
+        }
+      }
+
+      if (nreadPtr != null) this._writeWasmI32(nreadPtr, totalRead);
+      return ERRNO_SUCCESS;
+    } catch {
+      return ERRNO_IO;
+    }
+  }
+
+  fd_close(fd) {
+    const entry = this._getFd(fd);
+    if (!entry) return ERRNO_BADF;
+    if (fd <= 2) return ERRNO_SUCCESS;
+    try {
+      if (entry.realFd !== null) fs.closeSync(entry.realFd);
+      this._fdMap.delete(fd);
+      return ERRNO_SUCCESS;
+    } catch {
+      return ERRNO_IO;
+    }
+  }
+
+  fd_seek(fd, offset, whence, newoffsetPtr) {
+    const entry = this._getFd(fd);
+    if (!entry) return ERRNO_BADF;
+
+    try {
+      let newPos;
+      switch (whence) {
+        case WHENCE_SET: newPos = offset; break;
+        case WHENCE_CUR: newPos = entry.position + offset; break;
+        case WHENCE_END:
+          if (entry.realFd !== null) {
+            const stat = fs.fstatSync(entry.realFd);
+            newPos = stat.size + offset;
+          } else {
+            newPos = entry.position;
+          }
+          break;
+        default: return ERRNO_INVAL;
+      }
+      if (newPos < 0) return ERRNO_INVAL;
+      entry.position = newPos;
+      if (entry.realFd !== null) {
+        fs.fstatSync(entry.realFd);
+      }
+      if (newoffsetPtr != null) this._writeWasmI64(newoffsetPtr, newPos);
+      return ERRNO_SUCCESS;
+    } catch {
+      return ERRNO_IO;
+    }
+  }
+
+  fd_fdstat_get(fd, statPtr) {
+    const entry = this._getFd(fd);
+    if (!entry) return ERRNO_BADF;
+    if (statPtr == null || !this._memory) return ERRNO_INVAL;
+
+    const view = new DataView(this._memory.buffer);
+    view.setUint8(statPtr, entry.filetype);
+    view.setUint16(statPtr + 2, entry.flags, true);
+    const baseRights = entry.readable ? RIGHTS_FD_READ : 0n;
+    const writeRights = entry.writable ? RIGHTS_FD_WRITE : 0n;
+    view.setBigUint64(statPtr + 8, baseRights | writeRights, true);
+    view.setBigUint64(statPtr + 16, baseRights | writeRights, true);
+
+    return ERRNO_SUCCESS;
+  }
+
+  fd_prestat_get(fd, prestatPtr) {
+    const entry = this._getFd(fd);
+    if (!entry) return ERRNO_BADF;
+    if (entry.type !== 'preopen') return ERRNO_NOSYS;
+
+    const view = new DataView(this._memory.buffer);
+    view.setUint8(prestatPtr, 0);
+    const dirName = entry.virtualPath || '/';
+    view.setUint32(prestatPtr + 4, Buffer.byteLength(dirName), true);
+    return ERRNO_SUCCESS;
+  }
+
+  fd_prestat_dir_name(fd, bufPtr, bufLen) {
+    const entry = this._getFd(fd);
+    if (!entry) return ERRNO_BADF;
+    if (entry.type !== 'preopen') return ERRNO_NOSYS;
+
+    const dirName = entry.virtualPath || '/';
+    const nameBytes = Buffer.from(dirName, 'utf8');
+    if (nameBytes.length > bufLen) return ERRNO_NOMEM;
+
+    this._writeWasmBytes(bufPtr, nameBytes);
+    return ERRNO_SUCCESS;
+  }
+
+  fd_filestat_get(fd, statPtr) {
+    const entry = this._getFd(fd);
+    if (!entry) return ERRNO_BADF;
+
+    try {
+      let stat;
+      if (entry.realFd !== null) {
+        stat = fs.fstatSync(entry.realFd);
+      } else {
+        stat = { size: 0, mode: 0, atimeMs: 0, mtimeMs: 0, ctimeMs: 0, dev: 0, ino: 0, nlink: 0 };
+      }
+      this._writeFilestat(statPtr, stat, entry.filetype);
+      return ERRNO_SUCCESS;
+    } catch {
+      return ERRNO_IO;
+    }
+  }
+
+  _writeFilestat(ptr, stat, filetype) {
+    const view = new DataView(this._memory.buffer);
+    view.setBigUint64(ptr, BigInt(stat.dev || 0), true);
+    view.setBigUint64(ptr + 8, BigInt(stat.ino || 0), true);
+    view.setUint8(ptr + 16, filetype || FILETYPE_REGULAR_FILE);
+    view.setBigUint64(ptr + 24, BigInt(stat.nlink || 1), true);
+    view.setBigUint64(ptr + 32, BigInt(stat.size || 0), true);
+    view.setBigUint64(ptr + 40, BigInt(Math.floor((stat.atimeMs || 0) * 1e6)), true);
+    view.setBigUint64(ptr + 48, BigInt(Math.floor((stat.mtimeMs || 0) * 1e6)), true);
+    view.setBigUint64(ptr + 56, BigInt(Math.floor((stat.ctimeMs || 0) * 1e6)), true);
+  }
+
+  path_open(fd, dirFlags, pathPtr, pathLen, oflags, fsRightsBase, fsRightsInheriting, fdFlags, openedFdPtr) {
+    const entry = this._getFd(fd);
+    if (!entry) return ERRNO_BADF;
+
+    try {
+      const name = this._readString(pathPtr, pathLen);
+      const resolved = this._resolvePath(name);
+      if (!resolved) return ERRNO_ACCES;
+
+      const realPath = resolved.realPath;
+      let hostFlags = fs.constants.O_RDONLY;
+      if (fsRightsBase & BigInt(RIGHTS_FD_WRITE)) {
+        hostFlags = fs.constants.O_RDWR;
+      }
+      if (oflags & 1) hostFlags |= fs.constants.O_CREAT;
+      if (oflags & 2) hostFlags |= fs.constants.O_EXCL;
+      if (oflags & 4) hostFlags |= fs.constants.O_TRUNC;
+      if (oflags & 8) hostFlags |= fs.constants.O_APPEND;
+
+      const realFd = fs.openSync(realPath, hostFlags);
+      const newFd = this._nextFd++;
+      const stat = fs.fstatSync(realFd);
+      const filetype = stat.isDirectory() ? FILETYPE_DIRECTORY : FILETYPE_REGULAR_FILE;
+
+      this._fdMap.set(newFd, new FdEntry('file', {
+        realFd,
+        virtualPath: name,
+        realPath,
+        filetype,
+        readable: !!(fsRightsBase & RIGHTS_FD_READ),
+        writable: !!(fsRightsBase & RIGHTS_FD_WRITE),
+      }));
+
+      if (openedFdPtr != null) this._writeWasmI32(openedFdPtr, newFd);
+      return ERRNO_SUCCESS;
+    } catch (err) {
+      if (err.code === 'EEXIST') return ERRNO_EXIST;
+      if (err.code === 'ENOENT') return ERRNO_NOSYS;
+      if (err.code === 'EACCES') return ERRNO_ACCES;
+      if (err.code === 'ENOTDIR') return ERRNO_NOTDIR;
+      if (err.code === 'EISDIR') return ERRNO_ISDIR;
+      return ERRNO_IO;
+    }
+  }
+
+  path_create_directory(fd, pathPtr, pathLen) {
+    try {
+      const name = this._readString(pathPtr, pathLen);
+      const resolved = this._resolvePath(name);
+      if (!resolved) return ERRNO_ACCES;
+      fs.mkdirSync(resolved.realPath, { recursive: true });
+      return ERRNO_SUCCESS;
+    } catch (err) {
+      if (err.code === 'EEXIST') return ERRNO_EXIST;
+      return ERRNO_IO;
+    }
+  }
+
+  path_remove_directory(fd, pathPtr, pathLen) {
+    try {
+      const name = this._readString(pathPtr, pathLen);
+      const resolved = this._resolvePath(name);
+      if (!resolved) return ERRNO_ACCES;
+      fs.rmdirSync(resolved.realPath);
+      return ERRNO_SUCCESS;
+    } catch {
+      return ERRNO_IO;
+    }
+  }
+
+  path_unlink_file(fd, pathPtr, pathLen) {
+    try {
+      const name = this._readString(pathPtr, pathLen);
+      const resolved = this._resolvePath(name);
+      if (!resolved) return ERRNO_ACCES;
+      fs.unlinkSync(resolved.realPath);
+      return ERRNO_SUCCESS;
+    } catch {
+      return ERRNO_IO;
+    }
+  }
+
+  path_rename(fd, oldPathPtr, oldPathLen, newFd, newPathPtr, newPathLen) {
+    try {
+      const oldName = this._readString(oldPathPtr, oldPathLen);
+      const newName = this._readString(newPathPtr, newPathLen);
+      const oldResolved = this._resolvePath(oldName);
+      const newResolved = this._resolvePath(newName);
+      if (!oldResolved || !newResolved) return ERRNO_ACCES;
+      fs.renameSync(oldResolved.realPath, newResolved.realPath);
+      return ERRNO_SUCCESS;
+    } catch {
+      return ERRNO_IO;
+    }
+  }
+
+  path_filestat_get(fd, flags, pathPtr, pathLen, statPtr) {
+    try {
+      const name = this._readString(pathPtr, pathLen);
+      const resolved = this._resolvePath(name);
+      if (!resolved) return ERRNO_ACCES;
+
+      const stat = fs.statSync(resolved.realPath);
+      const filetype = stat.isDirectory() ? FILETYPE_DIRECTORY : FILETYPE_REGULAR_FILE;
+      this._writeFilestat(statPtr, stat, filetype);
+      return ERRNO_SUCCESS;
+    } catch {
+      return ERRNO_IO;
+    }
+  }
+
+  fd_readdir(fd, bufPtr, bufLen, cookie, bufusedPtr) {
+    const entry = this._getFd(fd);
+    if (!entry) return ERRNO_BADF;
+
+    try {
+      if (!entry.dirEntries) {
+        const realPath = entry.realPath || '.';
+        const names = fs.readdirSync(realPath);
+        entry.dirEntries = names;
+        entry._dirCookie = 0;
+      }
+
+      let offset = 0;
+      const startIdx = Number(cookie);
+      const view = new Uint8Array(this._memory.buffer);
+
+      for (let i = startIdx; i < entry.dirEntries.length && offset < bufLen; i++) {
+        const name = entry.dirEntries[i];
+        const nameBytes = Buffer.from(name, 'utf8');
+        const entrySize = 24 + nameBytes.length;
+        if (offset + entrySize > bufLen) break;
+
+        const dataView = new DataView(this._memory.buffer);
+        dataView.setBigUint64(bufPtr + offset, BigInt(i + 1), true);
+        dataView.setBigUint64(bufPtr + offset + 8, BigInt(nameBytes.length), true);
+        dataView.setUint8(bufPtr + offset + 16, FILETYPE_REGULAR_FILE);
+        view.set(nameBytes, bufPtr + offset + 24);
+        offset += entrySize;
+      }
+
+      if (bufusedPtr != null) this._writeWasmI32(bufusedPtr, offset);
+      return ERRNO_SUCCESS;
+    } catch {
+      return ERRNO_IO;
+    }
+  }
+
+  path_readlink(fd, pathPtr, pathLen, bufPtr, bufLen, bufusedPtr) {
+    try {
+      const name = this._readString(pathPtr, pathLen);
+      const resolved = this._resolvePath(name);
+      if (!resolved) return ERRNO_ACCES;
+
+      const target = fs.readlinkSync(resolved.realPath);
+      const targetBytes = Buffer.from(target, 'utf8');
+      const toWrite = Math.min(targetBytes.length, bufLen);
+      this._writeWasmBytes(bufPtr, targetBytes.slice(0, toWrite));
+      if (bufusedPtr != null) this._writeWasmI32(bufusedPtr, toWrite);
+      return ERRNO_SUCCESS;
+    } catch {
+      return ERRNO_IO;
+    }
+  }
+
+  path_symlink(fd, oldPathPtr, oldPathLen, newPathPtr, newPathLen) {
+    try {
+      const oldName = this._readString(oldPathPtr, oldPathLen);
+      const newName = this._readString(newPathPtr, newPathLen);
+      const newResolved = this._resolvePath(newName);
+      if (!newResolved) return ERRNO_ACCES;
+      fs.symlinkSync(oldName, newResolved.realPath);
+      return ERRNO_SUCCESS;
+    } catch {
+      return ERRNO_IO;
+    }
+  }
+
+  clock_time_get(clockId, precision, timePtr) {
+    const now = Date.now();
+    const ns = clockId === 0 ? BigInt(now) * 1000000n : BigInt(process.hrtime.bigint());
+    if (timePtr != null && this._memory) {
+      const view = new DataView(this._memory.buffer);
+      view.setBigUint64(timePtr, ns, true);
+    }
+    return ERRNO_SUCCESS;
+  }
+
+  clock_res_get(clockId, resolutionPtr) {
+    if (resolutionPtr != null && this._memory) {
+      const view = new DataView(this._memory.buffer);
+      view.setBigUint64(resolutionPtr, 1000n, true);
+    }
+    return ERRNO_SUCCESS;
+  }
+
+  random_get(bufPtr, bufLen) {
+    const crypto = require('crypto');
+    const bytes = crypto.randomBytes(bufLen);
+    if (this._memory) {
+      this._writeWasmBytes(bufPtr, bytes);
+    }
+    return ERRNO_SUCCESS;
+  }
+
+  proc_exit(code) {
+    throw new Error(`WASI process exited with code ${code}`);
+  }
+
+  args_sizes_get(argcPtr, argvBufSizePtr) {
+    const totalSize = this.args.reduce((sum, a) => sum + Buffer.byteLength(a) + 1, 0);
+    if (argcPtr != null) this._writeWasmI32(argcPtr, this.args.length);
+    if (argvBufSizePtr != null) this._writeWasmI32(argvBufSizePtr, totalSize);
+    return ERRNO_SUCCESS;
+  }
+
+  args_get(argvPtr, argvBufPtr) {
+    let bufOffset = 0;
+    for (let i = 0; i < this.args.length; i++) {
+      const arg = this.args[i];
+      const bytes = Buffer.from(arg, 'utf8');
+      this._writeWasmI32(argvPtr + i * 4, argvBufPtr + bufOffset);
+      this._writeWasmBytes(argvBufPtr + bufOffset, bytes);
+      this._writeWasmBytes(argvBufPtr + bufOffset + bytes.length, Buffer.from([0]));
+      bufOffset += bytes.length + 1;
+    }
+    return ERRNO_SUCCESS;
+  }
+
+  environ_sizes_get(countPtr, sizePtr) {
+    const envKeys = Object.keys(this.env);
+    const totalSize = envKeys.reduce((sum, k) => {
+      return sum + Buffer.byteLength(k) + 1 + Buffer.byteLength(String(this.env[k])) + 1;
+    }, 0);
+    if (countPtr != null) this._writeWasmI32(countPtr, envKeys.length);
+    if (sizePtr != null) this._writeWasmI32(sizePtr, totalSize);
+    return ERRNO_SUCCESS;
+  }
+
+  environ_get(environPtr, environBufPtr) {
+    let bufOffset = 0;
+    let i = 0;
+    for (const [key, val] of Object.entries(this.env)) {
+      const entry = `${key}=${val}`;
+      const bytes = Buffer.from(entry, 'utf8');
+      this._writeWasmI32(environPtr + i * 4, environBufPtr + bufOffset);
+      this._writeWasmBytes(environBufPtr + bufOffset, bytes);
+      this._writeWasmBytes(environBufPtr + bufOffset + bytes.length, Buffer.from([0]));
+      bufOffset += bytes.length + 1;
+      i++;
+    }
+    return ERRNO_SUCCESS;
+  }
+
+  poll_oneoff(inPtr, outPtr, nsubscriptions, neventsPtr) {
+    if (neventsPtr != null) this._writeWasmI32(neventsPtr, 0);
+    return ERRNO_SUCCESS;
+  }
+
+  sched_yield() {
+    return ERRNO_SUCCESS;
+  }
+
+  fd_advise(fd, offset, len, advice) {
+    return ERRNO_SUCCESS;
+  }
+
+  fd_allocate(fd, offset, len) {
+    return ERRNO_SUCCESS;
+  }
+
+  fd_datasync(fd) {
+    const entry = this._getFd(fd);
+    if (!entry) return ERRNO_BADF;
+    try {
+      if (entry.realFd !== null) fs.fdatasyncSync(entry.realFd);
+      return ERRNO_SUCCESS;
+    } catch {
+      return ERRNO_IO;
+    }
+  }
+
+  fd_sync(fd) {
+    const entry = this._getFd(fd);
+    if (!entry) return ERRNO_BADF;
+    try {
+      if (entry.realFd !== null) fs.fsyncSync(entry.realFd);
+      return ERRNO_SUCCESS;
+    } catch {
+      return ERRNO_IO;
+    }
+  }
+
+  fd_fdstat_set_flags(fd, flags) {
+    const entry = this._getFd(fd);
+    if (!entry) return ERRNO_BADF;
+    entry.flags = flags;
+    return ERRNO_SUCCESS;
+  }
+
+  fd_tell(fd, newoffsetPtr) {
+    const entry = this._getFd(fd);
+    if (!entry) return ERRNO_BADF;
+    if (newoffsetPtr != null) this._writeWasmI64(newoffsetPtr, entry.position);
+    return ERRNO_SUCCESS;
+  }
+
+  fd_renumber(from, to) {
+    const fromEntry = this._getFd(from);
+    if (!fromEntry) return ERRNO_BADF;
+    const toEntry = this._getFd(to);
+    if (!toEntry) return ERRNO_BADF;
+    this._fdMap.set(to, fromEntry);
+    this._fdMap.delete(from);
+    return ERRNO_SUCCESS;
+  }
+
+  _readString(ptr, len) {
+    if (!this._memory || ptr == null || len == null || !len) return '';
+    const bytes = new Uint8Array(this._memory.buffer, ptr, len);
+    return new TextDecoder().decode(bytes);
+  }
+
+  toImportObject() {
+    const ctx = this;
+    const funcs = {
+      fd_write: (fd, iovs, iovsLen, nwritten) => ctx.fd_write(fd, iovs, iovsLen, nwritten),
+      fd_read: (fd, iovs, iovsLen, nread) => ctx.fd_read(fd, iovs, iovsLen, nread),
+      fd_close: (fd) => ctx.fd_close(fd),
+      fd_seek: (fd, offset, whence, newoffset) => ctx.fd_seek(fd, Number(offset), whence, newoffset),
+      fd_fdstat_get: (fd, stat) => ctx.fd_fdstat_get(fd, stat),
+      fd_fdstat_set_flags: (fd, flags) => ctx.fd_fdstat_set_flags(fd, flags),
+      fd_prestat_get: (fd, buf) => ctx.fd_prestat_get(fd, buf),
+      fd_prestat_dir_name: (fd, buf, len) => ctx.fd_prestat_dir_name(fd, buf, len),
+      fd_filestat_get: (fd, buf) => ctx.fd_filestat_get(fd, buf),
+      fd_readdir: (fd, buf, len, cookie, bufused) => ctx.fd_readdir(fd, buf, len, cookie, bufused),
+      fd_tell: (fd, newoffset) => ctx.fd_tell(fd, newoffset),
+      fd_renumber: (from, to) => ctx.fd_renumber(from, to),
+      fd_datasync: (fd) => ctx.fd_datasync(fd),
+      fd_sync: (fd) => ctx.fd_sync(fd),
+      fd_advise: (fd, offset, len, advice) => ctx.fd_advise(fd, Number(offset), Number(len), advice),
+      fd_allocate: (fd, offset, len) => ctx.fd_allocate(fd, Number(offset), Number(len)),
+      path_open: (fd, dirflags, path, pathLen, oflags, fsRightsBase, fsRightsInheriting, fdFlags, openedFd) =>
+        ctx.path_open(fd, dirflags, path, pathLen, oflags, fsRightsBase, fsRightsInheriting, fdFlags, openedFd),
+      path_create_directory: (fd, path, pathLen) => ctx.path_create_directory(fd, path, pathLen),
+      path_remove_directory: (fd, path, pathLen) => ctx.path_remove_directory(fd, path, pathLen),
+      path_unlink_file: (fd, path, pathLen) => ctx.path_unlink_file(fd, path, pathLen),
+      path_rename: (fd, oldPath, oldPathLen, newFd, newPath, newPathLen) =>
+        ctx.path_rename(fd, oldPath, oldPathLen, newFd, newPath, newPathLen),
+      path_filestat_get: (fd, flags, path, pathLen, buf) => ctx.path_filestat_get(fd, flags, path, pathLen, buf),
+      path_readlink: (fd, path, pathLen, buf, bufLen, bufused) =>
+        ctx.path_readlink(fd, path, pathLen, buf, bufLen, bufused),
+      path_symlink: (fd, oldPath, oldPathLen, newPath, newPathLen) =>
+        ctx.path_symlink(fd, oldPath, oldPathLen, newPath, newPathLen),
+      clock_time_get: (id, precision, time) => ctx.clock_time_get(id, Number(precision), time),
+      clock_res_get: (id, resolution) => ctx.clock_res_get(id, resolution),
+      random_get: (buf, len) => ctx.random_get(buf, len),
+      proc_exit: (code) => ctx.proc_exit(code),
+      args_sizes_get: (argc, bufSize) => ctx.args_sizes_get(argc, bufSize),
+      args_get: (argv, buf) => ctx.args_get(argv, buf),
+      environ_sizes_get: (count, size) => ctx.environ_sizes_get(count, size),
+      environ_get: (environ, buf) => ctx.environ_get(environ, buf),
+      poll_oneoff: (inPtr, outPtr, nsubscriptions, nevents) =>
+        ctx.poll_oneoff(inPtr, outPtr, nsubscriptions, nevents),
+      sched_yield: () => ctx.sched_yield(),
+    };
+    return { 'wasi_snapshot_preview1': funcs, 'wasi_unstable': funcs };
+  }
+}
+
+module.exports = { WasiContext, ERRNO_SUCCESS, ERRNO_BADF, ERRNO_INVAL, ERRNO_ACCES, ERRNO_EXIST };

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 };