@intelligems/sst 2.49.6-ig.1 → 2.49.6-ig.3

package/cli/commands/dev.js

@@ -92,9 +92,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);

package/package.json

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

package/package.json.bak

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

package/runtime/handlers/node.js

@@ -61,6 +61,48 @@ 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}`));
+                // 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 handlerFunctionsDir = path.join(project.paths.root, "web/node-backend/src");
+                const root = await findAbove(handlerFunctionsDir, "package.json");
+                if (root) {
+                    const sourceNodeModules = path.resolve(root, "node_modules");
+                    const monoBundleNodeModules = path.join(monoBundleDir, "node_modules");
+                    try {
+                        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 {
+                        // 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 {
+                    type: "success",
+                    handler: "index.handler",
+                    out: monoBundleDir,
+                };
+            }
             const parsed = path.parse(input.props.handler);
             const file = [
                 ".ts",
@@ -108,7 +150,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.d.ts

@@ -6,6 +6,7 @@ declare module "../bus.js" {
         };
         "function.build.success": {
             functionID: string;
+            monoBundle?: boolean;
         };
         "function.build.failed": {
             functionID: string;
@@ -41,6 +42,7 @@ export interface RuntimeHandler {
         type: "success";
         handler: string;
         sourcemap?: string;
+        out?: string;
     } | {
         type: "error";
         errors: string[];
@@ -57,10 +59,10 @@ export declare const useRuntimeHandlers: () => {
         type: "error";
         errors: string[];
     } | {
-        out: string;
-        sourcemap: string | undefined;
         type: "success";
         handler: string;
+        out: string;
+        sourcemap: string | undefined;
     }>;
 };
 interface Artifact {

package/runtime/handlers.js

@@ -48,6 +48,26 @@ export const useRuntimeHandlers = lazy(() => {
                     };
                 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
+                // In mono-bundle mode, handler returns its own out path immediately without building
+                const monoBundleCheck = await handler.build({
+                    functionID,
+                    out,
+                    mode,
+                    props: func,
+                });
+                // If mono-bundle detected (handler returned custom out), skip all artifact work
+                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,
+                        out: monoBundleCheck.out,
+                        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 });

package/support/nodejs-runtime/index.mjs

@@ -7,10 +7,22 @@ import fs from "fs";
 import http from "http";
 import url from "url";
 var input = workerData;
-var parsed = path.parse(input.handler);
-var file = [".js", ".jsx", ".mjs", ".cjs"].map((ext) => path.join(input.out, parsed.dir, parsed.name + ext)).find((file2) => {
-  return fs.existsSync(file2);
-});
+var monoBundlePath = path.join(input.out, "index.mjs");
+var useMonoBundle = input.handler === "index.handler" && fs.existsSync(monoBundlePath);
+var file;
+var handlerName;
+if (useMonoBundle) {
+  file = monoBundlePath;
+  handlerName = "handler";
+} else {
+  const parsed = path.parse(input.handler);
+  const foundFile = [".js", ".jsx", ".mjs", ".cjs"].map((ext) => path.join(input.out, parsed.dir, parsed.name + ext)).find((f) => fs.existsSync(f));
+  if (!foundFile) {
+    throw new Error(`Could not find handler file for "${input.handler}"`);
+  }
+  file = foundFile;
+  handlerName = parsed.ext.substring(1);
+}
 var fn;
 function fetch(req) {
   return new Promise((resolve, reject) => {
@@ -44,11 +56,10 @@ function fetch(req) {
 try {
   const { href } = url.pathToFileURL(file);
   const mod = await import(href);
-  const handler = parsed.ext.substring(1);
-  fn = mod[handler];
+  fn = mod[handlerName];
   if (!fn) {
     throw new Error(
-      `Function "${handler}" not found in "${input.handler}". Found ${Object.keys(mod).join(", ")}`
+      useMonoBundle ? `Mono-bundle handler "${handlerName}" not found in "${file}". Found: ${Object.keys(mod).join(", ")}` : `Function "${handlerName}" not found in "${input.handler}". Found: ${Object.keys(mod).join(", ")}`
     );
   }
 } catch (ex) {