@gcoredev/fastedge-test 0.1.7 → 0.2.1

package/dist/lib/index.cjs

@@ -49,13 +49,11 @@ var import_node_wasi = require("node:wasi");
 var textEncoder = new TextEncoder();
 var textDecoder = new TextDecoder();
 var MemoryManager = class {
-  constructor() {
-    this.memory = null;
-    this.instance = null;
-    this.hostAllocOffset = 0;
-    this.logCallback = null;
-    this.isInitializing = false;
-  }
+  memory = null;
+  instance = null;
+  hostAllocOffset = 0;
+  logCallback = null;
+  isInitializing = false;
   setMemory(memory) {
     this.memory = memory;
   }
@@ -218,14 +216,64 @@ var MemoryManager = class {
 
 // server/runner/HeaderManager.ts
 var textEncoder2 = new TextEncoder();
-var HeaderManager = class {
+var HeaderManager = class _HeaderManager {
+  // 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 = {};
+    const normalized = /* @__PURE__ */ Object.create(null);
     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;
   }
+  // Append-merge two header records: for keys present in both, values are
+  // concatenated into a string[] rather than the right-hand side overwriting
+  // the left. Keys are lowercased on the way in (consistent with `normalize`).
+  //
+  // Used by the runner to combine request-phase response-header state with
+  // the origin's response headers, mirroring how Envoy serves
+  // `add_http_response_header` calls issued during onRequestHeaders /
+  // onRequestBody against the actual upstream response — both values survive
+  // as a multi-value list (preserving the proxy-wasm cross-phase pattern).
+  static appendMerge(left, right) {
+    const result = _HeaderManager.normalize(left);
+    for (const [key, value] of Object.entries(right)) {
+      const k = key.toLowerCase();
+      const incoming = Array.isArray(value) ? value.map(String) : [String(value)];
+      if (Object.hasOwn(result, k)) {
+        const existing = result[k];
+        const existingArr = Array.isArray(existing) ? existing : [existing];
+        result[k] = [...existingArr, ...incoming];
+      } else {
+        result[k] = incoming.length === 1 ? incoming[0] : incoming;
+      }
+    }
+    return result;
+  }
   static serialize(headers) {
     const pairs = Object.entries(headers);
     const numPairs = pairs.length;
@@ -301,13 +349,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;
   }
@@ -386,20 +452,18 @@ var HeaderManager = class {
 
 // server/runner/PropertyResolver.ts
 var PropertyResolver = class {
-  constructor() {
-    this.properties = {};
-    this.requestHeaders = {};
-    this.requestMethod = "GET";
-    this.requestPath = "/";
-    this.requestScheme = "https";
-    this.requestUrl = "";
-    this.requestHost = "";
-    this.requestQuery = "";
-    this.requestExtension = "";
-    this.responseHeaders = {};
-    this.responseStatus = 200;
-    this.responseStatusText = "OK";
-  }
+  properties = {};
+  requestHeaders = {};
+  requestMethod = "GET";
+  requestPath = "/";
+  requestScheme = "https";
+  requestUrl = "";
+  requestHost = "";
+  requestQuery = "";
+  requestExtension = "";
+  responseHeaders = {};
+  responseStatus = 200;
+  responseStatusText = "OK";
   setProperties(properties) {
     this.properties = properties;
   }
@@ -453,10 +517,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 +591,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;
   }
@@ -590,6 +655,7 @@ var PropertyResolver = class {
 
 // server/fastedge-host/SecretStore.ts
 var SecretStore = class {
+  secrets;
   constructor(initialSecrets) {
     this.secrets = /* @__PURE__ */ new Map();
     if (initialSecrets) {
@@ -672,6 +738,7 @@ var SecretStore = class {
 
 // server/fastedge-host/Dictionary.ts
 var Dictionary = class {
+  data;
   constructor(initialData) {
     this.data = /* @__PURE__ */ new Map();
     if (initialData) {
@@ -839,26 +906,33 @@ function createFastEdgeHostFunctions(memory, secretStore, dictionary, logDebug)
 // server/runner/HostFunctions.ts
 var textEncoder3 = new TextEncoder();
 var HostFunctions = class {
+  memory;
+  propertyResolver;
+  propertyAccessControl;
+  getCurrentHook;
+  logs = [];
+  requestHeaders = [];
+  responseHeaders = [];
+  requestBody = "";
+  responseBody = "";
+  vmConfig = "";
+  pluginConfig = "";
+  currentContextId = 1;
+  lastHostCall = null;
+  debug = false;
+  currentLogLevel = 0 /* Trace */;
+  // Default to show all logs
+  // http_call state
+  nextTokenId = 0;
+  pendingHttpCall = null;
+  httpCallResponse = null;
+  streamClosed = false;
+  // Local response state (from proxy_send_local_response / send_http_response)
+  localResponse = null;
+  // FastEdge extensions
+  secretStore;
+  dictionary;
   constructor(memory, propertyResolver, propertyAccessControl, getCurrentHook, debug = false, secretStore, dictionary) {
-    this.logs = [];
-    this.requestHeaders = [];
-    this.responseHeaders = [];
-    this.requestBody = "";
-    this.responseBody = "";
-    this.vmConfig = "";
-    this.pluginConfig = "";
-    this.currentContextId = 1;
-    this.lastHostCall = null;
-    this.debug = false;
-    this.currentLogLevel = 0 /* Trace */;
-    // Default to show all logs
-    // http_call state
-    this.nextTokenId = 0;
-    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;
@@ -902,7 +976,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 +1407,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;
   }
@@ -1588,6 +1663,8 @@ var BUILT_IN_PROPERTIES = [
   }
 ];
 var PropertyAccessControl = class {
+  builtInProperties;
+  customProperties;
   constructor() {
     this.builtInProperties = /* @__PURE__ */ new Map();
     this.customProperties = /* @__PURE__ */ new Map();
@@ -1805,21 +1882,28 @@ var textEncoder4 = new TextEncoder();
 var BUILTIN_URL = "http://fastedge-builtin.debug";
 var BUILTIN_SHORTHAND = "built-in";
 var ProxyWasmRunner = class {
+  module = null;
+  // Compiled module (reused)
+  instance = null;
+  // Current instance (transient per hook)
+  memory;
+  propertyResolver;
+  propertyAccessControl;
+  currentHook = null;
+  hostFunctions;
+  logs = [];
+  rootContextId = 1;
+  nextContextId = 2;
+  currentContextId = 1;
+  isInitializing = false;
+  debug = process.env.PROXY_RUNNER_DEBUG === "1";
+  stateManager = null;
+  secretStore;
+  dictionary;
+  dotenvEnabled = true;
+  // Default to enabled
+  dotenvPath = ".";
   constructor(fastEdgeConfig, dotenvEnabled = true) {
-    this.module = null;
-    // Compiled module (reused)
-    this.instance = null;
-    this.currentHook = null;
-    this.logs = [];
-    this.rootContextId = 1;
-    this.nextContextId = 2;
-    this.currentContextId = 1;
-    this.isInitializing = false;
-    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();
@@ -1992,7 +2076,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 +2119,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 +2150,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 +2161,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 +2169,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 +2187,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 +2230,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;
@@ -2163,6 +2256,14 @@ var ProxyWasmRunner = class {
           `Fetch completed: ${responseStatus} ${responseStatusText}`
         );
       }
+      const requestPhaseResponseHeaders = {
+        ...results.onRequestHeaders.output.response.headers ?? {},
+        ...results.onRequestBody.output.response.headers ?? {}
+      };
+      const mergedResponseHeaders = HeaderManager.appendMerge(
+        requestPhaseResponseHeaders,
+        responseHeaders
+      );
       const responseCall = {
         ...call,
         request: {
@@ -2171,7 +2272,7 @@ var ProxyWasmRunner = class {
           body: modifiedRequestBody
         },
         response: {
-          headers: responseHeaders,
+          headers: mergedResponseHeaders,
           body: responseBody,
           status: responseStatus,
           statusText: responseStatusText
@@ -2193,6 +2294,25 @@ var ProxyWasmRunner = class {
           "system"
         );
       }
+      if (results.onResponseHeaders.returnCode === 1 && this.hostFunctions.hasLocalResponse()) {
+        const local = this.hostFunctions.getLocalResponse();
+        const headers = results.onResponseHeaders.output.response.headers;
+        this.hostFunctions.resetLocalResponse();
+        const contentType2 = HeaderManager.firstValue(headers["content-type"]) || "text/plain";
+        const { body, isBase64: isBase642 } = encodeLocalResponseBody(local.body, contentType2);
+        return {
+          hookResults: results,
+          finalResponse: {
+            status: local.statusCode,
+            statusText: local.statusText,
+            headers,
+            body,
+            contentType: contentType2,
+            isBase64: isBase642
+          },
+          calculatedProperties: this.propertyResolver.getCalculatedProperties()
+        };
+      }
       const headersAfterResponseHeaders = results.onResponseHeaders.output.response.headers;
       const propertiesAfterResponseHeaders = results.onResponseHeaders.properties;
       this.logDebug(
@@ -2217,11 +2337,30 @@ var ProxyWasmRunner = class {
           "system"
         );
       }
+      if (results.onResponseBody.returnCode === 1 && this.hostFunctions.hasLocalResponse()) {
+        const local = this.hostFunctions.getLocalResponse();
+        const headers = results.onResponseBody.output.response.headers;
+        this.hostFunctions.resetLocalResponse();
+        const contentType2 = HeaderManager.firstValue(headers["content-type"]) || "text/plain";
+        const { body, isBase64: isBase642 } = encodeLocalResponseBody(local.body, contentType2);
+        return {
+          hookResults: results,
+          finalResponse: {
+            status: local.statusCode,
+            statusText: local.statusText,
+            headers,
+            body,
+            contentType: contentType2,
+            isBase64: isBase642
+          },
+          calculatedProperties: this.propertyResolver.getCalculatedProperties()
+        };
+      }
       const finalHeaders = results.onResponseBody.output.response.headers;
       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 +2453,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 +2546,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 +2556,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 +2674,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 +2695,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 +2810,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 +2824,6 @@ var ProxyWasmRunner = class {
         body,
         method
       },
-      response: {
-        headers: responseHeaders,
-        body: responseBody,
-        status: responseStatus,
-        statusText: responseStatusText
-      },
       properties,
       enforceProductionPropertyRules
     };
@@ -2686,7 +2832,7 @@ var ProxyWasmRunner = class {
   /**
    * Not supported for Proxy-WASM (HTTP WASM only)
    */
-  async execute(request) {
+  async execute(_request) {
     throw new Error(
       "execute() is not supported for Proxy-WASM. Use callHook() or callFullFlow() instead."
     );
@@ -2850,21 +2996,22 @@ async function isLegacySyncWasm(bufferOrPath) {
 
 // server/runner/HttpWasmRunner.ts
 var HttpWasmRunner = class {
+  process = null;
+  port = null;
+  cliPath = null;
+  tempWasmPath = null;
+  currentWasmPath = null;
+  // resolved path used when spawning
+  logs = [];
+  stateManager = null;
+  portManager;
+  dotenvEnabled = true;
+  dotenvPath = null;
+  /** Pinned ports bypass PortManager allocation and must not be released back to it. */
+  isPinnedPort = false;
+  /** @deprecated Legacy sync support — remove when #[fastedge::http] is retired */
+  isLegacySync = false;
   constructor(portManager, dotenvEnabled = true) {
-    this.process = null;
-    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;
-    /** 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;
     this.dotenvEnabled = dotenvEnabled;
   }
@@ -2991,7 +3138,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."
     );
@@ -3243,27 +3390,31 @@ ${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");
 var PortManager = class {
-  constructor() {
-    this.minPort = 8100;
-    this.maxPort = 8199;
-    this.allocatedPorts = /* @__PURE__ */ new Set();
-    this.lastAllocatedPort = this.minPort - 1;
-  }
+  minPort = 8100;
+  maxPort = 8199;
+  allocatedPorts = /* @__PURE__ */ new Set();
+  lastAllocatedPort = this.minPort - 1;
   /**
    * Check whether a port is actually free at the OS level.
    * This is necessary when multiple server processes run simultaneously —
@@ -3323,6 +3474,7 @@ var PortManager = class {
 
 // server/runner/WasmRunnerFactory.ts
 var WasmRunnerFactory = class {
+  portManager;
   constructor() {
     this.portManager = new PortManager();
   }