@gcoredev/fastedge-test 0.0.1-beta.4 → 0.1.0-beta.3

package/dist/lib/test-framework/index.js

@@ -736,6 +736,8 @@ var HostFunctions = class {
     this.pendingHttpCall = null;
     this.httpCallResponse = null;
     this.streamClosed = false;
+    // Local response state (from proxy_send_local_response / send_http_response)
+    this.localResponse = null;
     this.memory = memory;
     this.propertyResolver = propertyResolver;
     this.propertyAccessControl = propertyAccessControl;
@@ -790,6 +792,16 @@ var HostFunctions = class {
   resetStreamClosed() {
     this.streamClosed = false;
   }
+  // Local response accessors (called by ProxyWasmRunner after callHook)
+  hasLocalResponse() {
+    return this.localResponse !== null;
+  }
+  getLocalResponse() {
+    return this.localResponse;
+  }
+  resetLocalResponse() {
+    this.localResponse = null;
+  }
   getRequestHeaders() {
     return this.requestHeaders;
   }
@@ -1050,15 +1062,21 @@ var HostFunctions = class {
         this.currentContextId = contextId || this.currentContextId;
         return 0 /* Ok */;
       },
-      proxy_send_local_response: (statusCode, statusCodePtr, statusCodeLen, bodyPtr, bodyLen, grpcStatus) => {
+      proxy_send_local_response: (statusCode, statusCodePtr, statusCodeLen, bodyPtr, bodyLen, headerPairsPtr, headerPairsLen, grpcStatus) => {
         this.setLastHostCall(
           `proxy_send_local_response status=${statusCode} bodyLen=${bodyLen}`
         );
         const statusText = this.memory.readString(statusCodePtr, statusCodeLen);
-        const body = this.memory.readString(bodyPtr, bodyLen);
+        const body = this.memory.readBytes(bodyPtr, bodyLen);
+        if (headerPairsLen > 0) {
+          const headerBytes = this.memory.readBytes(headerPairsPtr, headerPairsLen);
+          const headers = HeaderManager.deserializeBinary(headerBytes);
+          this.logDebug(`send_local_response headers (not merged): ${JSON.stringify(headers)}`);
+        }
+        this.localResponse = { statusCode, statusText, body };
         this.logs.push({
           level: 1,
-          message: `local_response status=${statusCode} ${statusText} body=${body} grpc=${grpcStatus}`
+          message: `local_response status=${statusCode} ${statusText} bodyLen=${body.byteLength} grpc=${grpcStatus}`
         });
         return 0 /* Ok */;
       },
@@ -1638,7 +1656,6 @@ async function loadDotenvFiles(dotenvPath = ".") {
 // server/runner/ProxyWasmRunner.ts
 var textEncoder4 = new TextEncoder();
 var ProxyWasmRunner = class {
-  // Default to enabled
   constructor(fastEdgeConfig, dotenvEnabled = true) {
     this.module = null;
     // Compiled module (reused)
@@ -1652,6 +1669,8 @@ var ProxyWasmRunner = class {
     this.debug = process.env.PROXY_RUNNER_DEBUG === "1";
     this.stateManager = null;
     this.dotenvEnabled = true;
+    // Default to enabled
+    this.dotenvPath = ".";
     this.memory = new MemoryManager();
     this.propertyResolver = new PropertyResolver();
     this.propertyAccessControl = new PropertyAccessControl();
@@ -1686,7 +1705,7 @@ var ProxyWasmRunner = class {
       return;
     }
     try {
-      const dotenvConfig = await loadDotenvFiles(".");
+      const dotenvConfig = await loadDotenvFiles(this.dotenvPath);
       if (dotenvConfig.secrets && Object.keys(dotenvConfig.secrets).length > 0) {
         const existingSecrets = this.secretStore.getAll();
         this.secretStore = new SecretStore({
@@ -1718,9 +1737,37 @@ var ProxyWasmRunner = class {
       console.error("Failed to load dotenv files:", error);
     }
   }
+  /**
+   * Apply dotenv settings to the running module without recompiling.
+   * Resets SecretStore/Dictionary to empty, then re-loads dotenv files
+   * using the new settings. The compiled WASM module is untouched.
+   */
+  async applyDotenv(enabled, dotenvPath) {
+    this.dotenvEnabled = enabled;
+    if (dotenvPath !== void 0) {
+      this.dotenvPath = dotenvPath;
+    }
+    this.secretStore = new SecretStore();
+    this.dictionary = new Dictionary();
+    await this.loadDotenvIfEnabled();
+    if (!enabled) {
+      this.hostFunctions = new HostFunctions(
+        this.memory,
+        this.propertyResolver,
+        this.propertyAccessControl,
+        () => this.currentHook,
+        this.debug,
+        this.secretStore,
+        this.dictionary
+      );
+    }
+  }
   async load(bufferOrPath, config) {
-    if (config?.dotenvEnabled !== void 0) {
-      this.dotenvEnabled = config.dotenvEnabled;
+    if (config?.dotenv?.enabled !== void 0) {
+      this.dotenvEnabled = config.dotenv.enabled;
+    }
+    if (config?.dotenv?.path !== void 0) {
+      this.dotenvPath = config.dotenv.path;
     }
     this.resetState();
     let buffer;
@@ -1791,6 +1838,25 @@ var ProxyWasmRunner = class {
         "system"
       );
     }
+    if (results.onRequestHeaders.returnCode === 1 && this.hostFunctions.hasLocalResponse()) {
+      const local = this.hostFunctions.getLocalResponse();
+      const responseHeaders = results.onRequestHeaders.output.response.headers;
+      this.hostFunctions.resetLocalResponse();
+      const contentType = responseHeaders["content-type"] || "text/plain";
+      const { body, isBase64 } = encodeLocalResponseBody(local.body, contentType);
+      return {
+        hookResults: results,
+        finalResponse: {
+          status: local.statusCode,
+          statusText: local.statusText,
+          headers: responseHeaders,
+          body,
+          contentType,
+          isBase64
+        },
+        calculatedProperties: this.propertyResolver.getCalculatedProperties()
+      };
+    }
     const headersAfterRequestHeaders = results.onRequestHeaders.output.request.headers;
     const propertiesAfterRequestHeaders = results.onRequestHeaders.properties;
     this.logDebug(
@@ -1815,6 +1881,25 @@ var ProxyWasmRunner = class {
         "system"
       );
     }
+    if (results.onRequestBody.returnCode === 1 && this.hostFunctions.hasLocalResponse()) {
+      const local = this.hostFunctions.getLocalResponse();
+      const responseHeaders = results.onRequestBody.output.response.headers;
+      this.hostFunctions.resetLocalResponse();
+      const contentType = responseHeaders["content-type"] || "text/plain";
+      const { body, isBase64 } = encodeLocalResponseBody(local.body, contentType);
+      return {
+        hookResults: results,
+        finalResponse: {
+          status: local.statusCode,
+          statusText: local.statusText,
+          headers: responseHeaders,
+          body,
+          contentType,
+          isBase64
+        },
+        calculatedProperties: this.propertyResolver.getCalculatedProperties()
+      };
+    }
     const modifiedRequestHeaders = results.onRequestBody.output.request.headers;
     const modifiedRequestBody = results.onRequestBody.output.request.body;
     const propertiesAfterRequestBody = results.onRequestBody.properties;
@@ -2003,6 +2088,7 @@ var ProxyWasmRunner = class {
       throw new Error("WASM module not loaded");
     }
     this.currentHook = this.getHookContext(call.hook);
+    this.hostFunctions.resetLocalResponse();
     const imports = this.createImports();
     this.instance = await WebAssembly.instantiate(this.module, imports);
     const memory = this.instance.exports.memory;
@@ -2401,7 +2487,7 @@ var ProxyWasmRunner = class {
   /**
    * Not supported for Proxy-WASM (HTTP WASM only)
    */
-  async execute(request2) {
+  async execute(request) {
     throw new Error(
       "execute() is not supported for Proxy-WASM. Use callHook() or callFullFlow() instead."
     );
@@ -2436,16 +2522,24 @@ function ensureNullTerminated(value) {
   }
   return value.endsWith("\0") ? value : `${value}\0`;
 }
+function encodeLocalResponseBody(body, contentType) {
+  const isBinary = contentType.startsWith("image/") || contentType.startsWith("video/") || contentType.startsWith("audio/") || contentType.includes("application/octet-stream") || contentType.includes("application/pdf") || contentType.includes("application/zip");
+  if (isBinary) {
+    return { body: Buffer.from(body).toString("base64"), isBase64: true };
+  }
+  return { body: new TextDecoder().decode(body), isBase64: false };
+}
 
 // server/runner/HttpWasmRunner.ts
-import { spawn } from "child_process";
-import * as http from "http";
+import { spawn, execSync as execSync2 } from "child_process";
 
 // server/utils/fastedge-cli.ts
 import { execSync } from "child_process";
-import { existsSync } from "fs";
-import { join } from "path";
+import { existsSync, chmodSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
 import os from "os";
+var _currentDir = dirname(fileURLToPath(import.meta.url));
 function getCliBinaryName() {
   switch (os.platform()) {
     case "win32":
@@ -2461,19 +2555,30 @@ function getCliBinaryName() {
 function getBundledCliPaths() {
   const binaryName = getCliBinaryName();
   return [
-    // Production: bundled server at dist/server.js
-    join(__dirname, "fastedge-cli", binaryName),
+    // Installed npm package: dist/lib/index.js → dist/fastedge-cli/
+    join(_currentDir, "..", "fastedge-cli", binaryName),
+    // Production: bundled server at dist/server.js → dist/fastedge-cli/
+    join(_currentDir, "fastedge-cli", binaryName),
     // Development/Tests: running from source
-    // __dirname might be server/utils/, so go up to project root
-    join(__dirname, "..", "..", "fastedge-run", binaryName),
-    // Alternative: if __dirname is already at project root
-    join(__dirname, "fastedge-run", binaryName)
+    // _currentDir might be server/utils/, so go up to project root
+    join(_currentDir, "..", "..", "fastedge-run", binaryName),
+    // Alternative: if _currentDir is already at project root
+    join(_currentDir, "fastedge-run", binaryName)
   ];
 }
+function ensureExecutable(binaryPath) {
+  if (process.platform !== "win32") {
+    try {
+      chmodSync(binaryPath, 493);
+    } catch {
+    }
+  }
+}
 async function findFastEdgeRunCli() {
   const envPath = process.env.FASTEDGE_RUN_PATH;
   if (envPath) {
     if (existsSync(envPath)) {
+      ensureExecutable(envPath);
       return envPath;
     } else {
       throw new Error(
@@ -2483,6 +2588,7 @@ async function findFastEdgeRunCli() {
   }
   for (const bundledPath of getBundledCliPaths()) {
     if (existsSync(bundledPath)) {
+      ensureExecutable(bundledPath);
       return bundledPath;
     }
   }
@@ -2530,9 +2636,12 @@ var HttpWasmRunner = class {
     this.port = null;
     this.cliPath = null;
     this.tempWasmPath = null;
+    this.currentWasmPath = null;
+    // resolved path used when spawning
     this.logs = [];
     this.stateManager = null;
     this.dotenvEnabled = true;
+    this.dotenvPath = null;
     this.portManager = portManager;
     this.dotenvEnabled = dotenvEnabled;
   }
@@ -2540,8 +2649,11 @@ var HttpWasmRunner = class {
    * Load WASM binary and spawn fastedge-run process
    */
   async load(bufferOrPath, config) {
-    if (config?.dotenvEnabled !== void 0) {
-      this.dotenvEnabled = config.dotenvEnabled;
+    if (config?.dotenv?.enabled !== void 0) {
+      this.dotenvEnabled = config.dotenv.enabled;
+    }
+    if (config?.dotenv?.path !== void 0) {
+      this.dotenvPath = config.dotenv.path;
     }
     await this.cleanup();
     this.cliPath = await findFastEdgeRunCli();
@@ -2553,7 +2665,7 @@ var HttpWasmRunner = class {
       wasmPath = await writeTempWasmFile(bufferOrPath);
       this.tempWasmPath = wasmPath;
     }
-    this.port = this.portManager.allocate();
+    this.port = await this.portManager.allocate();
     const args = [
       "http",
       "-p",
@@ -2564,8 +2676,13 @@ var HttpWasmRunner = class {
       "true"
     ];
     if (this.dotenvEnabled) {
-      args.push("--dotenv");
+      if (this.dotenvPath) {
+        args.push("--dotenv", this.dotenvPath);
+      } else {
+        args.push("--dotenv");
+      }
     }
+    this.currentWasmPath = wasmPath;
     this.process = spawn(this.cliPath, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: {
@@ -2581,17 +2698,17 @@ var HttpWasmRunner = class {
   /**
    * Execute an HTTP request through the WASM module
    */
-  async execute(request2) {
+  async execute(request) {
     if (!this.port || !this.process) {
       throw new Error("HttpWasmRunner not loaded. Call load() first.");
     }
     this.logs = [];
     try {
-      const url = `http://localhost:${this.port}${request2.path}`;
+      const url = `http://localhost:${this.port}${request.path}`;
       const response = await fetch(url, {
-        method: request2.method,
-        headers: request2.headers,
-        body: request2.body || void 0,
+        method: request.method,
+        headers: request.headers,
+        body: request.body || void 0,
         signal: AbortSignal.timeout(3e4)
         // 30 second timeout
       });
@@ -2619,7 +2736,7 @@ var HttpWasmRunner = class {
   /**
    * Not supported for HTTP WASM (proxy-wasm only)
    */
-  async callHook(hookCall) {
+  async callHook(_hookCall) {
     throw new Error(
       "callHook() is not supported for HTTP WASM. Use execute() instead."
     );
@@ -2627,11 +2744,53 @@ var HttpWasmRunner = class {
   /**
    * Not supported for HTTP WASM (proxy-wasm only)
    */
-  async callFullFlow(url, method, headers, body, responseHeaders, responseBody, responseStatus, responseStatusText, properties, enforceProductionPropertyRules) {
+  async callFullFlow(_url, _method, _headers, _body, _responseHeaders, _responseBody, _responseStatus, _responseStatusText, _properties, _enforceProductionPropertyRules) {
     throw new Error(
       "callFullFlow() is not supported for HTTP WASM. Use execute() instead."
     );
   }
+  /**
+   * Apply dotenv settings by restarting the fastedge-run process.
+   * The WASM file is not re-read; only the --dotenv flag changes.
+   */
+  async applyDotenv(enabled, dotenvPath) {
+    this.dotenvEnabled = enabled;
+    if (dotenvPath !== void 0) {
+      this.dotenvPath = dotenvPath;
+    }
+    if (!this.process || !this.currentWasmPath || !this.cliPath || this.port === null) {
+      return;
+    }
+    await this.killProcess();
+    this.process = null;
+    const args = [
+      "http",
+      "-p",
+      this.port.toString(),
+      "-w",
+      this.currentWasmPath,
+      "--wasi-http",
+      "true"
+    ];
+    if (this.dotenvEnabled) {
+      if (this.dotenvPath) {
+        args.push("--dotenv", this.dotenvPath);
+      } else {
+        args.push("--dotenv");
+      }
+    }
+    this.process = spawn(this.cliPath, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        RUST_LOG: "info",
+        ...process.env
+      }
+    });
+    this.setupLogCapture();
+    this.setupErrorHandlers();
+    const timeout = process.env.NODE_ENV === "test" || process.env.VITEST ? 2e4 : 1e4;
+    await this.waitForServerReady(this.port, timeout);
+  }
   /**
    * Clean up resources
    */
@@ -2656,12 +2815,41 @@ var HttpWasmRunner = class {
   getType() {
     return "http-wasm";
   }
+  /**
+   * Get the port the fastedge-run HTTP server is listening on
+   */
+  getPort() {
+    return this.port;
+  }
   /**
    * Set state manager
    */
   setStateManager(stateManager) {
     this.stateManager = stateManager;
   }
+  /**
+   * Parse log level from a process output line.
+   * Matches bare prefixes (e.g. "INFO  target > msg") and bracketed prefixes (e.g. "[INFO] msg").
+   * Falls back to the provided default if no known level prefix is found.
+   */
+  parseLogLevel(message, fallback) {
+    const match = message.trimStart().match(/^\[?(\w+)\]?/);
+    const prefix = match?.[1]?.toUpperCase();
+    switch (prefix) {
+      case "TRACE":
+        return 0;
+      case "DEBUG":
+        return 1;
+      case "INFO":
+        return 2;
+      case "WARN":
+        return 3;
+      case "ERROR":
+        return 4;
+      default:
+        return fallback;
+    }
+  }
   /**
    * Setup log capture from process stdout/stderr
    */
@@ -2670,13 +2858,17 @@ var HttpWasmRunner = class {
     this.process.stdout?.on("data", (data) => {
       const message = data.toString().trim();
       if (message) {
-        this.logs.push({ level: 2, message });
+        const log = { level: this.parseLogLevel(message, 2), message };
+        this.logs.push(log);
+        this.stateManager?.emitHttpWasmLog(log);
       }
     });
     this.process.stderr?.on("data", (data) => {
       const message = data.toString().trim();
       if (message) {
-        this.logs.push({ level: 4, message });
+        const log = { level: this.parseLogLevel(message, 4), message };
+        this.logs.push(log);
+        this.stateManager?.emitHttpWasmLog(log);
       }
     });
   }
@@ -2706,66 +2898,54 @@ var HttpWasmRunner = class {
     });
   }
   /**
-   * Probe port with a single HTTP GET, returning true if any response is received.
-   * Uses Node.js http module with explicit content-length: 0 so that wasi-http
-   * runtimes (fastedge-run) immediately signal EOF to the WASM request body
-   * stream. Without this, newer fastedge-run builds hold the body stream open
-   * on keep-alive connections, causing the WASM's event.request.text() to hang
-   * indefinitely and never send a response.
-   */
-  probePort(port, timeoutMs) {
-    return new Promise((resolve) => {
-      const req = http.request(
-        {
-          hostname: "localhost",
-          port,
-          path: "/",
-          method: "GET",
-          headers: {
-            "content-length": "0",
-            connection: "close"
-          }
-        },
-        (res) => {
-          res.resume();
-          resolve(true);
-        }
-      );
-      req.setTimeout(timeoutMs, () => {
-        req.destroy();
-        resolve(false);
-      });
-      req.on("error", () => resolve(false));
-      req.end();
-    });
-  }
-  /**
-   * Wait for server to be ready by polling
+   * Wait for the fastedge-run HTTP server to be ready by watching process logs
+   * for the "Listening on" message.
+   *
+   * We intentionally avoid HTTP probing here. HTTP probes trigger WASM execution
+   * (the app calls event.request.text() to read the body), which can hang for
+   * many seconds in CI due to WASM JIT compilation on the first request, or
+   * because newer fastedge-run builds hold the body stream open regardless of
+   * content-length. Watching logs avoids all of this: fastedge-run emits
+   * "Listening on http://127.0.0.1:<port>" as soon as the HTTP listener is bound,
+   * before any WASM execution occurs.
    */
-  async waitForServerReady(port, timeoutMs) {
+  waitForServerReady(port, timeoutMs) {
     const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
-      const ready = await this.probePort(port, 5e3);
-      if (ready) return;
-      if (this.process && this.process.exitCode !== null) {
-        throw new Error(
-          `FastEdge-run process exited with code ${this.process.exitCode} before server started`
-        );
-      }
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    const processInfo = this.process ? `Process state: exitCode=${this.process.exitCode}, killed=${this.process.killed}, pid=${this.process.pid}` : "Process is null";
-    const recentLogs = this.logs.slice(-5).map((l) => `[${l.level}] ${l.message}`).join("\n");
-    throw new Error(
-      `FastEdge-run server did not start within ${timeoutMs}ms on port ${port}
+    return new Promise((resolve, reject) => {
+      const check = () => {
+        if (this.process && this.process.exitCode !== null) {
+          return reject(
+            new Error(
+              `FastEdge-run process exited with code ${this.process.exitCode} before server started`
+            )
+          );
+        }
+        if (this.logs.some((l) => l.message.includes("Listening on"))) {
+          return resolve();
+        }
+        if (Date.now() - startTime >= timeoutMs) {
+          const processInfo = this.process ? `Process state: exitCode=${this.process.exitCode}, killed=${this.process.killed}, pid=${this.process.pid}` : "Process is null";
+          const recentLogs = this.logs.slice(-5).map((l) => `[${l.level}] ${l.message}`).join("\n");
+          return reject(
+            new Error(
+              `FastEdge-run server did not start within ${timeoutMs}ms on port ${port}
 ${processInfo}
 Recent logs:
 ${recentLogs || "(no logs)"}`
-    );
+            )
+          );
+        }
+        setTimeout(check, 50);
+      };
+      check();
+    });
   }
   /**
-   * Kill the process gracefully (SIGINT) with fallback to SIGKILL
-   * FastEdge-run responds to SIGINT for graceful shutdown
+   * Kill the process gracefully (SIGINT) with platform-specific force-kill fallback.
+   * SIGINT is sent first on all platforms — Node.js translates it for Windows.
+   * If the process does not exit within 2 seconds:
+   *   - Windows: taskkill /F /T to terminate the process tree
+   *   - Unix: SIGKILL
    */
   async killProcess() {
     if (!this.process) return;
@@ -2776,8 +2956,18 @@ ${recentLogs || "(no logs)"}`
       }
       this.process.kill("SIGINT");
       const timeout = setTimeout(() => {
-        if (this.process && !this.process.killed) {
-          this.process.kill("SIGKILL");
+        if (this.process && this.process.exitCode === null && this.process.signalCode === null) {
+          if (process.platform === "win32") {
+            const pid = this.process.pid;
+            if (pid) {
+              try {
+                execSync2(`taskkill /F /T /PID ${pid}`);
+              } catch {
+              }
+            }
+          } else {
+            this.process.kill("SIGKILL");
+          }
         }
         resolve();
       }, 2e3);
@@ -2800,9 +2990,7 @@ ${recentLogs || "(no logs)"}`
       "application/zip",
       "application/gzip"
     ];
-    return binaryTypes.some(
-      (type) => contentType.toLowerCase().includes(type)
-    );
+    return binaryTypes.some((type) => contentType.toLowerCase().includes(type));
   }
   /**
    * Parse headers from fetch Headers object
@@ -2817,6 +3005,7 @@ ${recentLogs || "(no logs)"}`
 };
 
 // server/runner/PortManager.ts
+import { createServer } from "net";
 var PortManager = class {
   constructor() {
     this.minPort = 8100;
@@ -2824,18 +3013,31 @@ var PortManager = class {
     this.allocatedPorts = /* @__PURE__ */ new Set();
     this.lastAllocatedPort = this.minPort - 1;
   }
-  // Track last allocated port for sequential allocation
   /**
-   * Allocate an available port from the pool
-   * Sequential allocation to avoid reusing recently released ports (TCP TIME_WAIT)
-   * Synchronous to prevent race conditions when allocating in parallel
+   * Check whether a port is actually free at the OS level.
+   * This is necessary when multiple server processes run simultaneously —
+   * each has its own PortManager with independent in-memory state, so
+   * in-memory tracking alone is not enough to prevent cross-process conflicts.
+   */
+  isPortFree(port) {
+    return new Promise((resolve) => {
+      const server = createServer();
+      server.once("error", () => resolve(false));
+      server.once("listening", () => server.close(() => resolve(true)));
+      server.listen(port, "127.0.0.1");
+    });
+  }
+  /**
+   * Allocate an available port from the pool.
+   * Combines in-memory tracking (avoids TCP TIME_WAIT reuse within this process)
+   * with an OS-level check (avoids cross-process collisions).
    * @returns The allocated port number
    * @throws Error if no ports are available
    */
-  allocate() {
+  async allocate() {
     for (let offset = 1; offset <= this.maxPort - this.minPort + 1; offset++) {
       const port = this.minPort + (this.lastAllocatedPort - this.minPort + offset) % (this.maxPort - this.minPort + 1);
-      if (!this.allocatedPorts.has(port)) {
+      if (!this.allocatedPorts.has(port) && await this.isPortFree(port)) {
         this.allocatedPorts.add(port);
         this.lastAllocatedPort = port;
         return port;
@@ -2847,32 +3049,19 @@ var PortManager = class {
   }
   /**
    * Release a previously allocated port back to the pool
-   * @param port The port number to release
    */
   release(port) {
     this.allocatedPorts.delete(port);
   }
-  /**
-   * Get the number of currently allocated ports
-   */
   getAllocatedCount() {
     return this.allocatedPorts.size;
   }
-  /**
-   * Get the number of available ports
-   */
   getAvailableCount() {
     return this.maxPort - this.minPort + 1 - this.allocatedPorts.size;
   }
-  /**
-   * Check if a specific port is allocated
-   */
   isAllocated(port) {
     return this.allocatedPorts.has(port);
   }
-  /**
-   * Reset all allocations (useful for testing)
-   */
   reset() {
     this.allocatedPorts.clear();
   }
@@ -2917,9 +3106,9 @@ async function createRunnerFromBuffer(buffer, config) {
   const wasmType = config?.runnerType ?? await detectWasmType(buffer);
   let runner;
   if (wasmType === "http-wasm") {
-    runner = new HttpWasmRunner(new PortManager(), config?.dotenvEnabled ?? false);
+    runner = new HttpWasmRunner(new PortManager(), config?.dotenv?.enabled ?? false);
   } else {
-    runner = new ProxyWasmRunner(void 0, config?.dotenvEnabled ?? false);
+    runner = new ProxyWasmRunner(void 0, config?.dotenv?.enabled ?? false);
   }
   await runner.load(buffer, config);
   return runner;
@@ -2948,7 +3137,10 @@ var TestConfigSchema = z.object({
   request: RequestConfigSchema,
   response: ResponseConfigSchema.optional(),
   properties: z.record(z.string(), z.unknown()).optional().default({}),
-  dotenvEnabled: z.boolean().optional().default(true)
+  dotenv: z.object({
+    enabled: z.boolean().optional(),
+    path: z.string().optional()
+  }).optional()
 });
 
 // server/test-framework/suite-runner.ts