@gcoredev/fastedge-test 0.1.6 → 0.2.0

package/dist/lib/index.js

@@ -175,10 +175,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;
   }
@@ -257,13 +283,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;
   }
@@ -409,10 +453,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) {
@@ -482,28 +527,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;
   }
@@ -858,7 +903,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;
@@ -1288,7 +1334,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;
   }
@@ -1948,7 +1994,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,
@@ -1991,7 +2037,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,
@@ -2022,7 +2068,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 {
@@ -2033,7 +2079,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") {
@@ -2041,14 +2087,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 = {
@@ -2059,27 +2105,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"]}`
         );
@@ -2099,8 +2148,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;
@@ -2177,7 +2232,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: {
@@ -2270,13 +2325,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,
@@ -2363,7 +2418,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, {
@@ -2373,20 +2428,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();
@@ -2488,11 +2546,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 {
@@ -2502,7 +2567,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 {
@@ -2617,9 +2682,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
@@ -2628,12 +2696,6 @@ var ProxyWasmRunner = class {
         body,
         method
       },
-      response: {
-        headers: responseHeaders,
-        body: responseBody,
-        status: responseStatus,
-        statusText: responseStatusText
-      },
       properties,
       enforceProductionPropertyRules
     };
@@ -2817,6 +2879,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;
@@ -2843,7 +2907,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",
@@ -2875,7 +2951,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) {
@@ -2888,8 +2970,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);
@@ -2923,7 +3009,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."
     );
@@ -2980,8 +3066,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);
@@ -3172,17 +3261,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
 import { createServer } from "net";
@@ -3198,6 +3293,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/runner/HeaderManager.d.ts

@@ -1,6 +1,8 @@
-import type { HeaderMap, HeaderTuples } from "./types";
+import type { HeaderMap, HeaderRecord, HeaderTuples } from "./types";
 export declare class HeaderManager {
-    static normalize(headers: HeaderMap): HeaderMap;
+    static firstValue(v: string | string[] | undefined): string | undefined;
+    static flattenToMap(headers: HeaderMap | HeaderRecord): HeaderMap;
+    static normalize(headers: HeaderMap | HeaderRecord): HeaderRecord;
     static serialize(headers: HeaderMap): Uint8Array;
     /**
      * Deserializes a proxy-wasm binary header map format:
@@ -8,8 +10,8 @@ export declare class HeaderManager {
      */
     static deserializeBinary(bytes: Uint8Array): HeaderMap;
     static deserialize(payload: string): HeaderMap;
-    static recordToTuples(headers: HeaderMap): HeaderTuples;
-    static tuplesToRecord(tuples: HeaderTuples): HeaderMap;
+    static recordToTuples(headers: HeaderMap | HeaderRecord): HeaderTuples;
+    static tuplesToRecord(tuples: HeaderTuples): HeaderRecord;
     static normalizeTuples(tuples: HeaderTuples): HeaderTuples;
     static serializeTuples(tuples: HeaderTuples): Uint8Array;
     static deserializeBinaryToTuples(bytes: Uint8Array): HeaderTuples;

package/dist/lib/runner/HostFunctions.d.ts

@@ -1,4 +1,4 @@
-import type { HeaderMap, LogEntry } from "./types";
+import type { HeaderMap, HeaderRecord, HeaderTuples, LogEntry } from "./types";
 import { MemoryManager } from "./MemoryManager";
 import { PropertyResolver } from "./PropertyResolver";
 import { PropertyAccessControl, HookContext } from "./PropertyAccessControl";
@@ -36,7 +36,7 @@ export declare class HostFunctions {
     private dictionary;
     constructor(memory: MemoryManager, propertyResolver: PropertyResolver, propertyAccessControl: PropertyAccessControl, getCurrentHook: () => HookContext | null, debug?: boolean, secretStore?: SecretStore, dictionary?: Dictionary);
     setLogs(logs: LogEntry[]): void;
-    setHeadersAndBodies(reqHeaders: HeaderMap, resHeaders: HeaderMap, reqBody: string, resBody: string): void;
+    setHeadersAndBodies(reqHeaders: HeaderMap | HeaderRecord, resHeaders: HeaderMap | HeaderRecord, reqBody: string, resBody: string): void;
     setConfigs(vmConfig: string, pluginConfig: string): void;
     setCurrentContext(contextId: number): void;
     getCurrentLogLevel(): number;
@@ -50,7 +50,7 @@ export declare class HostFunctions {
         body: Uint8Array | null;
         timeoutMs: number;
     } | null;
-    setHttpCallResponse(tokenId: number, headers: HeaderMap, body: Uint8Array): void;
+    setHttpCallResponse(tokenId: number, headers: HeaderMap | HeaderRecord | HeaderTuples, body: Uint8Array): void;
     clearHttpCallResponse(): void;
     isStreamClosed(): boolean;
     resetStreamClosed(): void;
@@ -61,8 +61,8 @@ export declare class HostFunctions {
         body: Uint8Array;
     } | null;
     resetLocalResponse(): void;
-    getRequestHeaders(): HeaderMap;
-    getResponseHeaders(): HeaderMap;
+    getRequestHeaders(): HeaderRecord;
+    getResponseHeaders(): HeaderRecord;
     getRequestBody(): string;
     getResponseBody(): string;
     getSecretStore(): SecretStore;

package/dist/lib/runner/HttpWasmRunner.d.ts

@@ -4,6 +4,7 @@
  * Executes HTTP WASM binaries (component model with wasi-http interface)
  * using the FastEdge-run CLI as a process-based runner.
  */
+import type { IncomingHttpHeaders } from "node:http";
 import type { IWasmRunner, WasmType, RunnerConfig, HttpRequest, HttpResponse } from "./IWasmRunner.js";
 import type { HookCall, HookResult, FullFlowResult } from "./types.js";
 import type { IStateManager } from "./IStateManager.js";
@@ -24,6 +25,8 @@ export declare class HttpWasmRunner implements IWasmRunner {
     private portManager;
     private dotenvEnabled;
     private dotenvPath;
+    /** Pinned ports bypass PortManager allocation and must not be released back to it. */
+    private isPinnedPort;
     /** @deprecated Legacy sync support — remove when #[fastedge::http] is retired */
     private isLegacySync;
     constructor(portManager: PortManager, dotenvEnabled?: boolean);
@@ -32,7 +35,13 @@ export declare class HttpWasmRunner implements IWasmRunner {
      */
     load(bufferOrPath: Buffer | string, config?: RunnerConfig): Promise<void>;
     /**
-     * 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.
      */
     execute(request: HttpRequest): Promise<HttpResponse>;
     /**
@@ -42,7 +51,7 @@ export declare class HttpWasmRunner implements IWasmRunner {
     /**
      * Not supported for HTTP WASM (proxy-wasm only)
      */
-    callFullFlow(_url: string, _method: string, _headers: Record<string, string>, _body: string, _responseHeaders: Record<string, string>, _responseBody: string, _responseStatus: number, _responseStatusText: string, _properties: Record<string, unknown>, _enforceProductionPropertyRules: boolean): Promise<FullFlowResult>;
+    callFullFlow(_url: string, _method: string, _headers: Record<string, string>, _body: string, _properties: Record<string, unknown>, _enforceProductionPropertyRules: boolean): Promise<FullFlowResult>;
     /**
      * Apply dotenv settings by restarting the fastedge-run process.
      * The WASM file is not re-read; only the --dotenv flag changes.
@@ -103,8 +112,16 @@ export declare class HttpWasmRunner implements IWasmRunner {
      * Check if content type is binary
      */
     private isBinaryContentType;
-    /**
-     * Parse headers from fetch Headers object
-     */
     private parseHeaders;
 }
+/**
+ * Parse a fetch Headers object into an IncomingHttpHeaders-shaped record.
+ *
+ * Uses `Headers.getSetCookie()` (Node 19.7+, always available on Node ≥22.12)
+ * to preserve multiple Set-Cookie entries as a string[] — RFC 6265 §3 exempts
+ * Set-Cookie from the "combine duplicates with commas" rule, and real browsers
+ * process each Set-Cookie independently.
+ *
+ * Exported for unit testing; in production use it via HttpWasmRunner.
+ */
+export declare function parseFetchHeaders(headers: Headers): IncomingHttpHeaders;

package/dist/lib/runner/IStateManager.d.ts

@@ -7,30 +7,30 @@
  */
 export type EventSource = "ui" | "ai_agent" | "api" | "system";
 export interface IStateManager {
-    emitRequestStarted(url: string, method: string, headers: Record<string, string>, source?: EventSource): void;
+    emitRequestStarted(url: string, method: string, headers: Record<string, string | string[]>, source?: EventSource): void;
     emitHookExecuted(hook: string, returnCode: number | null, logCount: number, input: {
         request: {
-            headers: Record<string, string>;
+            headers: Record<string, string | string[]>;
             body: string;
         };
         response: {
-            headers: Record<string, string>;
+            headers: Record<string, string | string[]>;
             body: string;
         };
     }, output: {
         request: {
-            headers: Record<string, string>;
+            headers: Record<string, string | string[]>;
             body: string;
         };
         response: {
-            headers: Record<string, string>;
+            headers: Record<string, string | string[]>;
             body: string;
         };
     }, source?: EventSource): void;
     emitRequestCompleted(hookResults: Record<string, unknown>, finalResponse: {
         status: number;
         statusText: string;
-        headers: Record<string, string>;
+        headers: Record<string, string | string[]>;
         body: string;
         contentType: string;
         isBase64?: boolean;
@@ -41,7 +41,7 @@ export interface IStateManager {
     emitHttpWasmRequestCompleted(response: {
         status: number;
         statusText: string;
-        headers: Record<string, string>;
+        headers: Record<string, string | string[] | undefined>;
         body: string;
         contentType: string | null;
         isBase64?: boolean;