npm - @gcoredev/fastedge-test - Versions diffs - 0.1.6 → 0.2.0 - Mend

@gcoredev/fastedge-test 0.1.6 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (43) hide show

package/dist/frontend/assets/{index-BpdzhbRl.js → index-CiqeJ9rz.js} +24 -24
package/dist/frontend/index.html +1 -1
package/dist/lib/index.cjs +164 -66
package/dist/lib/index.d.ts +1 -0
package/dist/lib/index.js +164 -66
package/dist/lib/runner/HeaderManager.d.ts +6 -4
package/dist/lib/runner/HostFunctions.d.ts +5 -5
package/dist/lib/runner/HttpWasmRunner.d.ts +22 -5
package/dist/lib/runner/IStateManager.d.ts +7 -7
package/dist/lib/runner/IWasmRunner.d.ts +42 -10
package/dist/lib/runner/PortManager.d.ts +4 -1
package/dist/lib/runner/PropertyResolver.d.ts +3 -3
package/dist/lib/runner/ProxyWasmRunner.d.ts +5 -2
package/dist/lib/runner/standalone.d.ts +1 -1
package/dist/lib/runner/types.d.ts +17 -8
package/dist/lib/schemas/api.d.ts +2 -8
package/dist/lib/schemas/config.d.ts +2 -13
package/dist/lib/schemas/index.d.ts +2 -2
package/dist/lib/test-framework/assertions.d.ts +18 -4
package/dist/lib/test-framework/index.cjs +18634 -115
package/dist/lib/test-framework/index.d.ts +2 -0
package/dist/lib/test-framework/index.js +18651 -104
package/dist/lib/test-framework/mock-origins.d.ts +56 -0
package/dist/lib/test-framework/suite-runner.d.ts +16 -0
package/dist/lib/test-framework/types.d.ts +1 -5
package/dist/server.js +33 -33
package/docs/API.md +48 -54
package/docs/DEBUGGER.md +7 -8
package/docs/INDEX.md +4 -1
package/docs/RUNNER.md +126 -74
package/docs/TEST_CONFIG.md +79 -40
package/docs/TEST_FRAMEWORK.md +235 -36
package/docs/WEBSOCKET.md +25 -21
package/docs/quickstart.md +1 -13
package/package.json +4 -1
package/schemas/api-config.schema.json +5 -24
package/schemas/api-load.schema.json +5 -0
package/schemas/api-send.schema.json +0 -20
package/schemas/fastedge-config.test.schema.json +5 -24
package/schemas/full-flow-result.schema.json +17 -7
package/schemas/hook-call.schema.json +16 -6
package/schemas/hook-result.schema.json +16 -6
package/schemas/http-response.schema.json +227 -5

package/dist/frontend/index.html CHANGED Viewed

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Proxy Runner</title>
-    <script type="module" crossorigin src="/assets/index-BpdzhbRl.js"></script>
+    <script type="module" crossorigin src="/assets/index-CiqeJ9rz.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DdlINQc_.css">
   </head>
   <body>

package/dist/lib/index.cjs CHANGED Viewed

@@ -219,10 +219,36 @@ var MemoryManager = class {
 // server/runner/HeaderManager.ts
 var textEncoder2 = new TextEncoder();
 var HeaderManager = class {
+  // Read a header value as a single string. For multi-valued headers (string[]) returns the first.
+  // Use when callers know the header is conventionally single-valued (content-type, host, location, etc.)
+  // and need to satisfy APIs that take a string.
+  static firstValue(v) {
+    return Array.isArray(v) ? v[0] : v;
+  }
+  // Flatten a HeaderRecord to a HeaderMap (single string per key) for consumers
+  // that can't handle multi-valued headers (e.g. fetch's HeadersInit).
+  // Multi-valued entries are joined with ", " — caller must be sure this is acceptable
+  // (NOT valid for Set-Cookie; route those through a separate channel).
+  static flattenToMap(headers) {
+    const flat = {};
+    for (const [k, v] of Object.entries(headers)) {
+      if (Array.isArray(v)) {
+        flat[k] = v.join(", ");
+      } else if (v !== void 0) {
+        flat[k] = String(v);
+      }
+    }
+    return flat;
+  }
   static normalize(headers) {
     const normalized = {};
     for (const [key, value] of Object.entries(headers)) {
-      normalized[key.toLowerCase()] = String(value);
+      const k = key.toLowerCase();
+      if (Array.isArray(value)) {
+        normalized[k] = value.map(String);
+      } else {
+        normalized[k] = String(value);
+      }
     }
     return normalized;
   }
@@ -301,13 +327,31 @@ var HeaderManager = class {
   }
   // --- Tuple-based methods for multi-valued header support ---
   static recordToTuples(headers) {
-    return Object.entries(headers).map(([k, v]) => [k.toLowerCase(), String(v)]);
+    const tuples = [];
+    for (const [k, v] of Object.entries(headers)) {
+      const key = k.toLowerCase();
+      if (Array.isArray(v)) {
+        for (const val of v) tuples.push([key, String(val)]);
+      } else if (v !== void 0) {
+        tuples.push([key, String(v)]);
+      }
+    }
+    return tuples;
   }
+  // Lossless projection of tuples to a Record: single-valued keys are string,
+  // multi-valued keys are string[] — matching Node's IncomingHttpHeaders shape.
+  // Set-Cookie and other legitimately-repeatable headers are preserved across duplicates.
   static tuplesToRecord(tuples) {
     const record = {};
     for (const [key, value] of tuples) {
       const existing = record[key];
-      record[key] = existing !== void 0 ? `${existing},${value}` : value;
+      if (existing === void 0) {
+        record[key] = value;
+      } else if (Array.isArray(existing)) {
+        existing.push(value);
+      } else {
+        record[key] = [existing, value];
+      }
     }
     return record;
   }
@@ -453,10 +497,11 @@ var PropertyResolver = class {
       const url = new URL(targetUrl);
       this.requestUrl = targetUrl;
       this.requestHost = url.hostname + (url.port ? `:${url.port}` : "");
-      this.requestPath = url.pathname || "/";
+      this.requestPath = (url.pathname || "/") + url.search;
       this.requestQuery = url.search.startsWith("?") ? url.search.substring(1) : url.search;
       this.requestScheme = url.protocol.replace(":", "");
-      const pathParts = this.requestPath.split("/");
+      const pathOnly = url.pathname || "/";
+      const pathParts = pathOnly.split("/");
       const lastPart = pathParts[pathParts.length - 1];
       const dotIndex = lastPart.lastIndexOf(".");
       if (dotIndex > 0 && dotIndex < lastPart.length - 1) {
@@ -526,28 +571,28 @@ var PropertyResolver = class {
     if (path2 === "request.url")
       return this.requestUrl || `${this.requestScheme}://${this.requestHost}${this.requestPath}`;
     if (path2 === "request.host")
-      return this.requestHost || this.requestHeaders["host"] || "localhost";
+      return this.requestHost || HeaderManager.firstValue(this.requestHeaders["host"]) || "localhost";
     if (path2 === "request.scheme") return this.requestScheme;
     if (path2 === "request.protocol") return this.requestScheme;
     if (path2 === "request.query") return this.requestQuery;
     if (path2 === "request.extension") return this.requestExtension;
     if (path2 === "request.content_type") {
-      return this.requestHeaders["content-type"] || "";
+      return HeaderManager.firstValue(this.requestHeaders["content-type"]) || "";
     }
     if (path2.startsWith("request.headers.")) {
       const headerName = path2.substring("request.headers.".length).toLowerCase();
-      return this.requestHeaders[headerName] || "";
+      return HeaderManager.firstValue(this.requestHeaders[headerName]) || "";
     }
     if (path2 === "response.code") return this.responseStatus;
     if (path2 === "response.status") return this.responseStatus;
     if (path2 === "response.status_code") return this.responseStatus;
     if (path2 === "response.code_details") return this.responseStatusText;
     if (path2 === "response.content_type") {
-      return this.responseHeaders["content-type"] || "";
+      return HeaderManager.firstValue(this.responseHeaders["content-type"]) || "";
     }
     if (path2.startsWith("response.headers.")) {
       const headerName = path2.substring("response.headers.".length).toLowerCase();
-      return this.responseHeaders[headerName] || "";
+      return HeaderManager.firstValue(this.responseHeaders[headerName]) || "";
     }
     return void 0;
   }
@@ -902,7 +947,8 @@ var HostFunctions = class {
     return call;
   }
   setHttpCallResponse(tokenId, headers, body) {
-    this.httpCallResponse = { tokenId, headers, body };
+    const tuples = Array.isArray(headers) ? headers : HeaderManager.recordToTuples(headers);
+    this.httpCallResponse = { tokenId, headers: tuples, body };
   }
   clearHttpCallResponse() {
     this.httpCallResponse = null;
@@ -1332,7 +1378,7 @@ var HostFunctions = class {
       return this.responseHeaders;
     }
     if (mapType === 6 /* HttpCallResponseHeaders */ || mapType === 7 /* HttpCallResponseTrailers */) {
-      return HeaderManager.recordToTuples(this.httpCallResponse?.headers ?? {});
+      return this.httpCallResponse?.headers ?? [];
     }
     return this.requestHeaders;
   }
@@ -1992,7 +2038,7 @@ var ProxyWasmRunner = class {
       const local = this.hostFunctions.getLocalResponse();
       const responseHeaders2 = results.onRequestHeaders.output.response.headers;
       this.hostFunctions.resetLocalResponse();
-      const contentType2 = responseHeaders2["content-type"] || "text/plain";
+      const contentType2 = HeaderManager.firstValue(responseHeaders2["content-type"]) || "text/plain";
       const { body, isBase64: isBase642 } = encodeLocalResponseBody(local.body, contentType2);
       return {
         hookResults: results,
@@ -2035,7 +2081,7 @@ var ProxyWasmRunner = class {
       const local = this.hostFunctions.getLocalResponse();
       const responseHeaders2 = results.onRequestBody.output.response.headers;
       this.hostFunctions.resetLocalResponse();
-      const contentType2 = responseHeaders2["content-type"] || "text/plain";
+      const contentType2 = HeaderManager.firstValue(responseHeaders2["content-type"]) || "text/plain";
       const { body, isBase64: isBase642 } = encodeLocalResponseBody(local.body, contentType2);
       return {
         hookResults: results,
@@ -2066,7 +2112,7 @@ var ProxyWasmRunner = class {
     try {
       if (isBuiltIn) {
         this.logDebug("Using built-in responder");
-        const rawStatus = (modifiedRequestHeaders["x-debugger-status"] || "").trim();
+        const rawStatus = (HeaderManager.firstValue(modifiedRequestHeaders["x-debugger-status"]) || "").trim();
         if (rawStatus === "") {
           responseStatus = 200;
         } else {
@@ -2077,7 +2123,7 @@ var ProxyWasmRunner = class {
           }
         }
         responseStatusText = responseStatus === 200 ? "OK" : String(responseStatus);
-        const responseContentMode = modifiedRequestHeaders["x-debugger-content"] || "";
+        const responseContentMode = HeaderManager.firstValue(modifiedRequestHeaders["x-debugger-content"]) || "";
         delete modifiedRequestHeaders["x-debugger-status"];
         delete modifiedRequestHeaders["x-debugger-content"];
         if (responseContentMode === "status-only") {
@@ -2085,14 +2131,14 @@ var ProxyWasmRunner = class {
           contentType = "text/plain";
         } else if (responseContentMode === "body-only") {
           responseBody = modifiedRequestBody || "";
-          contentType = modifiedRequestHeaders["content-type"] || "text/plain";
+          contentType = HeaderManager.firstValue(modifiedRequestHeaders["content-type"]) || "text/plain";
         } else {
           contentType = "application/json";
           responseBody = JSON.stringify({
             method: requestMethod,
             reqHeaders: modifiedRequestHeaders,
             reqBody: modifiedRequestBody || "",
-            requestUrl: BUILTIN_URL
+            requestUrl: propertiesAfterRequestBody["request.url"] || BUILTIN_URL
           });
         }
         responseHeaders = {
@@ -2103,27 +2149,30 @@ var ProxyWasmRunner = class {
           `Built-in responder: ${responseStatus} ${responseStatusText}, mode=${responseContentMode || "full"}`
         );
       } else {
-        const modifiedScheme = propertiesAfterRequestBody["request.scheme"] || "https";
-        const modifiedHost = propertiesAfterRequestBody["request.host"] || "localhost";
-        const modifiedPath = propertiesAfterRequestBody["request.path"] || "/";
-        const modifiedQuery = propertiesAfterRequestBody["request.query"] || "";
-        const actualTargetUrl = `${modifiedScheme}://${modifiedHost}${modifiedPath}${modifiedQuery ? "?" + modifiedQuery : ""}`;
+        const actualTargetUrl = propertiesAfterRequestBody["request.url"] || targetUrl;
+        const actualScheme = new URL(actualTargetUrl).protocol.replace(":", "");
         this.logDebug(`Original URL: ${targetUrl}`);
-        this.logDebug(`Modified URL: ${actualTargetUrl}`);
+        this.logDebug(`Effective URL: ${actualTargetUrl}`);
         this.logDebug(`Fetching ${requestMethod} ${actualTargetUrl}`);
-        const fetchHeaders = {
-          ...modifiedRequestHeaders
-        };
+        const fetchHeaders = HeaderManager.flattenToMap(
+          modifiedRequestHeaders
+        );
+        for (const key of Object.keys(fetchHeaders)) {
+          if (key.startsWith(":")) {
+            delete fetchHeaders[key];
+          }
+        }
         const hostHeader = Object.entries(modifiedRequestHeaders).find(
           ([key]) => key.toLowerCase() === "host"
         );
         if (hostHeader) {
-          fetchHeaders["x-forwarded-host"] = hostHeader[1];
-          this.logDebug(`Adding x-forwarded-host: ${hostHeader[1]}`);
+          const hostValue = HeaderManager.firstValue(hostHeader[1]) ?? "";
+          fetchHeaders["x-forwarded-host"] = hostValue;
+          this.logDebug(`Adding x-forwarded-host: ${hostValue}`);
         }
-        fetchHeaders["x-forwarded-proto"] = modifiedScheme;
-        this.logDebug(`Adding x-forwarded-proto: ${modifiedScheme}`);
-        fetchHeaders["x-forwarded-port"] = modifiedScheme === "https" ? "443" : "80";
+        fetchHeaders["x-forwarded-proto"] = actualScheme;
+        this.logDebug(`Adding x-forwarded-proto: ${actualScheme}`);
+        fetchHeaders["x-forwarded-port"] = actualScheme === "https" ? "443" : "80";
         this.logDebug(
           `Adding x-forwarded-port: ${fetchHeaders["x-forwarded-port"]}`
         );
@@ -2143,8 +2192,14 @@ var ProxyWasmRunner = class {
         const response = await fetch(actualTargetUrl, fetchOptions);
         responseHeaders = {};
         response.headers.forEach((value, key) => {
-          responseHeaders[key] = value;
+          if (key.toLowerCase() !== "set-cookie") {
+            responseHeaders[key] = value;
+          }
         });
+        const setCookies = response.headers.getSetCookie();
+        if (setCookies.length > 0) {
+          responseHeaders["set-cookie"] = setCookies;
+        }
         contentType = response.headers.get("content-type") || "text/plain";
         responseStatus = response.status;
         responseStatusText = response.statusText;
@@ -2221,7 +2276,7 @@ var ProxyWasmRunner = class {
       const finalBody = results.onResponseBody.output.response.body;
       this.logDebug(`Final response body length: ${finalBody.length}`);
       const calculatedProperties = this.propertyResolver.getCalculatedProperties();
-      const finalContentType = finalHeaders["content-type"] || contentType;
+      const finalContentType = HeaderManager.firstValue(finalHeaders["content-type"]) || contentType;
       return {
         hookResults: results,
         finalResponse: {
@@ -2314,13 +2369,13 @@ var ProxyWasmRunner = class {
     this.hostFunctions.setLogLevel(0);
     const requestHeaders = HeaderManager.normalize(call.request.headers ?? {});
     const responseHeaders = HeaderManager.normalize(
-      call.response.headers ?? {}
+      call.response?.headers ?? {}
     );
     const requestBody = call.request.body ?? "";
-    const responseBody = call.response.body ?? "";
+    const responseBody = call.response?.body ?? "";
     const requestMethod = call.request.method ?? "GET";
-    const responseStatus = call.response.status ?? 200;
-    const responseStatusText = call.response.statusText ?? "OK";
+    const responseStatus = call.response?.status ?? 200;
+    const responseStatusText = call.response?.statusText ?? "OK";
     this.propertyResolver.setProperties({ ...call.properties ?? {} });
     this.propertyResolver.setRequestMetadata(
       requestHeaders,
@@ -2407,7 +2462,7 @@ var ProxyWasmRunner = class {
       for (const [k, v] of Object.entries(pending.headers)) {
         if (!k.startsWith(":")) fetchHeaders[k] = v;
       }
-      let responseHeaders2 = {};
+      let responseHeaders2 = [];
       let responseBody2 = new Uint8Array(0);
       try {
         const resp = await fetch(url, {
@@ -2417,20 +2472,23 @@ var ProxyWasmRunner = class {
           signal: AbortSignal.timeout(pending.timeoutMs)
         });
         resp.headers.forEach((v, k) => {
-          responseHeaders2[k] = v;
+          if (k.toLowerCase() !== "set-cookie") responseHeaders2.push([k, v]);
         });
+        for (const cookie of resp.headers.getSetCookie()) {
+          responseHeaders2.push(["set-cookie", cookie]);
+        }
         responseBody2 = new Uint8Array(await resp.arrayBuffer());
         this.logDebug(
-          `http_call response: ${resp.status} ${resp.statusText} numHeaders=${Object.keys(responseHeaders2).length} bodySize=${responseBody2.byteLength}`
+          `http_call response: ${resp.status} ${resp.statusText} numHeaders=${responseHeaders2.length} bodySize=${responseBody2.byteLength}`
         );
       } catch (err) {
         const errMsg = `http_call failed for ${url}: ${String(err)}`;
         this.logDebug(errMsg);
         this.logs.push({ level: 3, message: `[host] ${errMsg}` });
-        responseHeaders2 = {};
+        responseHeaders2 = [];
         responseBody2 = new Uint8Array(0);
       }
-      const numHeaders = Object.keys(responseHeaders2).length;
+      const numHeaders = responseHeaders2.length;
       const bodySize = responseBody2.byteLength;
       this.hostFunctions.setHttpCallResponse(pending.tokenId, responseHeaders2, responseBody2);
       this.hostFunctions.resetStreamClosed();
@@ -2532,11 +2590,18 @@ var ProxyWasmRunner = class {
     this.isInitializing = false;
   }
   buildHookInvocation(hook, requestHeaders, responseHeaders, requestBody, responseBody) {
+    const countEntries = (h) => {
+      let n = 0;
+      for (const v of Object.values(h)) {
+        n += Array.isArray(v) ? v.length : 1;
+      }
+      return n;
+    };
     switch (hook) {
       case "onRequestHeaders":
         return {
           exportName: "proxy_on_request_headers",
-          args: [this.currentContextId, Object.keys(requestHeaders).length, 0]
+          args: [this.currentContextId, countEntries(requestHeaders), 0]
         };
       case "onRequestBody":
         return {
@@ -2546,7 +2611,7 @@ var ProxyWasmRunner = class {
       case "onResponseHeaders":
         return {
           exportName: "proxy_on_response_headers",
-          args: [this.currentContextId, Object.keys(responseHeaders).length, 0]
+          args: [this.currentContextId, countEntries(responseHeaders), 0]
         };
       case "onResponseBody":
         return {
@@ -2661,9 +2726,12 @@ var ProxyWasmRunner = class {
     console.warn(entry.message);
   }
   /**
-   * Interface-compliant callFullFlow method
+   * Interface-compliant callFullFlow method.
+   *
+   * The upstream response is generated at runtime by a real HTTP fetch
+   * against `url` or by the built-in responder when `url === "built-in"`.
    */
-  async callFullFlow(url, method, headers, body, responseHeaders, responseBody, responseStatus, responseStatusText, properties, enforceProductionPropertyRules) {
+  async callFullFlow(url, method, headers, body, properties, enforceProductionPropertyRules) {
     const call = {
       hook: "",
       // Not used in fullFlow
@@ -2672,12 +2740,6 @@ var ProxyWasmRunner = class {
         body,
         method
       },
-      response: {
-        headers: responseHeaders,
-        body: responseBody,
-        status: responseStatus,
-        statusText: responseStatusText
-      },
       properties,
       enforceProductionPropertyRules
     };
@@ -2861,6 +2923,8 @@ var HttpWasmRunner = class {
     this.stateManager = null;
     this.dotenvEnabled = true;
     this.dotenvPath = null;
+    /** Pinned ports bypass PortManager allocation and must not be released back to it. */
+    this.isPinnedPort = false;
     /** @deprecated Legacy sync support — remove when #[fastedge::http] is retired */
     this.isLegacySync = false;
     this.portManager = portManager;
@@ -2887,7 +2951,19 @@ var HttpWasmRunner = class {
       this.tempWasmPath = wasmPath;
     }
     this.isLegacySync = await isLegacySyncWasm(bufferOrPath);
-    this.port = await this.portManager.allocate();
+    if (config?.httpPort !== void 0) {
+      const pinned = config.httpPort;
+      if (!await this.portManager.isPortFree(pinned)) {
+        throw new Error(
+          `fastedge-run port ${pinned} is not available \u2014 release it or choose a different httpPort in fastedge-config.test.json`
+        );
+      }
+      this.port = pinned;
+      this.isPinnedPort = true;
+    } else {
+      this.port = await this.portManager.allocate();
+      this.isPinnedPort = false;
+    }
     const wasi_http = !this.isLegacySync;
     const args = [
       "http",
@@ -2919,7 +2995,13 @@ var HttpWasmRunner = class {
     await this.waitForServerReady(this.port, timeout);
   }
   /**
-   * Execute an HTTP request through the WASM module
+   * Execute an HTTP request through the WASM module.
+   *
+   * Redirects are surfaced verbatim — `fetch` is called with
+   * `redirect: "manual"` so 3xx responses (status + `Location`) reach the
+   * caller intact. This matches FastEdge edge behaviour, which returns
+   * redirects to the client rather than following them server-side. See
+   * `IWasmRunner.execute` for the public contract.
    */
   async execute(request) {
     if (!this.port || !this.process) {
@@ -2932,8 +3014,12 @@ var HttpWasmRunner = class {
         method: request.method,
         headers: request.headers,
         body: request.body || void 0,
-        signal: AbortSignal.timeout(3e4)
+        signal: AbortSignal.timeout(3e4),
         // 30 second timeout
+        // Surface 3xx responses verbatim so tests can assert on status/Location.
+        // A FastEdge edge returns redirects to the client rather than following
+        // them server-side; production parity requires the same here.
+        redirect: "manual"
       });
       const arrayBuffer = await response.arrayBuffer();
       const bodyBuffer = Buffer.from(arrayBuffer);
@@ -2967,7 +3053,7 @@ 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, _properties, _enforceProductionPropertyRules) {
     throw new Error(
       "callFullFlow() is not supported for HTTP WASM. Use execute() instead."
     );
@@ -3024,8 +3110,11 @@ var HttpWasmRunner = class {
       this.process = null;
     }
     if (this.port !== null) {
-      this.portManager.release(this.port);
+      if (!this.isPinnedPort) {
+        this.portManager.release(this.port);
+      }
       this.port = null;
+      this.isPinnedPort = false;
     }
     if (this.tempWasmPath) {
       await removeTempWasmFile(this.tempWasmPath);
@@ -3216,17 +3305,23 @@ ${recentLogs || "(no logs)"}`
     ];
     return binaryTypes.some((type) => contentType.toLowerCase().includes(type));
   }
-  /**
-   * Parse headers from fetch Headers object
-   */
   parseHeaders(headers) {
-    const result = {};
-    headers.forEach((value, key) => {
-      result[key] = value;
-    });
-    return result;
+    return parseFetchHeaders(headers);
   }
 };
+function parseFetchHeaders(headers) {
+  const result = {};
+  headers.forEach((value, key) => {
+    if (key.toLowerCase() !== "set-cookie") {
+      result[key] = value;
+    }
+  });
+  const setCookies = headers.getSetCookie();
+  if (setCookies.length > 0) {
+    result["set-cookie"] = setCookies;
+  }
+  return result;
+}
 // server/runner/PortManager.ts
 var import_net = require("net");
@@ -3242,6 +3337,9 @@ var PortManager = class {
    * 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.
+   *
+   * Public so pinned-port callers (HttpWasmRunner with RunnerConfig.httpPort)
+   * can reuse the same OS-level check without going through allocate().
    */
   isPortFree(port) {
     return new Promise((resolve) => {

package/dist/lib/index.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export * from "./runner/index.js";