@jaypie/express 1.2.4-rc9 → 1.2.5

package/dist/cjs/index.cjs

@@ -5,8 +5,8 @@ var node_http = require('node:http');
 var errors = require('@jaypie/errors');
 var kit = require('@jaypie/kit');
 var expressCors = require('cors');
-var logger$2 = require('@jaypie/logger');
 var aws = require('@jaypie/aws');
+var logger$2 = require('@jaypie/logger');
 var datadog = require('@jaypie/datadog');
 
 //
@@ -34,6 +34,17 @@ class LambdaRequest extends node_stream.Readable {
         this.path = options.url.split("?")[0];
         this.headers = this.normalizeHeaders(options.headers);
         this.bodyBuffer = options.body ?? null;
+        // Use pre-parsed query if provided, otherwise parse from URL
+        if (options.query) {
+            this.query = options.query;
+        }
+        else {
+            const queryIndex = options.url.indexOf("?");
+            if (queryIndex !== -1) {
+                const queryString = options.url.slice(queryIndex + 1);
+                this.query = parseQueryString(queryString);
+            }
+        }
         // Store Lambda context
         this._lambdaContext = options.lambdaContext;
         this._lambdaEvent = options.lambdaEvent;
@@ -44,6 +55,18 @@ class LambdaRequest extends node_stream.Readable {
             remoteAddress: options.remoteAddress,
         };
         this.connection = this.socket;
+        // Schedule body push for next tick to ensure stream is ready
+        // This is needed for body parsers that consume the stream
+        if (this.bodyBuffer && this.bodyBuffer.length > 0) {
+            process.nextTick(() => {
+                if (!this.bodyPushed) {
+                    this.push(this.bodyBuffer);
+                    this.push(null);
+                    this.bodyPushed = true;
+                    this.complete = true;
+                }
+            });
+        }
     }
     //
     // Readable stream implementation
@@ -82,6 +105,66 @@ class LambdaRequest extends node_stream.Readable {
 }
 //
 //
+// Helper Functions
+//
+/**
+ * Normalize bracket notation in query parameter key.
+ * Removes trailing `[]` from keys (e.g., `filterByStatus[]` → `filterByStatus`).
+ */
+function normalizeQueryKey(key) {
+    return key.endsWith("[]") ? key.slice(0, -2) : key;
+}
+/**
+ * Parse a query string into a record with proper array handling.
+ * Handles bracket notation (e.g., `param[]`) and multi-value parameters.
+ */
+function parseQueryString(queryString) {
+    const result = {};
+    const params = new URLSearchParams(queryString);
+    for (const [rawKey, value] of params) {
+        const key = normalizeQueryKey(rawKey);
+        const existing = result[key];
+        if (existing === undefined) {
+            // First occurrence - check if it's bracket notation to determine if it should be an array
+            result[key] = rawKey.endsWith("[]") ? [value] : value;
+        }
+        else if (Array.isArray(existing)) {
+            existing.push(value);
+        }
+        else {
+            // Convert to array when we encounter a second value
+            result[key] = [existing, value];
+        }
+    }
+    return result;
+}
+/**
+ * Build query object from API Gateway v1 multiValueQueryStringParameters.
+ * Normalizes bracket notation and preserves array values.
+ */
+function buildQueryFromMultiValue(multiValueParams) {
+    const result = {};
+    if (!multiValueParams)
+        return result;
+    for (const [rawKey, values] of Object.entries(multiValueParams)) {
+        const key = normalizeQueryKey(rawKey);
+        const existingValues = result[key];
+        if (existingValues === undefined) {
+            // First occurrence - use array if multiple values or bracket notation
+            result[key] = values.length === 1 && !rawKey.endsWith("[]") ? values[0] : values;
+        }
+        else if (Array.isArray(existingValues)) {
+            existingValues.push(...values);
+        }
+        else {
+            // Convert to array and merge
+            result[key] = [existingValues, ...values];
+        }
+    }
+    return result;
+}
+//
+//
 // Type Guards
 //
 /**
@@ -107,6 +190,7 @@ function createLambdaRequest(event, context) {
     let url;
     let method;
     let protocol;
+    let query;
     let remoteAddress;
     const headers = { ...event.headers };
     if (isFunctionUrlEvent(event)) {
@@ -117,6 +201,10 @@ function createLambdaRequest(event, context) {
         method = event.requestContext.http.method;
         protocol = event.requestContext.http.protocol.split("/")[0].toLowerCase();
         remoteAddress = event.requestContext.http.sourceIp;
+        // Parse query string with proper multi-value and bracket notation support
+        if (event.rawQueryString) {
+            query = parseQueryString(event.rawQueryString);
+        }
         // Normalize cookies into Cookie header if not already present
         if (event.cookies && event.cookies.length > 0 && !headers.cookie) {
             headers.cookie = event.cookies.join("; ");
@@ -124,7 +212,13 @@ function createLambdaRequest(event, context) {
     }
     else if (isApiGatewayV1Event(event)) {
         // API Gateway REST API v1 format
+        // Use multiValueQueryStringParameters for proper array support
+        const multiValueParams = event.multiValueQueryStringParameters;
         const queryParams = event.queryStringParameters;
+        if (multiValueParams && Object.keys(multiValueParams).length > 0) {
+            query = buildQueryFromMultiValue(multiValueParams);
+        }
+        // Build URL with query string
         if (queryParams && Object.keys(queryParams).length > 0) {
             const queryString = new URLSearchParams(queryParams).toString();
             url = `${event.path}?${queryString}`;
@@ -145,6 +239,11 @@ function createLambdaRequest(event, context) {
         body = event.isBase64Encoded
             ? Buffer.from(event.body, "base64")
             : Buffer.from(event.body, "utf8");
+        // Add content-length header if not present (required for body parsers)
+        const hasContentLength = Object.keys(headers).some((k) => k.toLowerCase() === "content-length");
+        if (!hasContentLength) {
+            headers["content-length"] = String(body.length);
+        }
     }
     return new LambdaRequest({
         body,
@@ -153,6 +252,7 @@ function createLambdaRequest(event, context) {
         lambdaEvent: event,
         method,
         protocol,
+        query,
         remoteAddress,
         url,
     });
@@ -162,6 +262,9 @@ function createLambdaRequest(event, context) {
 //
 // Constants
 //
+// Symbol to identify Lambda mock responses. Uses Symbol.for() to ensure
+// the same symbol is used across bundles/realms. Survives prototype manipulation.
+const JAYPIE_LAMBDA_MOCK = Symbol.for("@jaypie/express/LambdaMock");
 // Get Node's internal kOutHeaders symbol from ServerResponse prototype.
 // This is needed for compatibility with Datadog dd-trace instrumentation,
 // which patches HTTP methods and expects this internal state to exist.
@@ -195,21 +298,87 @@ class LambdaResponseBuffered extends node_stream.Writable {
         // Internal state exposed for direct manipulation by safe response methods
         // that need to bypass dd-trace interception of stream methods
         this._chunks = [];
+        this._ended = false; // Track ended state since writableEnded is lost after prototype change
         this._headers = new Map();
         this._headersSent = false;
         this._resolve = null;
+        // Mark as Lambda mock response for identification in expressHandler
+        this[JAYPIE_LAMBDA_MOCK] = true;
         // Initialize Node's internal kOutHeaders for dd-trace compatibility.
         // dd-trace patches HTTP methods and expects this internal state.
         if (kOutHeaders$1) {
             this[kOutHeaders$1] = Object.create(null);
         }
+        // CRITICAL: Define key methods as instance properties to survive Express's
+        // setPrototypeOf(res, app.response) in middleware/init.js which would
+        // otherwise replace our prototype with ServerResponse.prototype.
+        // Instance properties take precedence over prototype properties.
+        this.getHeader = this.getHeader.bind(this);
+        this.setHeader = this.setHeader.bind(this);
+        this.removeHeader = this.removeHeader.bind(this);
+        this.hasHeader = this.hasHeader.bind(this);
+        this.getHeaders = this.getHeaders.bind(this);
+        this.getHeaderNames = this.getHeaderNames.bind(this);
+        this.writeHead = this.writeHead.bind(this);
+        this.get = this.get.bind(this);
+        this.set = this.set.bind(this);
+        this.status = this.status.bind(this);
+        this.json = this.json.bind(this);
+        this.send = this.send.bind(this);
+        this.vary = this.vary.bind(this);
+        this.end = this.end.bind(this);
+        this.write = this.write.bind(this);
+        // Also bind internal Writable methods that are called via prototype chain
+        this._write = this._write.bind(this);
+        this._final = this._final.bind(this);
+        // Bind result-building methods
+        this.getResult = this.getResult.bind(this);
+        this.buildResult = this.buildResult.bind(this);
+        this.isBinaryContentType = this.isBinaryContentType.bind(this);
+    }
+    //
+    // Internal bypass methods - completely avoid prototype chain lookup
+    // These directly access _headers Map, safe from dd-trace interception
+    //
+    _internalGetHeader(name) {
+        const value = this._headers.get(name.toLowerCase());
+        return value ? String(value) : undefined;
+    }
+    _internalSetHeader(name, value) {
+        if (!this._headersSent) {
+            const lowerName = name.toLowerCase();
+            this._headers.set(lowerName, value);
+            // Also sync kOutHeaders for any code that expects it
+            if (kOutHeaders$1) {
+                const outHeaders = this[kOutHeaders$1];
+                if (outHeaders) {
+                    outHeaders[lowerName] = [name, value];
+                }
+            }
+        }
+    }
+    _internalHasHeader(name) {
+        return this._headers.has(name.toLowerCase());
+    }
+    _internalRemoveHeader(name) {
+        if (!this._headersSent) {
+            const lowerName = name.toLowerCase();
+            this._headers.delete(lowerName);
+            if (kOutHeaders$1) {
+                const outHeaders = this[kOutHeaders$1];
+                if (outHeaders) {
+                    delete outHeaders[lowerName];
+                }
+            }
+        }
     }
     //
     // Promise-based API for getting final result
     //
     getResult() {
         return new Promise((resolve) => {
-            if (this.writableEnded) {
+            // Use _ended instead of writableEnded since Express's setPrototypeOf breaks the getter
+            if (this._ended) {
                 resolve(this.buildResult());
             }
             else {
@@ -267,36 +436,40 @@ class LambdaResponseBuffered extends node_stream.Writable {
     /**
      * Proxy for direct header access (e.g., res.headers['content-type']).
      * Required for compatibility with middleware like helmet that access headers directly.
+     * Uses direct _headers access to bypass dd-trace interception.
      */
     get headers() {
         return new Proxy({}, {
             deleteProperty: (_target, prop) => {
-                this.removeHeader(String(prop));
+                this._headers.delete(String(prop).toLowerCase());
                 return true;
             },
             get: (_target, prop) => {
                 if (typeof prop === "symbol")
                     return undefined;
-                return this.getHeader(String(prop));
+                return this._headers.get(String(prop).toLowerCase());
             },
             getOwnPropertyDescriptor: (_target, prop) => {
-                if (this.hasHeader(String(prop))) {
+                const lowerProp = String(prop).toLowerCase();
+                if (this._headers.has(lowerProp)) {
                     return {
                         configurable: true,
                         enumerable: true,
-                        value: this.getHeader(String(prop)),
+                        value: this._headers.get(lowerProp),
                     };
                 }
                 return undefined;
             },
             has: (_target, prop) => {
-                return this.hasHeader(String(prop));
+                return this._headers.has(String(prop).toLowerCase());
             },
             ownKeys: () => {
-                return this.getHeaderNames();
+                return Array.from(this._headers.keys());
             },
             set: (_target, prop, value) => {
-                this.setHeader(String(prop), value);
+                if (!this._headersSent) {
+                    this._headers.set(String(prop).toLowerCase(), value);
+                }
                 return true;
             },
         });
@@ -313,9 +486,10 @@ class LambdaResponseBuffered extends node_stream.Writable {
             headersToSet = statusMessageOrHeaders;
         }
         if (headersToSet) {
+            // Use direct _headers access to bypass dd-trace interception
             for (const [key, value] of Object.entries(headersToSet)) {
                 if (value !== undefined) {
-                    this.setHeader(key, value);
+                    this._headers.set(key.toLowerCase(), String(value));
                 }
             }
         }
@@ -352,7 +526,8 @@ class LambdaResponseBuffered extends node_stream.Writable {
         return this;
     }
     json(data) {
-        this.setHeader("content-type", "application/json");
+        // Use direct _headers access to bypass dd-trace interception
+        this._headers.set("content-type", "application/json");
         this.end(JSON.stringify(data));
         return this;
     }
@@ -366,11 +541,12 @@ class LambdaResponseBuffered extends node_stream.Writable {
     /**
      * Add a field to the Vary response header.
      * Used by CORS middleware to indicate response varies by Origin.
+     * Uses direct _headers access to bypass dd-trace interception.
      */
     vary(field) {
-        const existing = this.getHeader("vary");
+        const existing = this._headers.get("vary");
         if (!existing) {
-            this.setHeader("vary", field);
+            this._headers.set("vary", field);
         }
         else {
             // Append to existing Vary header if field not already present
@@ -378,7 +554,7 @@ class LambdaResponseBuffered extends node_stream.Writable {
                 .split(",")
                 .map((f) => f.trim().toLowerCase());
             if (!fields.includes(field.toLowerCase())) {
-                this.setHeader("vary", `${existing}, ${field}`);
+                this._headers.set("vary", `${existing}, ${field}`);
             }
         }
         return this;
@@ -396,6 +572,7 @@ class LambdaResponseBuffered extends node_stream.Writable {
         callback();
     }
     _final(callback) {
+        this._ended = true;
         if (this._resolve) {
             this._resolve(this.buildResult());
         }
@@ -406,7 +583,8 @@ class LambdaResponseBuffered extends node_stream.Writable {
     //
     buildResult() {
         const body = Buffer.concat(this._chunks);
-        const contentType = this.getHeader("content-type") || "";
+        // Use direct _headers access to bypass dd-trace interception
+        const contentType = this._headers.get("content-type") || "";
         // Determine if response should be base64 encoded
         const isBase64Encoded = this.isBinaryContentType(contentType);
         // Build headers object
@@ -468,6 +646,8 @@ class LambdaResponseStreaming extends node_stream.Writable {
         this.socket = {
             remoteAddress: "127.0.0.1",
         };
+        // Internal state exposed for direct manipulation by safe response methods
+        // that need to bypass dd-trace interception
         this._headers = new Map();
         this._headersSent = false;
         this._pendingWrites = [];
@@ -478,6 +658,65 @@ class LambdaResponseStreaming extends node_stream.Writable {
         if (kOutHeaders) {
             this[kOutHeaders] = Object.create(null);
         }
+        // CRITICAL: Define key methods as instance properties to survive Express's
+        // setPrototypeOf(res, app.response) in middleware/init.js which would
+        // otherwise replace our prototype with ServerResponse.prototype.
+        // Instance properties take precedence over prototype properties.
+        this.getHeader = this.getHeader.bind(this);
+        this.setHeader = this.setHeader.bind(this);
+        this.removeHeader = this.removeHeader.bind(this);
+        this.hasHeader = this.hasHeader.bind(this);
+        this.getHeaders = this.getHeaders.bind(this);
+        this.getHeaderNames = this.getHeaderNames.bind(this);
+        this.writeHead = this.writeHead.bind(this);
+        this.flushHeaders = this.flushHeaders.bind(this);
+        this.get = this.get.bind(this);
+        this.set = this.set.bind(this);
+        this.status = this.status.bind(this);
+        this.json = this.json.bind(this);
+        this.send = this.send.bind(this);
+        this.vary = this.vary.bind(this);
+        this.end = this.end.bind(this);
+        this.write = this.write.bind(this);
+        // Also bind internal Writable methods that are called via prototype chain
+        this._write = this._write.bind(this);
+        this._final = this._final.bind(this);
+    }
+    //
+    // Internal bypass methods - completely avoid prototype chain lookup
+    // These directly access _headers Map, safe from dd-trace interception
+    //
+    _internalGetHeader(name) {
+        const value = this._headers.get(name.toLowerCase());
+        return value ? String(value) : undefined;
+    }
+    _internalSetHeader(name, value) {
+        if (!this._headersSent) {
+            const lowerName = name.toLowerCase();
+            this._headers.set(lowerName, value);
+            // Also sync kOutHeaders for any code that expects it
+            if (kOutHeaders) {
+                const outHeaders = this[kOutHeaders];
+                if (outHeaders) {
+                    outHeaders[lowerName] = [name, value];
+                }
+            }
+        }
+    }
+    _internalHasHeader(name) {
+        return this._headers.has(name.toLowerCase());
+    }
+    _internalRemoveHeader(name) {
+        if (!this._headersSent) {
+            const lowerName = name.toLowerCase();
+            this._headers.delete(lowerName);
+            if (kOutHeaders) {
+                const outHeaders = this[kOutHeaders];
+                if (outHeaders) {
+                    delete outHeaders[lowerName];
+                }
+            }
+        }
     }
     //
     // Header management
@@ -532,36 +771,42 @@ class LambdaResponseStreaming extends node_stream.Writable {
     /**
      * Proxy for direct header access (e.g., res.headers['content-type']).
      * Required for compatibility with middleware like helmet that access headers directly.
+     * Uses direct _headers access to bypass dd-trace interception.
      */
     get headers() {
         return new Proxy({}, {
             deleteProperty: (_target, prop) => {
-                this.removeHeader(String(prop));
+                if (!this._headersSent) {
+                    this._headers.delete(String(prop).toLowerCase());
+                }
                 return true;
             },
             get: (_target, prop) => {
                 if (typeof prop === "symbol")
                     return undefined;
-                return this.getHeader(String(prop));
+                return this._headers.get(String(prop).toLowerCase());
             },
             getOwnPropertyDescriptor: (_target, prop) => {
-                if (this.hasHeader(String(prop))) {
+                const lowerProp = String(prop).toLowerCase();
+                if (this._headers.has(lowerProp)) {
                     return {
                         configurable: true,
                         enumerable: true,
-                        value: this.getHeader(String(prop)),
+                        value: this._headers.get(lowerProp),
                     };
                 }
                 return undefined;
             },
             has: (_target, prop) => {
-                return this.hasHeader(String(prop));
+                return this._headers.has(String(prop).toLowerCase());
             },
             ownKeys: () => {
-                return this.getHeaderNames();
+                return Array.from(this._headers.keys());
             },
             set: (_target, prop, value) => {
-                this.setHeader(String(prop), value);
+                if (!this._headersSent) {
+                    this._headers.set(String(prop).toLowerCase(), value);
+                }
                 return true;
             },
         });
@@ -581,9 +826,10 @@ class LambdaResponseStreaming extends node_stream.Writable {
             headersToSet = statusMessageOrHeaders;
         }
         if (headersToSet) {
+            // Use direct _headers access to bypass dd-trace interception
             for (const [key, value] of Object.entries(headersToSet)) {
                 if (value !== undefined) {
-                    this.setHeader(key, value);
+                    this._headers.set(key.toLowerCase(), String(value));
                 }
             }
         }
@@ -641,7 +887,8 @@ class LambdaResponseStreaming extends node_stream.Writable {
         return this;
     }
     json(data) {
-        this.setHeader("content-type", "application/json");
+        // Use direct _headers access to bypass dd-trace interception
+        this._headers.set("content-type", "application/json");
         this.end(JSON.stringify(data));
         return this;
     }
@@ -655,11 +902,12 @@ class LambdaResponseStreaming extends node_stream.Writable {
     /**
      * Add a field to the Vary response header.
      * Used by CORS middleware to indicate response varies by Origin.
+     * Uses direct _headers access to bypass dd-trace interception.
      */
     vary(field) {
-        const existing = this.getHeader("vary");
+        const existing = this._headers.get("vary");
         if (!existing) {
-            this.setHeader("vary", field);
+            this._headers.set("vary", field);
         }
         else {
             // Append to existing Vary header if field not already present
@@ -667,7 +915,7 @@ class LambdaResponseStreaming extends node_stream.Writable {
                 .split(",")
                 .map((f) => f.trim().toLowerCase());
             if (!fields.includes(field.toLowerCase())) {
-                this.setHeader("vary", `${existing}, ${field}`);
+                this._headers.set("vary", `${existing}, ${field}`);
             }
         }
         return this;
@@ -765,6 +1013,7 @@ function runExpressApp(app, req, res) {
  */
 function createLambdaHandler(app, _options) {
     return async (event, context) => {
+        let result;
         try {
             // Set current invoke for getCurrentInvokeUuid
             setCurrentInvoke(event, context);
@@ -774,8 +1023,38 @@ function createLambdaHandler(app, _options) {
             const res = new LambdaResponseBuffered();
             // Run Express app
             await runExpressApp(app, req, res);
-            // Return Lambda response
-            return res.getResult();
+            // Get Lambda response - await explicitly to ensure we have the result
+            result = await res.getResult();
+            // Debug: Log the response before returning
+            console.log("[createLambdaHandler] Returning response:", JSON.stringify({
+                statusCode: result.statusCode,
+                headers: result.headers,
+                bodyLength: result.body?.length,
+                isBase64Encoded: result.isBase64Encoded,
+            }));
+            return result;
+        }
+        catch (error) {
+            // Log any unhandled errors
+            console.error("[createLambdaHandler] Unhandled error:", error);
+            if (error instanceof Error) {
+                console.error("[createLambdaHandler] Stack:", error.stack);
+            }
+            // Return a proper error response instead of throwing
+            return {
+                statusCode: 500,
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    errors: [
+                        {
+                            status: 500,
+                            title: "Internal Server Error",
+                            detail: error instanceof Error ? error.message : "Unknown error occurred",
+                        },
+                    ],
+                }),
+                isBase64Encoded: false,
+            };
         }
         finally {
             // Clear current invoke context
@@ -913,7 +1192,7 @@ const corsHelper = (config = {}) => {
     };
     return expressCors(options);
 };
-var cors = (config) => {
+var cors_helper = (config) => {
     const cors = corsHelper(config);
     return (req, res, next) => {
         cors(req, res, (error) => {
@@ -928,154 +1207,10 @@ var cors = (config) => {
     };
 };
 
-//
-//
-// Constants
-//
-const DEFAULT_PORT = 8080;
-//
-//
-// Main
-//
-/**
- * Creates and starts an Express server with standard Jaypie middleware.
- *
- * Features:
- * - CORS handling (configurable)
- * - JSON body parsing
- * - Listens on PORT env var (default 8080)
- *
- * Usage:
- * ```ts
- * import express from "express";
- * import { createServer, expressHandler } from "@jaypie/express";
- *
- * const app = express();
- *
- * app.get("/", expressHandler(async (req, res) => {
- *   return { message: "Hello World" };
- * }));
- *
- * const { server, port } = await createServer(app);
- * console.log(`Server running on port ${port}`);
- * ```
- *
- * @param app - Express application instance
- * @param options - Server configuration options
- * @returns Promise resolving to server instance and port
- */
-async function createServer(app, options = {}) {
-    const { cors: corsConfig, jsonLimit = "1mb", middleware = [], port: portOption, } = options;
-    // Determine port
-    const port = typeof portOption === "string"
-        ? parseInt(portOption, 10)
-        : (portOption ?? parseInt(process.env.PORT || String(DEFAULT_PORT), 10));
-    // Apply CORS middleware (unless explicitly disabled)
-    if (corsConfig !== false) {
-        app.use(cors(corsConfig));
-    }
-    // Apply JSON body parser
-    // Note: We use dynamic import to avoid requiring express as a direct dependency
-    const express = await import('express');
-    app.use(express.json({ limit: jsonLimit }));
-    // Apply additional middleware
-    for (const mw of middleware) {
-        app.use(mw);
-    }
-    // Start server
-    return new Promise((resolve, reject) => {
-        try {
-            const server = app.listen(port, () => {
-                // Get the actual port (important when port 0 is passed to get an ephemeral port)
-                const address = server.address();
-                const actualPort = address?.port ?? port;
-                logger$2.log.info(`Server listening on port ${actualPort}`);
-                resolve({ port: actualPort, server });
-            });
-            server.on("error", (error) => {
-                logger$2.log.error("Server error", { error });
-                reject(error);
-            });
-        }
-        catch (error) {
-            reject(error);
-        }
-    });
-}
-
-//
-//
-// Constants
-//
-const HEADER_AMZN_REQUEST_ID$1 = "x-amzn-request-id";
-const ENV_AMZN_TRACE_ID = "_X_AMZN_TRACE_ID";
 //
 //
 // Helper Functions
 //
-/**
- * Extract request ID from X-Ray trace ID environment variable
- * Format: Root=1-5e6b4a90-example;Parent=example;Sampled=1
- * We extract the trace ID from the Root segment
- */
-function parseTraceId(traceId) {
-    if (!traceId)
-        return undefined;
-    // Extract the Root segment (format: Root=1-{timestamp}-{uuid})
-    const rootMatch = traceId.match(/Root=([^;]+)/);
-    if (rootMatch && rootMatch[1]) {
-        return rootMatch[1];
-    }
-    return undefined;
-}
-//
-//
-// Main
-//
-/**
- * Get the current invoke UUID from Lambda Web Adapter context.
- * This function extracts the request ID from either:
- * 1. The x-amzn-request-id header (set by Lambda Web Adapter)
- * 2. The _X_AMZN_TRACE_ID environment variable (set by Lambda runtime)
- *
- * @param req - Optional Express request object to extract headers from
- * @returns The AWS request ID or undefined if not in Lambda context
- */
-function getWebAdapterUuid(req) {
-    // First, try to get from request headers
-    if (req && req.headers) {
-        const headerValue = req.headers[HEADER_AMZN_REQUEST_ID$1];
-        if (headerValue) {
-            return Array.isArray(headerValue) ? headerValue[0] : headerValue;
-        }
-    }
-    // Fall back to environment variable (X-Ray trace ID)
-    const traceId = process.env[ENV_AMZN_TRACE_ID];
-    if (traceId) {
-        return parseTraceId(traceId);
-    }
-    return undefined;
-}
-
-//
-//
-// Constants
-//
-const HEADER_AMZN_REQUEST_ID = "x-amzn-request-id";
-//
-//
-// Helper Functions
-//
-/**
- * Detect if we're running in Lambda Web Adapter mode.
- * Web Adapter sets the x-amzn-request-id header on requests.
- */
-function isWebAdapterMode(req) {
-    if (req && req.headers && req.headers[HEADER_AMZN_REQUEST_ID]) {
-        return true;
-    }
-    return false;
-}
 /**
  * Get UUID from Jaypie Lambda adapter context.
  * This is set by createLambdaHandler/createLambdaStreamHandler.
@@ -1092,8 +1227,12 @@ function getJaypieAdapterUuid() {
  * The Jaypie adapter attaches _lambdaContext to the request.
  */
 function getRequestContextUuid(req) {
-    if (req && req._lambdaContext?.awsRequestId) {
-        return req._lambdaContext.awsRequestId;
+    if (req && req._lambdaContext) {
+        const lambdaContext = req
+            ._lambdaContext;
+        if (lambdaContext.awsRequestId) {
+            return lambdaContext.awsRequestId;
+        }
     }
     return undefined;
 }
@@ -1103,29 +1242,20 @@ function getRequestContextUuid(req) {
 //
 /**
  * Get the current invoke UUID from Lambda context.
- * Works with Jaypie Lambda adapter and Lambda Web Adapter mode.
+ * Works with Jaypie Lambda adapter (createLambdaHandler/createLambdaStreamHandler).
  *
  * @param req - Optional Express request object. Used to extract context
- *              from Web Adapter headers or Jaypie adapter's _lambdaContext.
+ *              from Jaypie adapter's _lambdaContext.
  * @returns The AWS request ID or undefined if not in Lambda context
  */
 function getCurrentInvokeUuid(req) {
-    // Priority 1: Web Adapter mode (header-based)
-    if (isWebAdapterMode(req)) {
-        return getWebAdapterUuid(req);
-    }
-    // Priority 2: Request has Lambda context attached (Jaypie adapter)
+    // Priority 1: Request has Lambda context attached (Jaypie adapter)
     const requestContextUuid = getRequestContextUuid(req);
     if (requestContextUuid) {
         return requestContextUuid;
     }
-    // Priority 3: Global context from Jaypie adapter
-    const jaypieAdapterUuid = getJaypieAdapterUuid();
-    if (jaypieAdapterUuid) {
-        return jaypieAdapterUuid;
-    }
-    // Fallback: Web Adapter env var
-    return getWebAdapterUuid();
+    // Priority 2: Global context from Jaypie adapter
+    return getJaypieAdapterUuid();
 }
 
 //
@@ -1139,7 +1269,11 @@ function getCurrentInvokeUuid(req) {
  */
 function safeGetHeader(res, name) {
     try {
-        // Try direct _headers access first (Lambda adapter, avoids dd-trace)
+        // Try internal method first (completely bypasses dd-trace)
+        if (typeof res._internalGetHeader === "function") {
+            return res._internalGetHeader(name);
+        }
+        // Fall back to _headers Map access (Lambda adapter, avoids dd-trace)
         if (res._headers instanceof Map) {
             const value = res._headers.get(name.toLowerCase());
             return value ? String(value) : undefined;
@@ -1167,7 +1301,12 @@ function safeGetHeader(res, name) {
  */
 function safeSetHeader(res, name, value) {
     try {
-        // Try direct _headers access first (Lambda adapter, avoids dd-trace)
+        // Try internal method first (completely bypasses dd-trace)
+        if (typeof res._internalSetHeader === "function") {
+            res._internalSetHeader(name, value);
+            return;
+        }
+        // Fall back to _headers Map access (Lambda adapter, avoids dd-trace)
         if (res._headers instanceof Map) {
             res._headers.set(name.toLowerCase(), value);
             return;
@@ -1298,12 +1437,10 @@ const logger$1 = logger$2.log;
 //
 /**
  * Check if response is a Lambda mock response with direct internal access.
+ * Uses Symbol marker to survive prototype chain modifications from Express and dd-trace.
  */
 function isLambdaMockResponse(res) {
-    const mock = res;
-    return (mock._headers instanceof Map &&
-        Array.isArray(mock._chunks) &&
-        typeof mock.buildResult === "function");
+    return res[JAYPIE_LAMBDA_MOCK] === true;
 }
 /**
  * Safely send a JSON response, avoiding dd-trace interception.
@@ -1312,17 +1449,28 @@ function isLambdaMockResponse(res) {
  */
 function safeSendJson(res, statusCode, data) {
     if (isLambdaMockResponse(res)) {
-        // Direct internal state manipulation - bypasses dd-trace completely
-        res._headers.set("content-type", "application/json");
+        // Use internal method to set header (completely bypasses dd-trace)
+        if (typeof res._internalSetHeader === "function") {
+            res._internalSetHeader("content-type", "application/json");
+        }
+        else {
+            // Fall back to direct _headers manipulation
+            res._headers.set("content-type", "application/json");
+        }
         res.statusCode = statusCode;
         // Directly push to chunks array instead of using stream write/end
         const chunk = Buffer.from(JSON.stringify(data));
         res._chunks.push(chunk);
         res._headersSent = true;
+        // Mark as ended so getResult() resolves immediately
+        res._ended = true;
         // Signal completion if a promise is waiting
         if (res._resolve) {
             res._resolve(res.buildResult());
         }
+        // Emit "finish" event so runExpressApp's promise resolves
+        console.log("[safeSendJson] Emitting finish event");
+        res.emit("finish");
         return;
     }
     // Fall back to standard Express methods for real responses
@@ -1342,10 +1490,15 @@ function safeSend(res, statusCode, body) {
             res._chunks.push(chunk);
         }
         res._headersSent = true;
+        // Mark as ended so getResult() resolves immediately
+        res._ended = true;
         // Signal completion if a promise is waiting
         if (res._resolve) {
             res._resolve(res.buildResult());
         }
+        // Emit "finish" event so runExpressApp's promise resolves
+        console.log("[safeSend] Emitting finish event");
+        res.emit("finish");
         return;
     }
     // Fall back to standard Express methods for real responses
@@ -1612,7 +1765,18 @@ function expressHandler(handlerOrOptions, optionsOrHandler) {
             }
         }
         catch (error) {
-            log.fatal("Express encountered an error while sending the response");
+            // Use console.error for raw stack trace to ensure it appears in CloudWatch
+            // Handle both Error objects and plain thrown values
+            const errorMessage = error instanceof Error
+                ? error.message
+                : typeof error === "object" && error !== null
+                    ? JSON.stringify(error)
+                    : String(error);
+            const errorStack = error instanceof Error
+                ? error.stack
+                : new Error("Stack trace").stack?.replace("Error: Stack trace", `Error: ${errorMessage}`);
+            console.error("Express response error stack trace:", errorStack);
+            log.fatal(`Express encountered an error while sending the response: ${errorMessage}`);
             log.var({ responseError: error });
         }
         // Log response
@@ -1712,14 +1876,13 @@ const logger = logger$2.log;
 // Helper
 //
 /**
- * Format an error as an SSE error event
+ * Get error body from an error
  */
-function formatErrorSSE(error) {
+function getErrorBody(error) {
     const isJaypieError = error.isProjectError;
-    const body = isJaypieError
+    return isJaypieError
         ? (error.body?.() ?? { error: error.message })
         : new errors.UnhandledError().body();
-    return `event: error\ndata: ${JSON.stringify(body)}\n\n`;
 }
 function expressStreamHandler(handlerOrOptions, optionsOrHandler) {
     /* eslint-enable no-redeclare */
@@ -1739,7 +1902,8 @@ function expressStreamHandler(handlerOrOptions, optionsOrHandler) {
     //
     // Validate
     //
-    let { chaos, contentType = "text/event-stream", locals, name, secrets, setup = [], teardown = [], unavailable, validate, } = options;
+    const format = options.format ?? "sse";
+    let { chaos, contentType = aws.getContentTypeForFormat(format), locals, name, secrets, setup = [], teardown = [], unavailable, validate, } = options;
     if (typeof handler !== "function") {
         throw new errors.BadRequestError(`Argument "${handler}" doesn't match type "function"`);
     }
@@ -1877,9 +2041,10 @@ function expressStreamHandler(handlerOrOptions, optionsOrHandler) {
                 log.fatal("Caught unhandled error in stream handler");
                 log.info.var({ unhandledError: error.message });
             }
-            // Write error as SSE event
+            // Write error in the appropriate format
             try {
-                res.write(formatErrorSSE(error));
+                const errorBody = getErrorBody(error);
+                res.write(aws.formatStreamError(errorBody, format));
             }
             catch {
                 // Response may already be closed
@@ -1993,10 +2158,9 @@ exports.LambdaRequest = LambdaRequest;
 exports.LambdaResponseBuffered = LambdaResponseBuffered;
 exports.LambdaResponseStreaming = LambdaResponseStreaming;
 exports.badRequestRoute = badRequestRoute;
-exports.cors = cors;
+exports.cors = cors_helper;
 exports.createLambdaHandler = createLambdaHandler;
 exports.createLambdaStreamHandler = createLambdaStreamHandler;
-exports.createServer = createServer;
 exports.echoRoute = echoRoute;
 exports.expressHandler = expressHandler;
 exports.expressHttpCodeHandler = httpHandler;