@gcoredev/fastedge-test 0.1.7 → 0.2.1

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

@@ -1,6 +1,9 @@
-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 appendMerge(left: HeaderMap | HeaderRecord, right: HeaderMap | HeaderRecord): HeaderRecord;
     static serialize(headers: HeaderMap): Uint8Array;
     /**
      * Deserializes a proxy-wasm binary header map format:
@@ -8,8 +11,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";
@@ -50,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.
@@ -111,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;

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

@@ -3,6 +3,7 @@
  *
  * Defines the common contract for both ProxyWasmRunner and HttpWasmRunner
  */
+import type { IncomingHttpHeaders } from "node:http";
 import type { IStateManager } from "./IStateManager.js";
 import type { HookCall, HookResult, FullFlowResult } from "./types.js";
 export type WasmType = "http-wasm" | "proxy-wasm";
@@ -38,12 +39,18 @@ export interface HttpRequest {
     body?: string;
 }
 /**
- * HTTP Response type for HTTP WASM runner
+ * HTTP Response type for HTTP WASM runner.
+ *
+ * `headers` uses Node's `IncomingHttpHeaders` shape — common single-valued
+ * headers (`content-type`, `location`, `etag`, …) are typed as `string`;
+ * `set-cookie` is `string[]`; unknown keys are `string | string[] | undefined`.
+ * This preserves RFC 6265 Set-Cookie semantics (each cookie kept separate)
+ * and matches consumer expectations for Node's fetch/http ecosystem.
  */
 export interface HttpResponse {
     status: number;
     statusText: string;
-    headers: Record<string, string>;
+    headers: IncomingHttpHeaders;
     body: string;
     contentType: string | null;
     isBase64?: boolean;
@@ -90,20 +97,21 @@ export interface IWasmRunner {
      */
     callHook(hookCall: HookCall): Promise<HookResult>;
     /**
-     * Execute full request/response flow (Proxy-WASM only)
-     * @param url Request URL
+     * Execute full request/response flow (Proxy-WASM only).
+     *
+     * The upstream response is generated at runtime — either by a real HTTP
+     * fetch against `url`, or by the built-in responder when
+     * `url === "built-in"`. There is no fixture-level mock response.
+     *
+     * @param url Request URL, or `"built-in"` to use the built-in responder
      * @param method HTTP method
      * @param headers Request headers
      * @param body Request body
-     * @param responseHeaders Response headers
-     * @param responseBody Response body
-     * @param responseStatus Response status code
-     * @param responseStatusText Response status text
      * @param properties Shared properties
      * @param enforceProductionPropertyRules Whether to enforce property access rules
      * @returns Full flow execution result
      */
-    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 to the current runner without reloading the WASM.
      * For ProxyWasmRunner: resets stores and re-loads dotenv files in-place.

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

@@ -1,4 +1,4 @@
-import type { HeaderMap } from "./types";
+import type { HeaderMap, HeaderRecord } from "./types";
 export declare class PropertyResolver {
     private properties;
     private requestHeaders;
@@ -28,13 +28,13 @@ export declare class PropertyResolver {
      * User properties take precedence over calculated ones
      */
     getAllProperties(): Record<string, unknown>;
-    setRequestMetadata(headers: HeaderMap, method: string, path?: string, scheme?: string): void;
+    setRequestMetadata(headers: HeaderMap | HeaderRecord, method: string, path?: string, scheme?: string): void;
     /**
      * Extract runtime properties from target URL
      * This parses the URL to populate request.url, request.host, request.path, etc.
      */
     extractRuntimePropertiesFromUrl(targetUrl: string): void;
-    setResponseMetadata(headers: HeaderMap, status: number, statusText: string): void;
+    setResponseMetadata(headers: HeaderMap | HeaderRecord, status: number, statusText: string): void;
     resolve(path: string): unknown;
     private resolveStandard;
     private resolvePathSegments;

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

@@ -59,13 +59,16 @@ export declare class ProxyWasmRunner implements IWasmRunner {
     private getHookContext;
     private logDebug;
     /**
-     * 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"`.
      */
-    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>;
     /**
      * Not supported for Proxy-WASM (HTTP WASM only)
      */
-    execute(request: HttpRequest): Promise<HttpResponse>;
+    execute(_request: HttpRequest): Promise<HttpResponse>;
     /**
      * Clean up resources (no-op for Proxy-WASM, but required by interface)
      */

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

@@ -7,7 +7,7 @@
  * Usage:
  *   import { createRunner } from './server/runner/standalone.js';
  *   const runner = await createRunner('./path/to/wasm.wasm');
- *   const result = await runner.callFullFlow('https://example.com', 'GET', {}, '', {}, '', 200, 'OK', {}, true);
+ *   const result = await runner.callFullFlow('https://example.com', 'GET', {}, '', {}, true);
  */
 import type { IWasmRunner, RunnerConfig } from "./IWasmRunner.js";
 /**

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

@@ -1,16 +1,25 @@
 export type HeaderMap = Record<string, string>;
 export type HeaderTuples = [string, string][];
+export type HeaderRecord = Record<string, string | string[]>;
 export type HookCall = {
     hook: string;
     request: {
-        headers: HeaderMap;
+        headers: HeaderRecord;
         body: string;
         method?: string;
         path?: string;
         scheme?: string;
     };
-    response: {
-        headers: HeaderMap;
+    /**
+     * Seed state for the response hooks (`onResponseHeaders` / `onResponseBody`)
+     * when calling them in isolation via `callHook()`. The full-flow path
+     * (`callFullFlow`) generates the upstream response at runtime and does not
+     * consume this field — request hooks ignore it, and response hooks are
+     * called with the response built from the live origin fetch or built-in
+     * responder output.
+     */
+    response?: {
+        headers: HeaderRecord;
         body: string;
         status?: number;
         statusText?: string;
@@ -27,22 +36,22 @@ export type HookResult = {
     }[];
     input: {
         request: {
-            headers: HeaderMap;
+            headers: HeaderRecord;
             body: string;
         };
         response: {
-            headers: HeaderMap;
+            headers: HeaderRecord;
             body: string;
         };
         properties?: Record<string, unknown>;
     };
     output: {
         request: {
-            headers: HeaderMap;
+            headers: HeaderRecord;
             body: string;
         };
         response: {
-            headers: HeaderMap;
+            headers: HeaderRecord;
             body: string;
         };
         properties?: Record<string, unknown>;
@@ -78,7 +87,7 @@ export type FullFlowResult = {
     finalResponse: {
         status: number;
         statusText: string;
-        headers: HeaderMap;
+        headers: HeaderRecord;
         body: string;
         contentType: string;
         isBase64?: boolean;

package/dist/lib/schemas/api.d.ts

@@ -16,10 +16,6 @@ export declare const ApiSendBodySchema: z.ZodObject<{
         headers: z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>>;
         body: z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodString>>>;
     }, z.core.$strip>>;
-    response: z.ZodOptional<z.ZodObject<{
-        headers: z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>>;
-        body: z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodString>>>;
-    }, z.core.$strip>>;
     properties: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
 }, z.core.$strip>;
 export declare const ApiCallBodySchema: z.ZodObject<{
@@ -79,10 +75,6 @@ export declare const ApiConfigBodySchema: z.ZodObject<{
             headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
             body: z.ZodDefault<z.ZodOptional<z.ZodString>>;
         }, z.core.$strip>;
-        response: z.ZodOptional<z.ZodObject<{
-            headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
-            body: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-        }, z.core.$strip>>;
     }, z.core.$strip>]>;
 }, z.core.$strip>;
 export type ApiLoadBody = z.infer<typeof ApiLoadBodySchema>;

package/dist/lib/schemas/config.d.ts

@@ -15,10 +15,6 @@ export declare const HttpRequestConfigSchema: z.ZodObject<{
     headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
     body: z.ZodDefault<z.ZodOptional<z.ZodString>>;
 }, z.core.$strip>;
-export declare const ResponseConfigSchema: z.ZodObject<{
-    headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
-    body: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-}, z.core.$strip>;
 declare const CdnConfigSchema: z.ZodObject<{
     $schema: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
@@ -38,10 +34,6 @@ declare const CdnConfigSchema: z.ZodObject<{
         headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
         body: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     }, z.core.$strip>;
-    response: z.ZodOptional<z.ZodObject<{
-        headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
-        body: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    }, z.core.$strip>>;
 }, z.core.$strip>;
 declare const HttpConfigSchema: z.ZodObject<{
     $schema: z.ZodOptional<z.ZodString>;
@@ -103,10 +95,6 @@ export declare const TestConfigSchema: z.ZodUnion<readonly [z.ZodObject<{
         headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
         body: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     }, z.core.$strip>;
-    response: z.ZodOptional<z.ZodObject<{
-        headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
-        body: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    }, z.core.$strip>>;
 }, z.core.$strip>]>;
 export declare const RequestConfigSchema: z.ZodObject<{
     method: z.ZodDefault<z.ZodString>;
@@ -118,7 +106,6 @@ export type WasmConfig = z.infer<typeof WasmConfigSchema>;
 export type CdnRequestConfig = z.infer<typeof CdnRequestConfigSchema>;
 export type HttpRequestConfig = z.infer<typeof HttpRequestConfigSchema>;
 export type RequestConfig = z.infer<typeof CdnRequestConfigSchema>;
-export type ResponseConfig = z.infer<typeof ResponseConfigSchema>;
 export type CdnConfig = z.infer<typeof CdnConfigSchema>;
 export type HttpConfig = z.infer<typeof HttpConfigSchema>;
 export type TestConfig = z.infer<typeof TestConfigSchema>;

package/dist/lib/schemas/index.d.ts

@@ -1,4 +1,4 @@
-export { WasmConfigSchema, RequestConfigSchema, ResponseConfigSchema, TestConfigSchema, } from './config';
-export type { WasmConfig, RequestConfig, ResponseConfig, TestConfig, } from './config';
+export { WasmConfigSchema, RequestConfigSchema, TestConfigSchema, } from './config';
+export type { WasmConfig, RequestConfig, TestConfig, } from './config';
 export { ApiLoadBodySchema, ApiSendBodySchema, ApiCallBodySchema, ApiConfigBodySchema, } from './api';
 export type { ApiLoadBody, ApiSendBody, ApiCallBody, ApiConfigBody, } from './api';

package/dist/lib/test-framework/assertions.d.ts

@@ -9,8 +9,12 @@ import type { HttpResponse } from "../runner/IWasmRunner.js";
 /**
  * Assert that a named header exists (and optionally matches a value)
  * in the hook's output request headers.
+ *
+ * When `expected` is a string and the header is multi-valued, passes if
+ * any value matches (`.includes()` semantics). When `expected` is a string[],
+ * requires an exact array match.
  */
-export declare function assertRequestHeader(result: HookResult, name: string, expected?: string): void;
+export declare function assertRequestHeader(result: HookResult, name: string, expected?: string | string[]): void;
 /**
  * Assert that a named header is absent in the hook's output request headers.
  */
@@ -18,8 +22,12 @@ export declare function assertNoRequestHeader(result: HookResult, name: string):
 /**
  * Assert that a named header exists (and optionally matches a value)
  * in the hook's output response headers.
+ *
+ * When `expected` is a string and the header is multi-valued (e.g. set-cookie),
+ * passes if any value matches (`.includes()` semantics). When `expected` is a
+ * string[], requires an exact array match.
  */
-export declare function assertResponseHeader(result: HookResult, name: string, expected?: string): void;
+export declare function assertResponseHeader(result: HookResult, name: string, expected?: string | string[]): void;
 /**
  * Assert that a named header is absent in the hook's output response headers.
  */
@@ -31,8 +39,10 @@ export declare function assertFinalStatus(result: FullFlowResult, expected: numb
 /**
  * Assert that a named header exists (and optionally matches a value)
  * in the final response headers from a full-flow run.
+ *
+ * Multi-value semantics match {@link assertResponseHeader}.
  */
-export declare function assertFinalHeader(result: FullFlowResult, name: string, expected?: string): void;
+export declare function assertFinalHeader(result: FullFlowResult, name: string, expected?: string | string[]): void;
 /**
  * Assert the hook return code (e.g. 0 = Ok, 1 = Pause).
  */
@@ -68,8 +78,12 @@ export declare function assertHttpStatus(response: HttpResponse, expected: numbe
 /**
  * Assert that a named header exists (and optionally matches a value)
  * in the HTTP response.
+ *
+ * Multi-value semantics: when `expected` is a string and the header is
+ * multi-valued (e.g. set-cookie is `string[]` per RFC 6265), passes if any
+ * value matches. When `expected` is a string[], requires exact array match.
  */
-export declare function assertHttpHeader(response: HttpResponse, name: string, expected?: string): void;
+export declare function assertHttpHeader(response: HttpResponse, name: string, expected?: string | string[]): void;
 /**
  * Assert that a named header is absent in the HTTP response.
  */