@intelligems/sst 2.49.3 → 2.49.6-ig.10

package/cli/commands/dev.js

@@ -36,6 +36,13 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
             const colors = ["#01cdfe", "#ff71ce", "#05ffa1", "#b967ff"];
             let index = 0;
             const pending = new Map();
+            // Track warmup request IDs to suppress their logs
+            const warmupRequestIDs = new Set();
+            // Helper to check if an event payload is a warmup request
+            function isWarmupEvent(event) {
+                return event && typeof event === 'object' &&
+                    ('ding' in event || 'warmer' in event || event.__sst_warmup === true);
+            }
             function prefix(requestID) {
                 const exists = pending.get(requestID);
                 if (exists) {
@@ -53,14 +60,54 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
                 // index--;
                 // if (index < 0) index = colors.length - 1;
                 pending.delete(requestID);
+                warmupRequestIDs.delete(requestID);
             }
+            // Warmup progress bar state
+            let warmupSpinner = null;
+            let warmupTotal = 0;
+            let warmupCompleted = 0;
+            bus.subscribe("warmup.start", async (evt) => {
+                warmupTotal = evt.properties.count;
+                warmupCompleted = 0;
+                warmupSpinner = createSpinner({
+                    color: "cyan",
+                    text: Colors.dim(` Warming up workers... 0/${warmupTotal}`),
+                }).start();
+            });
+            bus.subscribe("warmup.progress", async (evt) => {
+                warmupCompleted = evt.properties.completed;
+                if (warmupSpinner) {
+                    warmupSpinner.text = Colors.dim(` Warming up workers... ${warmupCompleted}/${warmupTotal}`);
+                }
+            });
+            bus.subscribe("warmup.complete", async (evt) => {
+                if (warmupSpinner) {
+                    warmupSpinner.succeed(Colors.dim(` Warmed up ${evt.properties.success} workers in ${evt.properties.elapsedMs}ms`));
+                    warmupSpinner = null;
+                }
+            });
             bus.subscribe("function.invoked", async (evt) => {
+                // Check if this is a warmup request and track it
+                if (isWarmupEvent(evt.properties.event)) {
+                    warmupRequestIDs.add(evt.properties.requestID);
+                    return; // Don't log warmup invocations
+                }
                 Colors.line(prefix(evt.properties.requestID), Colors.dim.bold("Invoked"), Colors.dim(useFunctions().fromID(evt.properties.functionID)?.handler));
             });
             bus.subscribe("worker.stdout", async (evt) => {
+                if (evt.properties.message.includes('[LOG]')) {
+                    console.log(evt.properties.message);
+                    return;
+                }
+                // Skip warmup request logs
+                if (warmupRequestIDs.has(evt.properties.requestID))
+                    return;
                 const info = useFunctions().fromID(evt.properties.functionID);
                 prefix(evt.properties.requestID);
-                const { started } = pending.get(evt.properties.requestID);
+                const pendingReq = pending.get(evt.properties.requestID);
+                if (!pendingReq)
+                    return; // Safety check
+                const { started } = pendingReq;
                 for (let line of evt.properties.message.split("\n")) {
                     // Remove prefix from container logs
                     if (info?.runtime === "container") {
@@ -92,9 +139,10 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
                     return;
                 if (info.enableLiveDev === false)
                     return;
+                const buildType = evt.properties.monoBundle ? "(mono-bundle)" : "(individual)";
                 Colors.line(info.runtime === "container"
-                    ? Colors.dim(Colors.prefix, "Built", info.handler, "container")
-                    : Colors.dim(Colors.prefix, "Built", info.handler));
+                    ? Colors.dim(Colors.prefix, "Built", info.handler, "container", buildType)
+                    : Colors.dim(Colors.prefix, "Built", info.handler, buildType));
             });
             bus.subscribe("function.build.failed", async (evt) => {
                 const info = useFunctions().fromID(evt.properties.functionID);
@@ -110,15 +158,27 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
                 Colors.gap();
             });
             bus.subscribe("function.success", async (evt) => {
+                // Skip warmup request logs
+                if (warmupRequestIDs.has(evt.properties.requestID)) {
+                    end(evt.properties.requestID);
+                    return;
+                }
                 // stdout logs sometimes come in after
                 const p = prefix(evt.properties.requestID);
                 const req = pending.get(evt.properties.requestID);
+                if (!req)
+                    return; // Safety check
                 setTimeout(() => {
                     Colors.line(p, Colors.dim(`Done in ${Date.now() - req.started - 100}ms`));
                     end(evt.properties.requestID);
                 }, 100);
             });
             bus.subscribe("function.error", async (evt) => {
+                // Skip warmup request logs
+                if (warmupRequestIDs.has(evt.properties.requestID)) {
+                    end(evt.properties.requestID);
+                    return;
+                }
                 setTimeout(() => {
                     Colors.line(prefix(evt.properties.requestID), Colors.danger.bold("Error:"), Colors.danger.bold(evt.properties.errorMessage));
                     for (const line of evt.properties.trace || []) {
@@ -341,6 +401,12 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
             import("./plugins/warmer.js").then((mod) => mod.useRDSWarmer()),
             useFunctionLogger(),
         ]);
+        // Trigger warmup by invoking Lambda functions with warmup payloads
+        // This creates workers through the real request flow
+        import("../../runtime/workers.js").then(async (mod) => {
+            const workers = await mod.useRuntimeWorkers();
+            await workers.triggerWarmup(30);
+        });
     }
     catch (e) {
         await exitWithError(e);

package/cli/sst.js

@@ -40,7 +40,6 @@ version(program);
 telemetry(program);
 types(program);
 if ("setSourceMapsEnabled" in process) {
-    // @ts-expect-error
     process.setSourceMapsEnabled(true);
 }
 process.removeAllListeners("uncaughtException");

package/constructs/Function.d.ts

@@ -24,6 +24,7 @@ declare const supportedRuntimes: {
     "python3.10": CDKRuntime;
     "python3.11": CDKRuntime;
     "python3.12": CDKRuntime;
+    "python3.13": CDKRuntime;
     "dotnetcore3.1": CDKRuntime;
     dotnet6: CDKRuntime;
     dotnet8: CDKRuntime;
@@ -798,7 +799,7 @@ export declare class Function extends CDKFunction implements SSTConstruct {
         type: "Function";
         data: {
             arn: string;
-            runtime: "container" | "rust" | "nodejs16.x" | "nodejs18.x" | "nodejs20.x" | "nodejs22.x" | "python3.7" | "python3.8" | "python3.9" | "python3.10" | "python3.11" | "python3.12" | "dotnetcore3.1" | "dotnet6" | "dotnet8" | "java8" | "java11" | "java17" | "java21" | "go1.x" | "go" | undefined;
+            runtime: "container" | "rust" | "nodejs16.x" | "nodejs18.x" | "nodejs20.x" | "nodejs22.x" | "python3.7" | "python3.8" | "python3.9" | "python3.10" | "python3.11" | "python3.12" | "python3.13" | "dotnetcore3.1" | "dotnet6" | "dotnet8" | "java8" | "java11" | "java17" | "java21" | "go1.x" | "go" | undefined;
             handler: string | undefined;
             missingSourcemap: boolean | undefined;
             localId: string;

package/constructs/Function.js

@@ -43,6 +43,7 @@ const supportedRuntimes = {
     "python3.10": CDKRuntime.PYTHON_3_10,
     "python3.11": CDKRuntime.PYTHON_3_11,
     "python3.12": CDKRuntime.PYTHON_3_12,
+    "python3.13": CDKRuntime.PYTHON_3_13,
     "dotnetcore3.1": CDKRuntime.DOTNET_CORE_3_1,
     dotnet6: CDKRuntime.DOTNET_6,
     dotnet8: CDKRuntime.DOTNET_8,
@@ -216,18 +217,18 @@ export class Function extends CDKFunction {
                     ? {
                         code: Code.fromInline("export function placeholder() {}"),
                         handler: "index.placeholder",
-                        runtime: CDKRuntime.NODEJS_20_X,
+                        runtime: CDKRuntime.NODEJS_22_X,
                         layers: undefined,
                     }
                     : props.code ? {
                         code: props.code,
                         handler: "index.handler",
-                        runtime: CDKRuntime.NODEJS_20_X,
+                        runtime: CDKRuntime.NODEJS_22_X,
                         layers: Function.buildLayers(scope, id, props),
                     } : {
                         code: Code.fromInline("export function placeholder() {}"),
                         handler: "index.placeholder",
-                        runtime: CDKRuntime.NODEJS_20_X,
+                        runtime: CDKRuntime.NODEJS_22_X,
                         layers: Function.buildLayers(scope, id, props),
                     }),
                 architecture,

package/credentials.js

@@ -1,4 +1,5 @@
 import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 import { fromNodeProviderChain } from "@aws-sdk/credential-providers";
 import { GetCallerIdentityCommand, STSClient } from "@aws-sdk/client-sts";
 import { Logger } from "./logger.js";
@@ -121,9 +122,9 @@ export function useAWSClient(client, force = false) {
 }
 export const useAWSProvider = lazy(async () => {
     const cdkToolkitUrl = await import.meta.resolve("@aws-cdk/toolkit-lib");
-    const cdkToolkitPath = new URL(cdkToolkitUrl).pathname;
-    const { SdkProvider } = await import(path.resolve(cdkToolkitPath, "..", "api", "aws-auth", "sdk-provider.js"));
-    const { IoHelper } = await import(path.resolve(cdkToolkitPath, "..", "api", "io", "private", "io-helper.js"));
+    const cdkToolkitPath = fileURLToPath(cdkToolkitUrl);
+    const { SdkProvider } = await import(pathToFileURL(path.resolve(cdkToolkitPath, "..", "api", "aws-auth", "sdk-provider.js")).href);
+    const { IoHelper } = await import(pathToFileURL(path.resolve(cdkToolkitPath, "..", "api", "io", "private", "io-helper.js")).href);
     const project = useProject();
     return new SdkProvider(useAWSCredentialsProvider(), project.config.region, {
         ioHelper: IoHelper.fromActionAwareIoHost({

package/iot.d.ts

@@ -4,4 +4,35 @@ export declare const useIOT: () => Promise<{
     prefix: string;
     publish<Type extends keyof Events>(topic: string, type: Type, properties: Events[Type]): Promise<void>;
 }>;
+/**
+ * A second connection, carrying only small control messages.
+ *
+ * `useIOT` also carries response bodies. Those are fragmented into 50KB chunks
+ * and published at QoS 1, so every chunk waits on a broker round trip, and they
+ * queue on the same socket as everything else.
+ *
+ * `function.ack` cannot afford to wait behind them. The Lambda re-invokes if the
+ * ack does not arrive within two seconds, and each re-invocation re-runs the
+ * handler and puts another response body on the socket that is already busy —
+ * so a late ack makes the next ack later still. Measured on one machine before
+ * this change: ack publish went from 105ms to 10.2s inside a minute, publishes
+ * in flight from 15 to 439, and a single request executed fifteen times before
+ * the gateway returned 504 at 29s.
+ *
+ * Round-trip latency decides who sees it. A chunk costs a round trip to the
+ * region — roughly 90ms from Europe against 15ms from the US — so the same
+ * payload lands either side of the two second budget depending on where the
+ * developer sits.
+ *
+ * **The client id must differ from `useIOT`'s.** AWS IoT drops an existing
+ * connection when a new one presents the same id, so a shared id would make the
+ * two sockets disconnect each other in a loop.
+ *
+ * This connection deliberately does not subscribe. Inbound traffic still arrives
+ * on `useIOT`; this one only publishes.
+ */
+export declare const useIOTControl: () => Promise<{
+    prefix: string;
+    publish<Type extends keyof Events>(topic: string, type: Type, properties: Events[Type]): Promise<void>;
+}>;
 export declare const isSupported: () => boolean;

package/iot.js

@@ -1,6 +1,11 @@
 import { IoTClient, DescribeEndpointCommand } from "@aws-sdk/client-iot";
 import { useAWSClient, useAWSCredentials } from "./credentials.js";
 import { VisibleError } from "./error.js";
+import { lazy } from "./util/lazy.js";
+import { Logger } from "./logger.js";
+import { logIotRx } from "./runtime/debug-bridge-logging.js";
+import { logEventTrace } from "./runtime/event-trace-logging.js";
+import { getRequestPath, getCorrelationId, getApiGatewayRequestId, getHttpMethod } from "./runtime/request-utils.js";
 export const useIOTEndpoint = lazy(async () => {
     const iot = useAWSClient(IoTClient);
     Logger.debug("Getting IoT endpoint");
@@ -15,10 +20,61 @@ export const useIOTEndpoint = lazy(async () => {
 import iot from "aws-iot-device-sdk";
 import { useBus } from "./bus.js";
 import { useProject } from "./project.js";
-import { Logger } from "./logger.js";
 import { useBootstrap } from "./bootstrap.js";
 import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
-import { lazy } from "./util/lazy.js";
+/**
+ * Re-sign the next reconnect with credentials that are still alive.
+ *
+ * The device is built with resolved credential *values*, because
+ * `aws-iot-device-sdk` takes strings rather than a provider. It keeps them in
+ * closure variables and re-signs the WebSocket URL from those on every
+ * reconnect, and nothing ever writes to them again except this call. So once
+ * the session expires, every retry presents a dead `sessionToken`, AWS IoT
+ * rejects the upgrade, and the socket closes again — forever.
+ *
+ * Measured on one machine: the connection dropped routinely five times in the
+ * first fifteen minutes and recovered each time; an hour later the credentials
+ * expired, and the next drop began **93 consecutive failed reconnects over five
+ * hours**, none of which emitted an `error` event. Nothing in the CLI said
+ * anything, and every request through the Live Lambda bridge 504'd.
+ *
+ * Every other AWS call in the process is unaffected, because `useAWSClient`
+ * passes the *provider* and the SDK calls it per request. This is the one path
+ * that holds values, so it is the one path that needs telling.
+ *
+ * **Why `close` and not `reconnect`.** The signing is synchronous and this
+ * refresh is not, so the two race. `emit("reconnect")` runs its handlers and
+ * returns — it does not await them — and `_setupStream()` signs on the next
+ * line, from whatever the variables hold at that instant. A refresh started
+ * there always loses. `close` fires one backoff interval earlier (the SDK
+ * manages its own, from `baseReconnectTimeMs` of 1s up to 128s, ignoring the
+ * `reconnectPeriod` passed in), which is ample for the resolve to land before
+ * the next attempt signs.
+ *
+ * So this wins the race by margin, not by construction. Two things bound it:
+ * `close` fires on **every** failed reconnect, not once per outage, so the
+ * values can never be more than one backoff interval stale; and the retry loop
+ * is unconditional. Making it airtight would mean keeping the stored
+ * credentials warm so the synchronous path can never read a stale one — a
+ * timer, which is machinery duplicating what the memoized provider already
+ * does. Measured recovery is five seconds, so that is not worth it yet.
+ *
+ * The provider only reaches the network within five minutes of expiry, so this
+ * is an in-memory read on most drops and one real refresh per session.
+ */
+async function refreshWebSocketCredentials(device, label) {
+    try {
+        const fresh = await useAWSCredentials();
+        // The typings mark `expiration` as required, but the implementation only
+        // assigns the three credential strings and never reads it — so this passes
+        // what the provider gave rather than inventing a date to satisfy a
+        // parameter nothing uses.
+        device.updateWebSocketCredentials(fresh.accessKeyId, fresh.secretAccessKey, fresh.sessionToken, fresh.expiration);
+    }
+    catch (err) {
+        Logger.debug(`${label} credential refresh failed`, err);
+    }
+}
 export const useIOT = lazy(async () => {
     const bus = useBus();
     const endpoint = await useIOTEndpoint();
@@ -113,6 +169,7 @@ export const useIOT = lazy(async () => {
     });
     device.on("close", () => {
         Logger.debug("IoT closed");
+        void refreshWebSocketCredentials(device, "IoT");
     });
     device.on("reconnect", () => {
         Logger.debug("IoT reconnecting...");
@@ -120,6 +177,19 @@ export const useIOT = lazy(async () => {
     device.on("message", (_topic, buffer) => {
         const fragment = JSON.parse(buffer.toString());
         if (!fragment.id) {
+            const requestID = fragment.properties?.requestID;
+            logIotRx(`Received ${fragment.type} reqId=${requestID?.slice(0, 8) || 'N/A'}`);
+            if (fragment.type === "function.invoked" && requestID) {
+                const event = fragment.properties?.event;
+                logEventTrace("IOT_RECEIVED", {
+                    requestID,
+                    functionID: fragment.properties?.functionID,
+                    path: getRequestPath(event),
+                    method: getHttpMethod(event),
+                    correlationId: getCorrelationId(event),
+                    apiGwReqId: getApiGatewayRequestId(event),
+                });
+            }
             bus.publish(fragment.type, fragment.properties);
             return;
         }
@@ -138,6 +208,20 @@ export const useIOT = lazy(async () => {
             const evt = JSON.parse(data);
             if (evt.sourceID === bus.sourceID)
                 return;
+            const requestID = evt.properties?.requestID;
+            logIotRx(`Received ${evt.type} reqId=${requestID?.slice(0, 8) || 'N/A'} (${fragment.count} fragments)`);
+            if (evt.type === "function.invoked" && requestID) {
+                const event = evt.properties?.event;
+                logEventTrace("IOT_RECEIVED", {
+                    requestID,
+                    functionID: evt.properties?.functionID,
+                    path: getRequestPath(event),
+                    method: getHttpMethod(event),
+                    correlationId: getCorrelationId(event),
+                    apiGwReqId: getApiGatewayRequestId(event),
+                    fragments: fragment.count,
+                });
+            }
             bus.publish(evt.type, evt.properties);
         }
     });
@@ -149,19 +233,96 @@ 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);
         },
     };
 });
+/**
+ * A second connection, carrying only small control messages.
+ *
+ * `useIOT` also carries response bodies. Those are fragmented into 50KB chunks
+ * and published at QoS 1, so every chunk waits on a broker round trip, and they
+ * queue on the same socket as everything else.
+ *
+ * `function.ack` cannot afford to wait behind them. The Lambda re-invokes if the
+ * ack does not arrive within two seconds, and each re-invocation re-runs the
+ * handler and puts another response body on the socket that is already busy —
+ * so a late ack makes the next ack later still. Measured on one machine before
+ * this change: ack publish went from 105ms to 10.2s inside a minute, publishes
+ * in flight from 15 to 439, and a single request executed fifteen times before
+ * the gateway returned 504 at 29s.
+ *
+ * Round-trip latency decides who sees it. A chunk costs a round trip to the
+ * region — roughly 90ms from Europe against 15ms from the US — so the same
+ * payload lands either side of the two second budget depending on where the
+ * developer sits.
+ *
+ * **The client id must differ from `useIOT`'s.** AWS IoT drops an existing
+ * connection when a new one presents the same id, so a shared id would make the
+ * two sockets disconnect each other in a loop.
+ *
+ * This connection deliberately does not subscribe. Inbound traffic still arrives
+ * on `useIOT`; this one only publishes.
+ */
+export const useIOTControl = lazy(async () => {
+    const bus = useBus();
+    const endpoint = await useIOTEndpoint();
+    const creds = await useAWSCredentials();
+    const project = useProject();
+    const device = new iot.device({
+        protocol: "wss",
+        host: endpoint,
+        region: project.config.region,
+        accessKeyId: creds.accessKeyId,
+        secretKey: creds.secretAccessKey,
+        sessionToken: creds.sessionToken,
+        reconnectPeriod: 1,
+        keepalive: 60,
+        clientId: `sst-control-${Math.random().toString(16).slice(2)}`,
+    });
+    const PREFIX = `/sst/${project.config.name}/${project.config.stage}`;
+    device.on("connect", () => {
+        Logger.debug("IoT control connected");
+    });
+    device.on("error", (err) => {
+        Logger.debug("IoT control error", err);
+    });
+    device.on("close", () => {
+        Logger.debug("IoT control closed");
+        void refreshWebSocketCredentials(device, "IoT control");
+    });
+    device.on("reconnect", () => {
+        Logger.debug("IoT control reconnecting...");
+    });
+    return {
+        prefix: PREFIX,
+        async publish(topic, type, properties) {
+            const payload = {
+                type,
+                properties,
+                sourceID: bus.sourceID,
+            };
+            // Control messages sit far below the fragment size, but the envelope has
+            // to match what the Lambda reassembles, so it is built the same way
+            // rather than assumed to be a single part.
+            const json = JSON.stringify(payload);
+            const parts = json.match(/.{1,50000}/g) ?? [];
+            const id = Math.random().toString();
+            await Promise.all(parts.map((data, index) => new Promise((r) => {
+                device.publish(topic, JSON.stringify({ id, index, count: parts.length, data }), { qos: 1 }, () => {
+                    r();
+                });
+            })));
+            Logger.debug("IOT Control Published", topic, type);
+        },
+    };
+});
 export const isSupported = () => [
     "eu-central-1",
     "eu-west-1",

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "@intelligems/sst",
-  "version": "2.49.3",
+  "version": "2.49.6-ig.10",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -113,7 +113,7 @@
     "@types/babel__generator": "^7.6.4",
     "@types/cross-spawn": "^6.0.2",
     "@types/express": "^4.17.14",
-    "@types/node": "18.11.9",
+    "@types/node": "22.13.14",
     "@types/react": "^18.0.28",
     "@types/uuid": "^8.3.4",
     "@types/ws": "8.5.3",

package/runtime/debug-bridge-logging.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Log debug message for workers component
+ * Outputs to console and optionally to .sst/debug-workers.log
+ */
+export declare function logWorkers(message: string, details?: Record<string, any>): void;
+/**
+ * Log debug message for server component
+ * Outputs to console and optionally to .sst/debug-server.log
+ */
+export declare function logServer(message: string, details?: Record<string, any>): void;
+/**
+ * Log debug message for IoT component (publishing)
+ * Outputs to console and optionally to .sst/debug-iot.log
+ */
+export declare function logIot(message: string, details?: Record<string, any>): void;
+/**
+ * Log debug message for IoT component (receiving)
+ * Outputs to console and optionally to .sst/debug-iot.log
+ */
+export declare function logIotRx(message: string, details?: Record<string, any>): void;
+/**
+ * Check if bridge debug logging is enabled
+ */
+export declare function isDebugBridgeEnabled(): boolean;

package/runtime/debug-bridge-logging.js

@@ -0,0 +1,98 @@
+import { createDebugFileLogger } from "./debug-file-logger.js";
+/**
+ * Debug logging for SST dev bridge components
+ *
+ * Enable with: SST_DEBUG_BRIDGE=true
+ *
+ * Log files:
+ * - .sst/debug-workers.log - Worker pool and invocation handling
+ * - .sst/debug-server.log  - Runtime server request/response handling
+ * - .sst/debug-iot.log     - IoT message publishing and receiving
+ */
+const DEBUG_BRIDGE = process.env.SST_DEBUG_BRIDGE === "true";
+// Lazy-initialized loggers
+let workersLogger = null;
+let serverLogger = null;
+let iotLogger = null;
+function getWorkersLogger() {
+    if (!DEBUG_BRIDGE)
+        return null;
+    if (!workersLogger) {
+        workersLogger = createDebugFileLogger({
+            filePath: ".sst/debug-workers.log",
+            sessionName: "WORKERS",
+            width: 120,
+        });
+    }
+    return workersLogger;
+}
+function getServerLogger() {
+    if (!DEBUG_BRIDGE)
+        return null;
+    if (!serverLogger) {
+        serverLogger = createDebugFileLogger({
+            filePath: ".sst/debug-server.log",
+            sessionName: "SERVER",
+            width: 120,
+        });
+    }
+    return serverLogger;
+}
+function getIotLogger() {
+    if (!DEBUG_BRIDGE)
+        return null;
+    if (!iotLogger) {
+        iotLogger = createDebugFileLogger({
+            filePath: ".sst/debug-iot.log",
+            sessionName: "IOT",
+            width: 120,
+        });
+    }
+    return iotLogger;
+}
+/**
+ * Log debug message for workers component
+ * Outputs to console and optionally to .sst/debug-workers.log
+ */
+export function logWorkers(message, details) {
+    const logger = getWorkersLogger();
+    if (logger) {
+        logger.log("WORKERS", { msg: message, ...details });
+    }
+}
+/**
+ * Log debug message for server component
+ * Outputs to console and optionally to .sst/debug-server.log
+ */
+export function logServer(message, details) {
+    const logger = getServerLogger();
+    if (logger) {
+        logger.log("SERVER", { msg: message, ...details });
+    }
+}
+/**
+ * Log debug message for IoT component (publishing)
+ * Outputs to console and optionally to .sst/debug-iot.log
+ */
+export function logIot(message, details) {
+    const logger = getIotLogger();
+    if (logger) {
+        logger.log("IOT", { msg: message, ...details });
+    }
+}
+/**
+ * Log debug message for IoT component (receiving)
+ * Outputs to console and optionally to .sst/debug-iot.log
+ */
+export function logIotRx(message, details) {
+    const logger = getIotLogger();
+    if (logger) {
+        logger.log("IOT-RX", { msg: message, ...details });
+    }
+}
+/**
+ * Check if bridge debug logging is enabled
+ */
+export function isDebugBridgeEnabled() {
+    return DEBUG_BRIDGE;
+}