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

package/iot.js

@@ -149,15 +149,12 @@ export const useIOT = lazy(async () => {
                 properties,
                 sourceID: bus.sourceID,
             };
-            for (const fragment of await encode(payload)) {
-                await new Promise((r) => {
-                    device.publish(topic, JSON.stringify(fragment), {
-                        qos: 1,
-                    }, () => {
-                        r();
-                    });
+            const fragments = await encode(payload);
+            await Promise.all(fragments.map((fragment) => new Promise((r) => {
+                device.publish(topic, JSON.stringify(fragment), { qos: 1 }, () => {
+                    r();
                 });
-            }
+            })));
             Logger.debug("IOT Published", topic, type);
         },
     };

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "@intelligems/sst",
-  "version": "2.49.6-ig.2",
+  "version": "2.49.6-ig.4",
   "bin": {
     "sst": "cli/sst.js"
   },

package/package.json.bak

@@ -5,7 +5,7 @@
   },
   "sideEffects": false,
   "name": "@intelligems/sst",
-  "version": "2.49.6-ig.2",
+  "version": "2.49.6-ig.4",
   "bin": {
     "sst": "cli/sst.js"
   },

package/runtime/handlers/node.js

@@ -34,27 +34,25 @@ export const useNodeHandler = () => {
         canHandle: (input) => input.startsWith("nodejs"),
         startWorker: async (input) => {
             const workers = await useRuntimeWorkers();
-            new Promise(async () => {
-                const worker = new Worker(url.fileURLToPath(new URL("../../support/nodejs-runtime/index.mjs", import.meta.url)), {
-                    env: {
-                        ...input.environment,
-                        IS_LOCAL: "true",
-                    },
-                    execArgv: ["--enable-source-maps"],
-                    workerData: input,
-                    stderr: true,
-                    stdin: true,
-                    stdout: true,
-                });
-                worker.stdout.on("data", (data) => {
-                    workers.stdout(input.workerID, data.toString());
-                });
-                worker.stderr.on("data", (data) => {
-                    workers.stdout(input.workerID, data.toString());
-                });
-                worker.on("exit", () => workers.exited(input.workerID));
-                threads.set(input.workerID, worker);
+            const worker = new Worker(url.fileURLToPath(new URL("../../support/nodejs-runtime/index.mjs", import.meta.url)), {
+                env: {
+                    ...input.environment,
+                    IS_LOCAL: "true",
+                },
+                execArgv: ["--enable-source-maps"],
+                workerData: input,
+                stderr: true,
+                stdin: true,
+                stdout: true,
             });
+            worker.stdout.on("data", (data) => {
+                workers.stdout(input.workerID, data.toString());
+            });
+            worker.stderr.on("data", (data) => {
+                workers.stdout(input.workerID, data.toString());
+            });
+            worker.on("exit", () => workers.exited(input.workerID));
+            threads.set(input.workerID, worker);
         },
         stopWorker: async (workerID) => {
             const worker = threads.get(workerID);
@@ -65,26 +63,37 @@ export const useNodeHandler = () => {
             const monoBundleDir = path.join(project.paths.root, ".mono-build");
             const monoBundlePath = path.join(monoBundleDir, "index.mjs");
             const monoBundleExists = fsSync.existsSync(monoBundlePath);
-            console.log(`[MONO-BUNDLE] mode=${input.mode}, exists=${monoBundleExists}, handler=${input.props.handler}`);
             if (input.mode === "start" && monoBundleExists) {
-                console.log(`[MONO-BUNDLE] Using mono-bundle for: ${input.props.handler}`);
-                Logger.debug("Using mono-bundle for dev mode:", monoBundlePath);
+                Colors.line(Colors.prefix, Colors.dim.bold("MonoBundle"), Colors.dim(`mode=${input.mode}, exists=${monoBundleExists}, handler=${input.props.handler}`));
                 // Symlink node_modules to mono-bundle dir for external dependencies
-                // Use the same approach as individual builds: find nearest package.json above the handler
-                // handler-functions.ts lives in web/node-backend/src/, so start from there
-                const handlerFunctionsDir = path.join(project.paths.root, "web/node-backend/src");
+                // Only create if symlink doesn't exist or points to wrong location (avoid redundant I/O)
+                const parsed = path.parse(input.props.handler);
+                const handlerFunctionsDir = path.join(project.paths.root, parsed.dir);
                 const root = await findAbove(handlerFunctionsDir, "package.json");
                 if (root) {
-                    const sourceNodeModules = path.join(root, "node_modules");
+                    const sourceNodeModules = path.resolve(root, "node_modules");
                     const monoBundleNodeModules = path.join(monoBundleDir, "node_modules");
                     try {
-                        // Remove existing node_modules in mono-build (might be stale from deploy build)
-                        await fs.rm(monoBundleNodeModules, { recursive: true, force: true });
-                        await fs.symlink(path.resolve(sourceNodeModules), monoBundleNodeModules, "dir");
-                        Logger.debug("Symlinked node_modules for mono-bundle from:", sourceNodeModules);
+                        const existingTarget = await fs.readlink(monoBundleNodeModules);
+                        if (existingTarget === sourceNodeModules) {
+                            // Symlink already correct, skip
+                        }
+                        else {
+                            // Symlink points to wrong location, recreate
+                            await fs.rm(monoBundleNodeModules, { recursive: true, force: true });
+                            await fs.symlink(sourceNodeModules, monoBundleNodeModules, "dir");
+                            Logger.debug("Symlinked node_modules for mono-bundle from:", sourceNodeModules);
+                        }
                     }
-                    catch (err) {
-                        Logger.debug("Failed to symlink node_modules for mono-bundle:", err);
+                    catch {
+                        // Symlink doesn't exist, create it
+                        try {
+                            await fs.symlink(sourceNodeModules, monoBundleNodeModules, "dir");
+                            Logger.debug("Symlinked node_modules for mono-bundle from:", sourceNodeModules);
+                        }
+                        catch (err) {
+                            Logger.debug("Failed to symlink node_modules for mono-bundle:", err);
+                        }
                     }
                 }
                 return {
@@ -140,7 +149,8 @@ export const useNodeHandler = () => {
                 try {
                     await fs.symlink(path.resolve(dir), path.resolve(path.join(input.out, "node_modules")), "dir");
                 }
-                catch { }
+                catch {
+                }
             }
             // Rebuilt using existing esbuild context
             let ctx = rebuildCache[input.functionID]?.ctx;

package/runtime/handlers.js

@@ -57,9 +57,9 @@ export const useRuntimeHandlers = lazy(() => {
                     props: func,
                 });
                 // 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) {
-                    bus.publish("function.build.started", { functionID });
-                    bus.publish("function.build.success", { functionID, monoBundle: true });
                     return {
                         type: "success",
                         handler: monoBundleCheck.handler,
@@ -138,7 +138,7 @@ export const useRuntimeHandlers = lazy(() => {
 export const useFunctionBuilder = lazy(() => {
     const artifacts = new Map();
     const handlers = useRuntimeHandlers();
-    const semaphore = new Semaphore(4);
+    const semaphore = new Semaphore(parseInt(process.env.SST_BUILD_CONCURRENCY || "4", 10));
     const result = {
         artifact: (functionID) => {
             if (artifacts.has(functionID))
@@ -166,6 +166,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?.out.includes(".mono-build"))
+                    continue;
                 const handler = handlers.for(info.runtime);
                 if (!handler?.shouldBuild({
                     functionID,
@@ -176,7 +181,8 @@ export const useFunctionBuilder = lazy(() => {
                 Logger.debug("Rebuilt function", functionID);
             }
         }
-        catch { }
+        catch {
+        }
     });
     return result;
 });

package/runtime/iot.js

@@ -1,6 +1,7 @@
 import { useBus } from "../bus.js";
 import { useIOT } from "../iot.js";
 import { lazy } from "../util/lazy.js";
+import { logInvokeTrace } from "./worker-pool-logging.js";
 export const useIOTBridge = lazy(async () => {
     const bus = useBus();
     const iot = await useIOT();
@@ -12,6 +13,9 @@ export const useIOTBridge = lazy(async () => {
         iot.publish(topic + "/" + evt.properties.workerID, "function.error", evt.properties);
     });
     bus.subscribe("function.ack", async (evt) => {
-        iot.publish(topic + "/" + evt.properties.workerID, "function.ack", evt.properties);
+        const workerID = evt.properties.workerID;
+        logInvokeTrace("IOT_ACK_START", workerID, `worker=${workerID.slice(0, 8)}`);
+        await iot.publish(topic + "/" + workerID, "function.ack", evt.properties);
+        logInvokeTrace("IOT_ACK_DONE", workerID, `worker=${workerID.slice(0, 8)}`);
     });
 });

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;
+}>;

package/runtime/server.js

@@ -31,38 +31,52 @@ export const useRuntimeServer = lazy(async () => {
             workersWaiting.set(workerID, resolve);
         });
     }
-    workers.subscribe("worker.exited", async (evt) => {
-        const waiting = workersWaiting.get(evt.properties.workerID);
-        if (!waiting)
-            return;
-        workersWaiting.delete(evt.properties.workerID);
-    });
-    bus.subscribe("function.invoked", async (evt) => {
-        const worker = workersWaiting.get(evt.properties.workerID);
-        if (worker) {
-            workersWaiting.delete(evt.properties.workerID);
-            worker(evt.properties);
+    // Route an invocation to a specific workerID (used by workers.ts for pooled workers)
+    function routeInvocation(targetWorkerID, invocation) {
+        const waiting = workersWaiting.get(targetWorkerID);
+        if (waiting) {
+            workersWaiting.delete(targetWorkerID);
+            waiting(invocation);
             return;
         }
-        let arr = invocationsQueued.get(evt.properties.workerID);
+        let arr = invocationsQueued.get(targetWorkerID);
         if (!arr) {
             arr = [];
-            invocationsQueued.set(evt.properties.workerID, arr);
+            invocationsQueued.set(targetWorkerID, arr);
         }
-        arr.push(evt.properties);
+        arr.push(invocation);
+    }
+    workers.subscribe("worker.exited", async (evt) => {
+        const waiting = workersWaiting.get(evt.properties.workerID);
+        if (!waiting)
+            return;
+        workersWaiting.delete(evt.properties.workerID);
     });
+    // Note: function.invoked routing is handled by workers.ts via routeInvocation()
+    // This ensures correct routing for both pooled and non-pooled workers
     app.post(`/:workerID/${cfg.API_VERSION}/runtime/init/error`, express.json({
         strict: false,
         type: ["application/json", "application/*+json"],
         limit: "10mb",
     }), async (req, res) => {
-        const worker = workers.fromID(req.params.workerID);
+        const pooledWorkerID = req.params.workerID;
+        const worker = workers.fromID(pooledWorkerID);
+        if (!worker) {
+            res.status(404).send();
+            return;
+        }
+        // Get AWS workerID for IoT routing (if pooled)
+        const awsWorkerID = workers.isPooled(pooledWorkerID)
+            ? workers.getAwsWorkerID(pooledWorkerID) || pooledWorkerID
+            : pooledWorkerID;
         bus.publish("function.error", {
-            requestID: workers.getCurrentRequestID(worker.workerID),
-            workerID: worker.workerID,
+            requestID: workers.getCurrentRequestID(pooledWorkerID),
+            workerID: awsWorkerID,
             functionID: worker.functionID,
             ...req.body,
         });
+        // Return pooled worker to pool
+        workers.onResponse(pooledWorkerID);
         res.json("ok");
     });
     app.get(`/:workerID/${cfg.API_VERSION}/runtime/invocation/next`, async (req, res) => {
@@ -77,8 +91,15 @@ export const useRuntimeServer = lazy(async () => {
             "Lambda-Runtime-Cognito-Identity": JSON.stringify(payload.context.identity || null),
             "Lambda-Runtime-Log-Group-Name": payload.context.logGroupName,
             "Lambda-Runtime-Log-Stream-Name": payload.context.logStreamName,
+            // Pass function ID for mono-build shared pool: allows per-invocation dispatch
+            "Lambda-Runtime-Sst-Function-Id": payload.functionID,
+        });
+        // Wrap event with env for per-invocation environment variable application
+        // This prevents env leakage when workers are reused across different functions
+        res.json({
+            event: payload.event,
+            env: payload.env,
         });
-        res.json(payload.event);
     });
     app.post(`/:workerID/${cfg.API_VERSION}/runtime/invocation/:awsRequestId/response`, express.json({
         strict: false,
@@ -87,14 +108,25 @@ export const useRuntimeServer = lazy(async () => {
         },
         limit: "10mb",
     }), (req, res) => {
-        Logger.debug("Worker", req.params.workerID, "got response", req.body);
-        const worker = workers.fromID(req.params.workerID);
+        const pooledWorkerID = req.params.workerID;
+        Logger.debug("Worker", pooledWorkerID, "got response", req.body);
+        const worker = workers.fromID(pooledWorkerID);
+        if (!worker) {
+            res.status(404).send();
+            return;
+        }
+        // Get AWS workerID for IoT routing (if pooled)
+        const awsWorkerID = workers.isPooled(pooledWorkerID)
+            ? workers.getAwsWorkerID(pooledWorkerID) || pooledWorkerID
+            : pooledWorkerID;
         bus.publish("function.success", {
-            workerID: worker.workerID,
+            workerID: awsWorkerID,
             functionID: worker.functionID,
             requestID: req.params.awsRequestId,
             body: req.body,
         });
+        // Return pooled worker to pool
+        workers.onResponse(pooledWorkerID);
         res.status(202).send();
     });
     app.all(`/proxy*`, express.raw({
@@ -135,16 +167,30 @@ export const useRuntimeServer = lazy(async () => {
         type: ["application/json", "application/*+json"],
         limit: "10mb",
     }), (req, res) => {
-        const worker = workers.fromID(req.params.workerID);
+        const pooledWorkerID = req.params.workerID;
+        const worker = workers.fromID(pooledWorkerID);
+        if (!worker) {
+            res.status(404).send();
+            return;
+        }
+        // Get AWS workerID for IoT routing (if pooled)
+        const awsWorkerID = workers.isPooled(pooledWorkerID)
+            ? workers.getAwsWorkerID(pooledWorkerID) || pooledWorkerID
+            : pooledWorkerID;
         bus.publish("function.error", {
-            workerID: worker.workerID,
+            workerID: awsWorkerID,
             functionID: worker.functionID,
             errorType: req.body.errorType,
             errorMessage: req.body.errorMessage,
             requestID: req.params.awsRequestId,
             trace: req.body.trace,
         });
+        // Return pooled worker to pool
+        workers.onResponse(pooledWorkerID);
         res.status(202).send();
     });
     app.listen(cfg.port);
+    return {
+        routeInvocation,
+    };
 });

package/runtime/worker-pool-logging.d.ts

@@ -0,0 +1,29 @@
+export declare const POOL_SIZE: number;
+export declare const IDLE_TIMEOUT: number;
+/**
+ * Set the function name resolver callback
+ * Called by workers.ts to provide access to useFunctions()
+ */
+export declare function setFunctionNameResolver(resolver: (functionID: string) => string): void;
+/**
+ * Pool debug logging helper - writes to file with bottleneck detection
+ */
+export declare function logPool(action: string, details?: Record<string, any>): void;
+/**
+ * Track request lifecycle for metrics - called at request start
+ */
+export declare function trackRequestStart(functionID: string, isPoolHit: boolean): void;
+/**
+ * Track request lifecycle for metrics - called at request end
+ */
+export declare function trackRequestEnd(functionID: string): void;
+/**
+ * Write session end summary and close log stream
+ * Called from workers.ts on process exit
+ */
+export declare function writeSessionEndSummary(): void;
+/**
+ * Log invocation trace events to .sst/invoke-trace.log
+ * Always enabled for debugging invocation flow
+ */
+export declare function logInvokeTrace(stage: string, requestID: string, details?: string): void;

package/runtime/worker-pool-logging.js

@@ -0,0 +1,190 @@
+import fs from "fs";
+import path from "path";
+// Configuration
+const SST_BUILD_CONCURRENCY = parseInt(process.env.SST_BUILD_CONCURRENCY || "4", 10);
+export const POOL_SIZE = parseInt(process.env.SST_WORKER_POOL_SIZE || "10", 10);
+export const IDLE_TIMEOUT = parseInt(process.env.SST_WORKER_IDLE_TIMEOUT || "60000", 10);
+const DEBUG_POOL = process.env.SST_DEBUG_POOL === "true";
+const DEBUG_POOL_FILE = process.env.SST_DEBUG_POOL_FILE || ".sst/worker-pool.log";
+const INVOKE_TRACE_FILE = ".sst/invoke-trace.log";
+const metrics = {
+    coldStarts: new Map(),
+    concurrentRequests: new Map(),
+    peakConcurrent: new Map(),
+    totalRequests: new Map(),
+    poolHits: new Map(),
+    avgResponseTime: new Map(),
+    responseCount: new Map(),
+};
+let logStream = null;
+// Function name resolver - set by workers.ts
+let functionNameResolver = (id) => id.slice(0, 25);
+/**
+ * Set the function name resolver callback
+ * Called by workers.ts to provide access to useFunctions()
+ */
+export function setFunctionNameResolver(resolver) {
+    functionNameResolver = resolver;
+}
+function initLogFile() {
+    if (!DEBUG_POOL || logStream)
+        return;
+    try {
+        const logDir = path.dirname(DEBUG_POOL_FILE);
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+        logStream = fs.createWriteStream(DEBUG_POOL_FILE, { flags: "w" });
+        logStream.write("\n" + "=".repeat(100) + "\n" +
+            "[SESSION START] " + new Date().toISOString() + " | POOL_SIZE=" + POOL_SIZE + " IDLE_TIMEOUT=" + IDLE_TIMEOUT + "ms BUILD_CONCURRENCY=" + SST_BUILD_CONCURRENCY + "\n" +
+            "=".repeat(100) + "\n");
+    }
+    catch {
+        // Fall back to no logging if file creation fails
+    }
+}
+// Extract readable function name from handler path
+function getFunctionName(functionID) {
+    return functionNameResolver(functionID);
+}
+// Calculate bottleneck indicators
+function getBottleneckFlags(functionID) {
+    const flags = [];
+    const concurrent = metrics.concurrentRequests.get(functionID) || 0;
+    const total = metrics.totalRequests.get(functionID) || 0;
+    const hits = metrics.poolHits.get(functionID) || 0;
+    const hitRate = total > 0 ? (hits / total) * 100 : 0;
+    const coldStarts = metrics.coldStarts.get(functionID) || 0;
+    // SATURATED: All pool slots in use
+    if (concurrent >= POOL_SIZE) {
+        flags.push("🚨 SATURATED");
+    }
+    // HIGH_LOAD: >70% pool utilization
+    else if (concurrent >= POOL_SIZE * 0.7) {
+        flags.push("⚠️ HIGH_LOAD");
+    }
+    // COLD_START: Low hit rate indicates frequent cold starts
+    if (total >= 5 && hitRate < 30) {
+        flags.push("❄️ LOW_REUSE");
+    }
+    // BOTTLENECK: High cold start ratio
+    if (total >= 3 && coldStarts / total > 0.5) {
+        flags.push("🔥 COLD_HEAVY");
+    }
+    return flags.length > 0 ? " " + flags.join(" ") : "";
+}
+/**
+ * Pool debug logging helper - writes to file with bottleneck detection
+ */
+export function logPool(action, details = {}) {
+    if (!DEBUG_POOL)
+        return;
+    initLogFile();
+    const timestamp = new Date().toISOString().slice(11, 23); // HH:MM:SS.mmm
+    const funcName = details.functionID
+        ? getFunctionName(details.functionID)
+        : "";
+    const bottleneckFlags = details.functionID &&
+        ["CREATE", "REUSE", "POOL_MISS", "RESPONSE"].includes(action)
+        ? getBottleneckFlags(details.functionID)
+        : "";
+    // Build metrics string for key actions
+    let metricsStr = "";
+    if (details.functionID && ["RESPONSE", "RETURN_TO_POOL"].includes(action)) {
+        const concurrent = metrics.concurrentRequests.get(details.functionID) || 0;
+        const total = metrics.totalRequests.get(details.functionID) || 0;
+        const hits = metrics.poolHits.get(details.functionID) || 0;
+        const hitRate = total > 0 ? ((hits / total) * 100).toFixed(0) : "0";
+        metricsStr = " | concurrent=" + concurrent + " hitRate=" + hitRate + "%";
+    }
+    // Format details, replacing functionID with funcName
+    const filteredDetails = { ...details };
+    delete filteredDetails.functionID;
+    const detailStr = Object.entries(filteredDetails)
+        .map(([k, v]) => k + "=" + (typeof v === "object" ? JSON.stringify(v) : v))
+        .join(" ");
+    const actionPadded = action.padEnd(14);
+    const funcPadded = funcName.padEnd(25);
+    const line = "[" + timestamp + "] " + actionPadded + " " + funcPadded + " " + detailStr + metricsStr + bottleneckFlags + "\n";
+    if (logStream) {
+        logStream.write(line);
+    }
+}
+/**
+ * Track request lifecycle for metrics - called at request start
+ */
+export function trackRequestStart(functionID, isPoolHit) {
+    const current = (metrics.concurrentRequests.get(functionID) || 0) + 1;
+    metrics.concurrentRequests.set(functionID, current);
+    metrics.totalRequests.set(functionID, (metrics.totalRequests.get(functionID) || 0) + 1);
+    const peak = metrics.peakConcurrent.get(functionID) || 0;
+    if (current > peak) {
+        metrics.peakConcurrent.set(functionID, current);
+    }
+    if (isPoolHit) {
+        metrics.poolHits.set(functionID, (metrics.poolHits.get(functionID) || 0) + 1);
+    }
+    else {
+        metrics.coldStarts.set(functionID, (metrics.coldStarts.get(functionID) || 0) + 1);
+    }
+}
+/**
+ * Track request lifecycle for metrics - called at request end
+ */
+export function trackRequestEnd(functionID) {
+    const current = metrics.concurrentRequests.get(functionID) || 0;
+    if (current > 0) {
+        metrics.concurrentRequests.set(functionID, current - 1);
+    }
+}
+/**
+ * Write session end summary and close log stream
+ * Called from workers.ts on process exit
+ */
+export function writeSessionEndSummary() {
+    if (!DEBUG_POOL || !logStream)
+        return;
+    let summary = "\n" + "─".repeat(100) + "\n[SESSION END] " + new Date().toISOString() + "\n";
+    for (const [funcID, total] of metrics.totalRequests) {
+        const hits = metrics.poolHits.get(funcID) || 0;
+        const cold = metrics.coldStarts.get(funcID) || 0;
+        const peak = metrics.peakConcurrent.get(funcID) || 0;
+        const hitRate = total > 0 ? ((hits / total) * 100).toFixed(1) : "0";
+        const funcName = getFunctionName(funcID);
+        summary += "  " + funcName.padEnd(25) + " total=" + total + " poolHits=" + hits + " coldStarts=" + cold + " peakConcurrent=" + peak + " hitRate=" + hitRate + "%\n";
+    }
+    summary += "─".repeat(100) + "\n";
+    logStream.write(summary);
+    logStream.end();
+}
+// Invocation trace logging - always enabled, writes to separate file
+let traceStream = null;
+function initTraceFile() {
+    if (traceStream)
+        return;
+    try {
+        const logDir = path.dirname(INVOKE_TRACE_FILE);
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+        traceStream = fs.createWriteStream(INVOKE_TRACE_FILE, { flags: "w" });
+        traceStream.write("\n" + "=".repeat(80) + "\n" +
+            "[TRACE START] " + new Date().toISOString() + "\n" +
+            "=".repeat(80) + "\n");
+    }
+    catch {
+        // Fall back to no logging if file creation fails
+    }
+}
+/**
+ * Log invocation trace events to .sst/invoke-trace.log
+ * Always enabled for debugging invocation flow
+ */
+export function logInvokeTrace(stage, requestID, details) {
+    initTraceFile();
+    if (!traceStream)
+        return;
+    const timestamp = new Date().toISOString().slice(11, 23); // HH:MM:SS.mmm
+    const line = `[${timestamp}] ${stage.padEnd(20)} req=${requestID.slice(0, 8)} ${details || ""}\n`;
+    traceStream.write(line);
+}

package/runtime/workers.d.ts

@@ -18,20 +18,26 @@ declare module "../bus.js" {
             requestID: string;
             message: string;
         };
+        "worker.reused": {
+            workerID: string;
+            functionID: string;
+            pooledWorkerID: string;
+        };
     }
 }
-interface Worker {
-    workerID: string;
-    functionID: string;
-}
 export declare const useRuntimeWorkers: () => Promise<{
-    fromID(workerID: string): Worker;
+    fromID(workerID: string): {
+        workerID: string;
+        functionID: string;
+    };
     getCurrentRequestID(workerID: string): string | undefined;
     stdout(workerID: string, message: string): void;
     exited(workerID: string): void;
-    subscribe: <Type extends "worker.started" | "worker.stopped" | "worker.exited" | "worker.stdout">(type: Type, cb: (payload: import("../bus.js").EventPayload<Type>) => void) => {
+    onResponse(pooledWorkerID: string): void;
+    getAwsWorkerID(pooledWorkerID: string): string | undefined;
+    isPooled(workerID: string): boolean;
+    subscribe: <Type extends "worker.started" | "worker.stopped" | "worker.exited" | "worker.stdout" | "worker.reused">(type: Type, cb: (payload: import("../bus.js").EventPayload<Type>) => void) => {
         type: keyof import("../bus.js").Events;
         cb: (payload: any) => void;
     };
 }>;
-export {};