@intelligems/sst 2.49.3 → 2.49.6-ig.10

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,64 +42,110 @@ 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);
-                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({
+                // Check for mono-bundle mode by doing a preliminary build call
+                // In mono-bundle mode, handler returns its own out path immediately without building
+                const monoBundleCheck = await handler.build({
                     functionID,
                     out,
                     mode,
                     props: func,
                 });
-                if (built.type === "error") {
-                    bus.publish("function.build.failed", {
+                // If mono-bundle detected (handler returned custom out), skip all artifact work
+                // Don't fire build events - mono-bundle is built externally by esbuild watch
+                // Worker pool invalidation is handled separately when bundle file actually changes
+                if (monoBundleCheck.type === "success" && monoBundleCheck.out) {
+                    return {
+                        type: "success",
+                        handler: monoBundleCheck.handler,
+                        out: monoBundleCheck.out,
+                        sourcemap: monoBundleCheck.sourcemap,
+                    };
+                }
+                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);
+                    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);
+                                }
                             }
-                            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);
@@ -118,27 +167,43 @@ export const useRuntimeHandlers = lazy(() => {
 export const useFunctionBuilder = lazy(() => {
     const artifacts = new Map();
     const handlers = useRuntimeHandlers();
-    const semaphore = new Semaphore(4);
+    // 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();
@@ -146,6 +211,11 @@ export const useFunctionBuilder = lazy(() => {
         try {
             const functions = useFunctions();
             for (const [functionID, info] of Object.entries(functions.all)) {
+                // 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 && isMonoBuildPath(existing.out))
+                    continue;
                 const handler = handlers.for(info.runtime);
                 if (!handler?.shouldBuild({
                     functionID,
@@ -156,7 +226,8 @@ export const useFunctionBuilder = lazy(() => {
                 Logger.debug("Rebuilt function", functionID);
             }
         }
-        catch { }
+        catch {
+        }
     });
     return result;
 });

package/runtime/iot.js

@@ -1,17 +1,44 @@
 import { useBus } from "../bus.js";
-import { useIOT } from "../iot.js";
+import { useIOT, useIOTControl } 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();
+    // The ack goes out on its own socket so it can never queue behind a response
+    // body. See `useIOTControl`.
+    const control = await useIOTControl();
     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) => {
-        iot.publish(topic + "/" + evt.properties.workerID, "function.ack", evt.properties);
+        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 control.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,58 @@
+/**
+ * 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 latches on: the first check that finds the bundle enables mono
+ * build for the rest of the session. It deliberately does NOT latch off, so a
+ * caller arriving before the bundle has been written cannot disable it.
+ */
+export declare const useMonoBuildConfig: () => {
+    /**
+     * Whether mono build mode is enabled. Re-checked until the bundle is
+     * found, so a check made before it was written does not stick.
+     * When true, all Node.js handlers use the shared .mono-build bundle.
+     */
+    readonly 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,104 @@
+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 latches on: the first check that finds the bundle enables mono
+ * build for the rest of the session. It deliberately does NOT latch off, so a
+ * caller arriving before the bundle has been written cannot disable it.
+ */
+export const useMonoBuildConfig = lazy(() => {
+    const project = useProject();
+    const monoBundleDir = path.join(project.paths.root, ".mono-build");
+    const monoBundlePath = path.join(monoBundleDir, "index.mjs");
+    /**
+     * Latches on true, never on false.
+     *
+     * This was a single `existsSync` at first call, cached for the session by
+     * `lazy`. Dev start deletes `.mono-build/index.mjs` and then rebuilds it, so
+     * any caller landing in that window — typically an invocation that beat the
+     * bundle to disk — pinned this to false for the whole session. Every handler
+     * then took the per-function esbuild path, which does not carry the mono
+     * build's `external` list, and failed to resolve packages the mono bundle
+     * never opens. The bundle finishing changed nothing, because the flag had
+     * already been decided, so the session stayed broken until restarted.
+     *
+     * Re-checking until it is found costs one `existsSync` per call for the few
+     * seconds before the bundle lands, and nothing afterwards.
+     */
+    let enabled = false;
+    const isEnabled = () => {
+        if (!enabled && fsSync.existsSync(monoBundlePath)) {
+            enabled = true;
+            Logger.debug("Mono build mode enabled:", monoBundlePath);
+        }
+        return enabled;
+    };
+    isEnabled();
+    return {
+        /**
+         * Whether mono build mode is enabled. Re-checked until the bundle is
+         * found, so a check made before it was written does not stick.
+         * When true, all Node.js handlers use the shared .mono-build bundle.
+         */
+        get enabled() {
+            return isEnabled();
+        },
+        /**
+         * 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 isEnabled() && 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 (isEnabled() && 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;

package/runtime/server.d.ts

@@ -1,6 +1,9 @@
+import { Events } from "../bus.js";
 export declare const useRuntimeServerConfig: () => Promise<{
     API_VERSION: string;
     port: number;
     url: string;
 }>;
-export declare const useRuntimeServer: () => Promise<void>;
+export declare const useRuntimeServer: () => Promise<{
+    routeInvocation: (targetWorkerID: string, invocation: Events["function.invoked"]) => void;
+}>;