@intelligems/sst 2.49.6-ig.4 → 2.49.6-ig.6

package/runtime/handlers/node.js

@@ -11,6 +11,7 @@ import { useRuntimeWorkers } from "../workers.js";
 import { Colors } from "../../cli/colors.js";
 import { Logger } from "../../logger.js";
 import { findAbove } from "../../util/fs.js";
+import { useMonoBuildConfig } from "../mono-build-config.js";
 export const useNodeHandler = () => {
     const rebuildCache = {};
     process.on("exit", () => {
@@ -59,12 +60,10 @@ export const useNodeHandler = () => {
             await worker?.terminate();
         },
         build: async (input) => {
-            // Check for dev mode mono-bundle: if .mono-build/index.mjs exists, skip individual builds
-            const monoBundleDir = path.join(project.paths.root, ".mono-build");
-            const monoBundlePath = path.join(monoBundleDir, "index.mjs");
-            const monoBundleExists = fsSync.existsSync(monoBundlePath);
-            if (input.mode === "start" && monoBundleExists) {
-                Colors.line(Colors.prefix, Colors.dim.bold("MonoBundle"), Colors.dim(`mode=${input.mode}, exists=${monoBundleExists}, handler=${input.props.handler}`));
+            // Check for dev mode mono-bundle using global config
+            const monoBuildConfig = useMonoBuildConfig();
+            if (input.mode === "start" && monoBuildConfig.enabled) {
+                Colors.line(Colors.prefix, Colors.dim.bold("MonoBundle"), Colors.dim(`mode=${input.mode}, handler=${input.props.handler}`));
                 // Symlink node_modules to mono-bundle dir for external dependencies
                 // Only create if symlink doesn't exist or points to wrong location (avoid redundant I/O)
                 const parsed = path.parse(input.props.handler);
@@ -72,7 +71,7 @@ export const useNodeHandler = () => {
                 const root = await findAbove(handlerFunctionsDir, "package.json");
                 if (root) {
                     const sourceNodeModules = path.resolve(root, "node_modules");
-                    const monoBundleNodeModules = path.join(monoBundleDir, "node_modules");
+                    const monoBundleNodeModules = path.join(monoBuildConfig.dir, "node_modules");
                     try {
                         const existingTarget = await fs.readlink(monoBundleNodeModules);
                         if (existingTarget === sourceNodeModules) {
@@ -98,8 +97,8 @@ export const useNodeHandler = () => {
                 }
                 return {
                     type: "success",
-                    handler: "index.handler",
-                    out: monoBundleDir,
+                    handler: monoBuildConfig.handler,
+                    out: monoBuildConfig.dir,
                 };
             }
             const parsed = path.parse(input.props.handler);

package/runtime/handlers.d.ts

@@ -28,6 +28,8 @@ export interface StartWorkerInput {
     out: string;
     handler: string;
     runtime: string;
+    /** Whether this worker is using mono build mode */
+    isMonoBuild?: boolean;
 }
 interface ShouldBuildInput {
     file: string;

package/runtime/handlers.js

@@ -14,6 +14,9 @@ import { usePythonHandler } from "./handlers/python.js";
 import { useRustHandler } from "./handlers/rust.js";
 import { lazy } from "../util/lazy.js";
 import { Semaphore } from "../util/semaphore.js";
+import { isMonoBuildPath } from "./mono-build-config.js";
+// Build concurrency semaphore - only used for actual builds, not mono-build lookups
+const buildSemaphore = new Semaphore(parseInt(process.env.SST_BUILD_CONCURRENCY || "4", 10));
 export const useRuntimeHandlers = lazy(() => {
     const handlers = [
         useNodeHandler(),
@@ -39,13 +42,11 @@ export const useRuntimeHandlers = lazy(() => {
             return result;
         },
         async build(functionID, mode) {
-            async function task() {
+            // Fast path for mono-bundle: check without semaphore since no actual build work
+            async function tryMonoBundleFastPath() {
                 const func = useFunctions().fromID(functionID);
                 if (!func)
-                    return {
-                        type: "error",
-                        errors: [`Function with ID "${functionID}" not found`],
-                    };
+                    return null;
                 const handler = result.for(func.runtime);
                 const out = path.join(project.paths.artifacts, functionID);
                 // Check for mono-bundle mode by doing a preliminary build call
@@ -67,56 +68,84 @@ export const useRuntimeHandlers = lazy(() => {
                         sourcemap: monoBundleCheck.sourcemap,
                     };
                 }
-                // Non-mono-bundle: follow original flow
-                await fs.rm(out, { recursive: true, force: true });
-                await fs.mkdir(out, { recursive: true });
-                bus.publish("function.build.started", { functionID });
-                if (func.hooks?.beforeBuild)
-                    await func.hooks.beforeBuild(func, out);
-                const built = await handler.build({
-                    functionID,
-                    out,
-                    mode,
-                    props: func,
-                });
-                if (built.type === "error") {
-                    bus.publish("function.build.failed", {
+                return null; // Not mono-bundle, need full build
+            }
+            // Full build with semaphore protection for actual compilation work
+            async function fullBuild() {
+                const func = useFunctions().fromID(functionID);
+                if (!func)
+                    return {
+                        type: "error",
+                        errors: [`Function with ID "${functionID}" not found`],
+                    };
+                const handler = result.for(func.runtime);
+                const out = path.join(project.paths.artifacts, functionID);
+                // Acquire semaphore only for actual build work
+                const unlock = await buildSemaphore.lock();
+                try {
+                    // Non-mono-bundle: follow original flow
+                    await fs.rm(out, { recursive: true, force: true });
+                    await fs.mkdir(out, { recursive: true });
+                    bus.publish("function.build.started", { functionID });
+                    if (func.hooks?.beforeBuild)
+                        await func.hooks.beforeBuild(func, out);
+                    const built = await handler.build({
                         functionID,
-                        errors: built.errors,
+                        out,
+                        mode,
+                        props: func,
                     });
-                    return built;
-                }
-                if (func.copyFiles) {
-                    await Promise.all(func.copyFiles.map(async (entry) => {
-                        const fromPath = path.join(project.paths.root, entry.from);
-                        const to = entry.to || entry.from;
-                        if (path.isAbsolute(to))
-                            throw new Error(`Copy destination path "${to}" must be relative`);
-                        const toPath = path.join(out, to);
-                        if (mode === "deploy")
-                            await fs.cp(fromPath, toPath, {
-                                recursive: true,
-                            });
-                        if (mode === "start") {
-                            try {
-                                const dir = path.dirname(toPath);
-                                await fs.mkdir(dir, { recursive: true });
-                                await fs.symlink(fromPath, toPath);
-                            }
-                            catch (ex) {
-                                Logger.debug("Failed to symlink", fromPath, toPath, ex);
+                    if (built.type === "error") {
+                        bus.publish("function.build.failed", {
+                            functionID,
+                            errors: built.errors,
+                        });
+                        return built;
+                    }
+                    if (func.copyFiles) {
+                        await Promise.all(func.copyFiles.map(async (entry) => {
+                            const fromPath = path.join(project.paths.root, entry.from);
+                            const to = entry.to || entry.from;
+                            if (path.isAbsolute(to))
+                                throw new Error(`Copy destination path "${to}" must be relative`);
+                            const toPath = path.join(out, to);
+                            if (mode === "deploy")
+                                await fs.cp(fromPath, toPath, {
+                                    recursive: true,
+                                });
+                            if (mode === "start") {
+                                try {
+                                    const dir = path.dirname(toPath);
+                                    await fs.mkdir(dir, { recursive: true });
+                                    await fs.symlink(fromPath, toPath);
+                                }
+                                catch (ex) {
+                                    Logger.debug("Failed to symlink", fromPath, toPath, ex);
+                                }
                             }
-                        }
-                    }));
+                        }));
+                    }
+                    if (func.hooks?.afterBuild)
+                        await func.hooks.afterBuild(func, out);
+                    bus.publish("function.build.success", { functionID });
+                    return {
+                        ...built,
+                        out,
+                        sourcemap: built.sourcemap,
+                    };
+                }
+                finally {
+                    unlock();
                 }
-                if (func.hooks?.afterBuild)
-                    await func.hooks.afterBuild(func, out);
-                bus.publish("function.build.success", { functionID });
-                return {
-                    ...built,
-                    out,
-                    sourcemap: built.sourcemap,
-                };
+            }
+            async function task() {
+                // Try mono-bundle fast path first (no semaphore needed)
+                const monoBundleResult = await tryMonoBundleFastPath();
+                if (monoBundleResult) {
+                    return monoBundleResult;
+                }
+                // Fall back to full build with semaphore protection
+                return fullBuild();
             }
             if (pendingBuilds.has(functionID)) {
                 Logger.debug("Waiting on pending build", functionID);
@@ -138,27 +167,43 @@ export const useRuntimeHandlers = lazy(() => {
 export const useFunctionBuilder = lazy(() => {
     const artifacts = new Map();
     const handlers = useRuntimeHandlers();
-    const semaphore = new Semaphore(parseInt(process.env.SST_BUILD_CONCURRENCY || "4", 10));
+    // Track pending builds to prevent duplicate concurrent builds for same function
+    const pendingArtifactBuilds = new Map();
     const result = {
         artifact: (functionID) => {
+            // Fast path: already cached - return immediately without any async work
             if (artifacts.has(functionID))
                 return artifacts.get(functionID);
             return result.build(functionID);
         },
         build: async (functionID) => {
-            const unlock = await semaphore.lock();
-            try {
-                const result = await handlers.build(functionID, "start");
-                if (!result)
-                    return;
-                if (result.type === "error")
-                    return;
-                artifacts.set(functionID, result);
+            // Fast path: already cached (check again in case of concurrent calls)
+            if (artifacts.has(functionID))
                 return artifacts.get(functionID);
-            }
-            finally {
-                unlock();
-            }
+            // Deduplication: if build already in progress for this function, wait for it
+            const pending = pendingArtifactBuilds.get(functionID);
+            if (pending)
+                return pending;
+            const buildTask = async () => {
+                try {
+                    // handlers.build() handles semaphore internally:
+                    // - mono-build: no semaphore (fast path)
+                    // - non-mono-build: semaphore protected
+                    const buildResult = await handlers.build(functionID, "start");
+                    if (!buildResult)
+                        return;
+                    if (buildResult.type === "error")
+                        return;
+                    artifacts.set(functionID, buildResult);
+                    return artifacts.get(functionID);
+                }
+                finally {
+                    pendingArtifactBuilds.delete(functionID);
+                }
+            };
+            const promise = buildTask();
+            pendingArtifactBuilds.set(functionID, promise);
+            return promise;
         },
     };
     const watcher = useWatcher();
@@ -169,7 +214,7 @@ export const useFunctionBuilder = lazy(() => {
                 // Optimization: For mono-build, the artifact path is stable and build is handled externally.
                 // We can skip the potentially expensive shouldBuild check and rebuild call.
                 const existing = artifacts.get(functionID);
-                if (existing?.out.includes(".mono-build"))
+                if (existing && isMonoBuildPath(existing.out))
                     continue;
                 const handler = handlers.for(info.runtime);
                 if (!handler?.shouldBuild({

package/runtime/iot.js

@@ -2,20 +2,40 @@ import { useBus } from "../bus.js";
 import { useIOT } from "../iot.js";
 import { lazy } from "../util/lazy.js";
 import { logInvokeTrace } from "./worker-pool-logging.js";
+import { logIot } from "./debug-bridge-logging.js";
+import { logEventTrace } from "./event-trace-logging.js";
 export const useIOTBridge = lazy(async () => {
     const bus = useBus();
     const iot = await useIOT();
     const topic = `${iot.prefix}/events`;
     bus.subscribe("function.success", async (evt) => {
-        iot.publish(topic + "/" + evt.properties.workerID, "function.success", evt.properties);
+        const { workerID, requestID } = evt.properties;
+        logIot(`reqId=${requestID?.slice(0, 8)} Publishing function.success to worker ${workerID.slice(0, 8)}`);
+        const startTime = Date.now();
+        await iot.publish(topic + "/" + workerID, "function.success", evt.properties);
+        logIot(`reqId=${requestID?.slice(0, 8)} function.success published in ${Date.now() - startTime}ms`);
     });
     bus.subscribe("function.error", async (evt) => {
-        iot.publish(topic + "/" + evt.properties.workerID, "function.error", evt.properties);
+        const { workerID, requestID } = evt.properties;
+        logIot(`reqId=${requestID?.slice(0, 8)} Publishing function.error to worker ${workerID.slice(0, 8)}`);
+        const startTime = Date.now();
+        await iot.publish(topic + "/" + workerID, "function.error", evt.properties);
+        logIot(`reqId=${requestID?.slice(0, 8)} function.error published in ${Date.now() - startTime}ms`);
     });
     bus.subscribe("function.ack", async (evt) => {
-        const workerID = evt.properties.workerID;
+        const { workerID, requestID, functionID } = evt.properties;
+        logIot(`reqId=${requestID?.slice(0, 8)} Publishing function.ack to worker ${workerID.slice(0, 8)}`);
         logInvokeTrace("IOT_ACK_START", workerID, `worker=${workerID.slice(0, 8)}`);
+        const startTime = Date.now();
         await iot.publish(topic + "/" + workerID, "function.ack", evt.properties);
+        const elapsed = Date.now() - startTime;
+        logIot(`reqId=${requestID?.slice(0, 8)} function.ack published in ${elapsed}ms`);
         logInvokeTrace("IOT_ACK_DONE", workerID, `worker=${workerID.slice(0, 8)}`);
+        logEventTrace("IOT_ACK", {
+            requestID,
+            functionID,
+            workerID,
+            elapsed,
+        });
     });
 });

package/runtime/mono-build-config.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Global mono build configuration for SST dev mode.
+ *
+ * Mono build mode bundles all Lambda handlers into a single file (.mono-build/index.mjs)
+ * instead of building each handler individually. This significantly speeds up dev mode
+ * by sharing compilation work across all handlers.
+ *
+ * Detection happens once at startup and the result is cached for the session.
+ */
+export declare const useMonoBuildConfig: () => {
+    /**
+     * Whether mono build mode is enabled (detected at startup).
+     * When true, all Node.js handlers use the shared .mono-build bundle.
+     */
+    enabled: boolean;
+    /**
+     * The mono bundle directory (.mono-build)
+     */
+    dir: string;
+    /**
+     * The mono bundle entry file (.mono-build/index.mjs)
+     */
+    entryFile: string;
+    /**
+     * The handler string to use for mono build mode
+     */
+    handler: string;
+    /**
+     * Check if a build output path represents a mono build.
+     * This is useful when you have a build result and need to determine its type.
+     */
+    isMonoBuildPath(buildOut: string): boolean;
+    /**
+     * Get the pool key for a function based on mono build status.
+     * For mono build: shared key (all functions share workers)
+     * For non-mono build: per-function key
+     */
+    getPoolKey(functionID: string, runtime: string, buildOut: string): {
+        key: string;
+        isShared: boolean;
+    };
+};
+/**
+ * Quick check for mono build mode without full config initialization.
+ * Use this for simple boolean checks where you don't need the full config.
+ */
+export declare function isMonoBuildEnabled(): boolean;
+/**
+ * Get the mono build directory path.
+ */
+export declare function getMonoBuildDir(): string;
+/**
+ * Check if a path represents a mono build output.
+ */
+export declare function isMonoBuildPath(buildOut: string): boolean;

package/runtime/mono-build-config.js

@@ -0,0 +1,80 @@
+import path from "path";
+import fsSync from "fs";
+import { useProject } from "../project.js";
+import { lazy } from "../util/lazy.js";
+import { Logger } from "../logger.js";
+/**
+ * Global mono build configuration for SST dev mode.
+ *
+ * Mono build mode bundles all Lambda handlers into a single file (.mono-build/index.mjs)
+ * instead of building each handler individually. This significantly speeds up dev mode
+ * by sharing compilation work across all handlers.
+ *
+ * Detection happens once at startup and the result is cached for the session.
+ */
+export const useMonoBuildConfig = lazy(() => {
+    const project = useProject();
+    const monoBundleDir = path.join(project.paths.root, ".mono-build");
+    const monoBundlePath = path.join(monoBundleDir, "index.mjs");
+    // Check once at startup if mono build exists
+    const enabled = fsSync.existsSync(monoBundlePath);
+    if (enabled) {
+        Logger.debug("Mono build mode enabled:", monoBundlePath);
+    }
+    return {
+        /**
+         * Whether mono build mode is enabled (detected at startup).
+         * When true, all Node.js handlers use the shared .mono-build bundle.
+         */
+        enabled,
+        /**
+         * The mono bundle directory (.mono-build)
+         */
+        dir: monoBundleDir,
+        /**
+         * The mono bundle entry file (.mono-build/index.mjs)
+         */
+        entryFile: monoBundlePath,
+        /**
+         * The handler string to use for mono build mode
+         */
+        handler: "index.handler",
+        /**
+         * Check if a build output path represents a mono build.
+         * This is useful when you have a build result and need to determine its type.
+         */
+        isMonoBuildPath(buildOut) {
+            return enabled && buildOut.includes(".mono-build");
+        },
+        /**
+         * Get the pool key for a function based on mono build status.
+         * For mono build: shared key (all functions share workers)
+         * For non-mono build: per-function key
+         */
+        getPoolKey(functionID, runtime, buildOut) {
+            if (enabled && buildOut.includes(".mono-build")) {
+                return { key: `${runtime}:mono-build`, isShared: true };
+            }
+            return { key: `${runtime}:${functionID}`, isShared: false };
+        },
+    };
+});
+/**
+ * Quick check for mono build mode without full config initialization.
+ * Use this for simple boolean checks where you don't need the full config.
+ */
+export function isMonoBuildEnabled() {
+    return useMonoBuildConfig().enabled;
+}
+/**
+ * Get the mono build directory path.
+ */
+export function getMonoBuildDir() {
+    return useMonoBuildConfig().dir;
+}
+/**
+ * Check if a path represents a mono build output.
+ */
+export function isMonoBuildPath(buildOut) {
+    return useMonoBuildConfig().isMonoBuildPath(buildOut);
+}

package/runtime/request-utils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Extracts a request path from a Lambda event for logging purposes.
+ * Handles API Gateway v1, v2, and other event formats.
+ */
+export declare function getRequestPath(event: unknown): string;
+/**
+ * Extracts correlation ID from headers for request tracing.
+ * Checks common correlation header names.
+ *
+ * Frontend can send: X-Correlation-ID, X-Request-ID, or X-Trace-ID
+ */
+export declare function getCorrelationId(event: unknown): string | undefined;
+/**
+ * Extracts API Gateway Request ID from requestContext.
+ * This ID is visible in browser dev tools (x-amzn-requestid response header).
+ */
+export declare function getApiGatewayRequestId(event: unknown): string | undefined;
+/**
+ * Extracts HTTP method from event
+ */
+export declare function getHttpMethod(event: unknown): string | undefined;

package/runtime/request-utils.js

@@ -0,0 +1,102 @@
+/**
+ * Extracts a request path from a Lambda event for logging purposes.
+ * Handles API Gateway v1, v2, and other event formats.
+ */
+export function getRequestPath(event) {
+    if (!event || typeof event !== "object") {
+        return "[unknown]";
+    }
+    const evt = event;
+    // API Gateway v2 (HTTP API)
+    if (typeof evt.rawPath === "string") {
+        return evt.rawPath;
+    }
+    // API Gateway v1 (REST API)
+    if (typeof evt.path === "string") {
+        return evt.path;
+    }
+    // Warmup requests
+    if ("ding" in evt || "warmer" in evt || evt.__sst_warmup === true) {
+        return "[warmup]";
+    }
+    // SQS, SNS, or other event types - no path
+    return "[event]";
+}
+/**
+ * Extracts correlation ID from headers for request tracing.
+ * Checks common correlation header names.
+ *
+ * Frontend can send: X-Correlation-ID, X-Request-ID, or X-Trace-ID
+ */
+export function getCorrelationId(event) {
+    if (!event || typeof event !== "object") {
+        return undefined;
+    }
+    const evt = event;
+    // Get headers - handle both v1 and v2 API Gateway formats
+    let headers;
+    // API Gateway v2 uses lowercase headers
+    if (evt.headers && typeof evt.headers === "object") {
+        headers = evt.headers;
+    }
+    if (!headers)
+        return undefined;
+    // Check common correlation header names (case-insensitive)
+    const correlationHeaders = [
+        "x-correlation-id",
+        "x-request-id",
+        "x-trace-id",
+        "correlation-id",
+        "request-id",
+    ];
+    // Normalize header keys to lowercase for comparison
+    const normalizedHeaders = {};
+    for (const [key, value] of Object.entries(headers)) {
+        normalizedHeaders[key.toLowerCase()] = value;
+    }
+    for (const headerName of correlationHeaders) {
+        const value = normalizedHeaders[headerName];
+        if (value) {
+            return value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Extracts API Gateway Request ID from requestContext.
+ * This ID is visible in browser dev tools (x-amzn-requestid response header).
+ */
+export function getApiGatewayRequestId(event) {
+    if (!event || typeof event !== "object") {
+        return undefined;
+    }
+    const evt = event;
+    // Check requestContext.requestId (both v1 and v2)
+    const requestContext = evt.requestContext;
+    if (requestContext?.requestId && typeof requestContext.requestId === "string") {
+        return requestContext.requestId;
+    }
+    return undefined;
+}
+/**
+ * Extracts HTTP method from event
+ */
+export function getHttpMethod(event) {
+    if (!event || typeof event !== "object") {
+        return undefined;
+    }
+    const evt = event;
+    // API Gateway v2
+    const requestContext = evt.requestContext;
+    if (requestContext?.http && typeof requestContext.http === "object") {
+        const http = requestContext.http;
+        if (typeof http.method === "string") {
+            return http.method;
+        }
+    }
+    // API Gateway v1
+    if (typeof evt.httpMethod === "string") {
+        return evt.httpMethod;
+    }
+    return undefined;
+}

package/runtime/runtime.d.ts

@@ -4,6 +4,7 @@ declare module "../bus.js" {
         "function.ack": {
             workerID: string;
             functionID: string;
+            requestID: string;
         };
         "function.invoked": {
             workerID: string;