SSG stuff

cmake/sources/ZigSources.txt

@@ -304,12 +304,14 @@ src/bundler/linker_context/generateCodeForLazyExport.zig
 src/bundler/linker_context/generateCompileResultForCssChunk.zig
 src/bundler/linker_context/generateCompileResultForHtmlChunk.zig
 src/bundler/linker_context/generateCompileResultForJSChunk.zig
+src/bundler/linker_context/OutputFileListBuilder.zig
 src/bundler/linker_context/postProcessCSSChunk.zig
 src/bundler/linker_context/postProcessHTMLChunk.zig
 src/bundler/linker_context/postProcessJSChunk.zig
 src/bundler/linker_context/prepareCssAstsForChunk.zig
 src/bundler/linker_context/renameSymbolsInChunk.zig
 src/bundler/linker_context/scanImportsAndExports.zig
+src/bundler/linker_context/StaticRouteVisitor.zig
 src/bundler/linker_context/writeOutputFilesToDisk.zig
 src/bundler/LinkerContext.zig
 src/bundler/LinkerGraph.zig

src/OutputFile.zig

@@ -20,8 +20,24 @@ side: ?bun.bake.Side,
 /// This is only set for the JS bundle, and not files associated with an
 /// entrypoint like sourcemaps and bytecode
 entry_point_index: ?u32,
-referenced_css_files: []const Index = &.{},
+referenced_css_chunks: []const Index = &.{},
 source_index: Index.Optional = .none,
+bake_extra: BakeExtra = .{},
+
+pub const zero_value = OutputFile{
+    .loader = .file,
+    .src_path = Fs.Path.init(""),
+    .value = .noop,
+    .output_kind = .chunk,
+    .side = null,
+    .entry_point_index = null,
+};
+
+pub const BakeExtra = struct {
+    is_route: bool = false,
+    fully_static: bool = false,
+    bake_is_runtime: bool = false,
+};
 
 pub const Index = bun.GenericIndex(u32, OutputFile);
 
@@ -30,7 +46,7 @@ pub fn deinit(this: *OutputFile) void {
 
     bun.default_allocator.free(this.src_path.text);
     bun.default_allocator.free(this.dest_path);
-    bun.default_allocator.free(this.referenced_css_files);
+    bun.default_allocator.free(this.referenced_css_chunks);
 }
 
 // Depending on:
@@ -99,6 +115,13 @@ pub const Value = union(Kind) {
         }
     }
 
+    pub fn asSlice(v: Value) []const u8 {
+        return switch (v) {
+            .buffer => |buf| buf.bytes,
+            else => "",
+        };
+    }
+
     pub fn toBunString(v: Value) bun.String {
         return switch (v) {
             .noop => bun.String.empty,
@@ -206,7 +229,8 @@ pub const Options = struct {
     },
     side: ?bun.bake.Side,
     entry_point_index: ?u32,
-    referenced_css_files: []const Index = &.{},
+    referenced_css_chunks: []const Index = &.{},
+    bake_extra: BakeExtra = .{},
 };
 
 pub fn init(options: Options) OutputFile {
@@ -240,7 +264,8 @@ pub fn init(options: Options) OutputFile {
         },
         .side = options.side,
         .entry_point_index = options.entry_point_index,
-        .referenced_css_files = options.referenced_css_files,
+        .referenced_css_chunks = options.referenced_css_chunks,
+        .bake_extra = options.bake_extra,
     };
 }
 

src/api/schema.zig

@@ -1956,6 +1956,27 @@ pub const Api = struct {
 
         _,
 
+        pub fn fromJS(global: *bun.JSC.JSGlobalObject, value: bun.JSC.JSValue) bun.JSError!?SourceMapMode {
+            if (value.isString()) {
+                const str = try value.toSliceOrNull(global);
+                defer str.deinit();
+                const utf8 = str.slice();
+                if (bun.strings.eqlComptime(utf8, "none")) {
+                    return .none;
+                }
+                if (bun.strings.eqlComptime(utf8, "inline")) {
+                    return .@"inline";
+                }
+                if (bun.strings.eqlComptime(utf8, "external")) {
+                    return .external;
+                }
+                if (bun.strings.eqlComptime(utf8, "linked")) {
+                    return .linked;
+                }
+            }
+            return null;
+        }
+
         pub fn jsonStringify(self: @This(), writer: anytype) !void {
             return try writer.write(@tagName(self));
         }

src/bake/BakeGlobalObject.cpp

@@ -9,6 +9,7 @@
 #include "JavaScriptCore/JSSourceCode.h"
 
 extern "C" BunString BakeProdResolve(JSC::JSGlobalObject*, BunString a, BunString b);
+extern "C" BunString BakeToWindowsPath(BunString a);
 
 namespace Bake {
 using namespace JSC;
@@ -107,7 +108,18 @@ static JSC::JSInternalPromise* resolvedInternalPromise(JSC::JSGlobalObject* glob
     return promise;
 }
 
-extern "C" BunString BakeProdLoad(ProductionPerThread* perThreadData, BunString a);
+extern "C" BunString BakeProdLoad(void* perThreadData, BunString a);
+
+extern "C" bool BakeGlobalObject__isBakeGlobalObject(JSC::JSGlobalObject* global)
+{
+    return global->JSCell::inherits(Bake::GlobalObject::info());
+}
+
+extern "C" void* BakeGlobalObject__getPerThreadData(JSC::JSGlobalObject* global)
+{
+    Bake::GlobalObject* bake = jsCast<Bake::GlobalObject*>(global);
+    return bake->m_perThreadData;
+}
 
 JSC::JSInternalPromise* bakeModuleLoaderFetch(JSC::JSGlobalObject* globalObject,
     JSC::JSModuleLoader* loader, JSC::JSValue key,
@@ -134,12 +146,33 @@ JSC::JSInternalPromise* bakeModuleLoaderFetch(JSC::JSGlobalObject* globalObject,
                     JSC::SourceProviderSourceType::Module));
                 return resolvedInternalPromise(globalObject, JSC::JSSourceCode::create(vm, WTFMove(sourceCode)));
             }
-            return rejectedInternalPromise(globalObject, createTypeError(globalObject, makeString("Bundle does not have \""_s, moduleKey, "\". This is a bug in Bun's bundler."_s)));
+
+            // We unconditionally prefix the key with "bake:" inside
+            // BakeProdResolve in production.zig.
+            //
+            // But if someone does: `await import(resolve(import.meta.dir, "nav.ts"))`
+            // we don't actually want to load it from the Bake production module
+            // map and instead make it go through the normal codepath.
+            auto bakePrefixRemoved = moduleKey.substringSharingImpl("bake:"_s.length());
+
+#ifdef _WIN32
+            // We normalize paths to contain forward slashes in bake so we don't
+            // have to worry about platform paths. Now we have to worry about
+            // it, because `moduleLoaderFetch(...)` may read the path from disk
+            // and so we need to give a Windows path to it.
+            auto temp = BakeToWindowsPath(Bun::toString(bakePrefixRemoved));
+            bakePrefixRemoved = temp.toWTFString();
+#endif
+            JSString* bakePrefixRemovedString = jsNontrivialString(vm, bakePrefixRemoved);
+            JSValue bakePrefixRemovedJsvalue = bakePrefixRemovedString;
+            return Zig::GlobalObject::moduleLoaderFetch(globalObject, loader, bakePrefixRemovedJsvalue, parameters, script);
         }
         return rejectedInternalPromise(globalObject, createTypeError(globalObject, "BakeGlobalObject does not have per-thread data configured"_s));
     }
 
-    return Zig::GlobalObject::moduleLoaderFetch(globalObject, loader, key, parameters, script);
+    auto result = Zig::GlobalObject::moduleLoaderFetch(globalObject, loader, key, parameters, script);
+    RETURN_IF_EXCEPTION(scope, rejectedInternalPromise(globalObject, scope.exception()->value()));
+    return result;
 }
 
 GlobalObject* GlobalObject::create(JSC::VM& vm, JSC::Structure* structure,
@@ -205,7 +238,16 @@ const JSC::GlobalObjectMethodTable& GlobalObject::globalObjectMethodTable()
 // TODO: remove this entire method
 extern "C" GlobalObject* BakeCreateProdGlobal(void* console)
 {
-    JSC::VM& vm = JSC::VM::create(JSC::HeapType::Large).leakRef();
+    RefPtr<JSC::VM> vmPtr = JSC::VM::tryCreate(JSC::HeapType::Large);
+    if (!vmPtr) [[unlikely]] {
+        BUN_PANIC("Failed to allocate JavaScriptCore Virtual Machine. Did your computer run out of memory? Or maybe you compiled Bun with a mismatching libc++ version or compiler?");
+    }
+    // We need to unsafely ref this so it stays alive, later in
+    // `Zig__GlobalObject__destructOnExit` will call
+    // `vm.derefSuppressingSaferCPPChecking()` to free it.
+    vmPtr->refSuppressingSaferCPPChecking();
+    JSC::VM& vm = *vmPtr;
+
     vm.heap.acquireAccess();
     JSC::JSLockHolder locker(vm);
     BunVirtualMachine* bunVM = Bun__getVM();
@@ -225,6 +267,11 @@ extern "C" GlobalObject* BakeCreateProdGlobal(void* console)
     global->setStackTraceLimit(10); // Node.js defaults to 10
     global->isThreadLocalDefaultGlobalObject = true;
 
+    // if (shouldDisableStopIfNecessaryTimer) {
+    vm.heap.disableStopIfNecessaryTimer();
+    // }
+
+    // if you process.nextTick on a microtask we need thsi
     // TODO: it segfaults! process.nextTick is scoped out for now i guess!
     // vm.setOnComputeErrorInfo(computeErrorInfoWrapper);
     // vm.setOnEachMicrotaskTick([global](JSC::VM &vm) -> void {
@@ -240,7 +287,7 @@ extern "C" GlobalObject* BakeCreateProdGlobal(void* console)
     return global;
 }
 
-extern "C" void BakeGlobalObject__attachPerThreadData(GlobalObject* global, ProductionPerThread* perThreadData)
+extern "C" void BakeGlobalObject__attachPerThreadData(GlobalObject* global, void* perThreadData)
 {
     global->m_perThreadData = perThreadData;
 }

src/bake/BakeGlobalObject.h

@@ -4,13 +4,11 @@
 
 namespace Bake {
 
-struct ProductionPerThread;
-
 class GlobalObject : public Zig::GlobalObject {
 public:
     using Base = Zig::GlobalObject;
 
-    ProductionPerThread* m_perThreadData = nullptr;
+    void* m_perThreadData = nullptr;
     DECLARE_INFO;
 
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
@@ -39,4 +37,7 @@ class GlobalObject : public Zig::GlobalObject {
     }
 };
 
+extern "C" void* BakeGlobalObject__getPerThreadData(JSC::JSGlobalObject* global);
+extern "C" void BakeGlobalObject__attachPerThreadData(GlobalObject* global, void* perThreadData);
+
 }; // namespace Kit

src/bake/BakeSourceProvider.cpp

@@ -22,7 +22,7 @@ extern "C" BunString BakeSourceProvider__getSourceSlice(SourceProvider* provider
     return Bun::toStringView(provider->source());
 }
 
-extern "C" JSC::EncodedJSValue BakeLoadInitialServerCode(GlobalObject* global, BunString source, bool separateSSRGraph) {
+extern "C" JSC::EncodedJSValue BakeLoadInitialServerCode(JSC::JSGlobalObject* global, BunString source, bool separateSSRGraph) {
   auto& vm = JSC::getVM(global);
   auto scope = DECLARE_THROW_SCOPE(vm);
 

src/bake/FrameworkRouter.zig

@@ -287,6 +287,11 @@ pub const EncodedPattern = struct {
                 },
                 .param => |name| {
                     const end = strings.indexOfCharPos(path, '/', i) orelse path.len;
+                    // Check if we're about to exceed the maximum number of parameters
+                    if (param_num >= MatchedParams.max_count) {
+                        // TODO: ideally we should throw a nice user message
+                        bun.Output.panic("Route pattern matched more than {d} parameters. Path: {s}", .{ MatchedParams.max_count, path });
+                    }
                     params.params.len = @intCast(param_num + 1);
                     params.params.buffer[param_num] = .{
                         .key = name,
@@ -295,8 +300,30 @@ pub const EncodedPattern = struct {
                     param_num += 1;
                     i = if (end == path.len) end else end + 1;
                 },
-                .catch_all_optional => return true,
-                .catch_all => break,
+                .catch_all_optional, .catch_all => |name| {
+                    // Capture remaining path segments as individual parameters
+                    if (i < path.len) {
+                        var segment_start = i;
+                        while (segment_start < path.len) {
+                            const segment_end = strings.indexOfCharPos(path, '/', segment_start) orelse path.len;
+                            if (segment_start < segment_end) {
+                                // Check if we're about to exceed the maximum number of parameters
+                                if (param_num >= MatchedParams.max_count) {
+                                    // TODO: ideally we should throw a nice user message
+                                    bun.Output.panic("Route pattern matched more than {d} parameters. Path: {s}", .{ MatchedParams.max_count, path });
+                                }
+                                params.params.len = @intCast(param_num + 1);
+                                params.params.buffer[param_num] = .{
+                                    .key = name,
+                                    .value = path[segment_start..segment_end],
+                                };
+                                param_num += 1;
+                            }
+                            segment_start = if (segment_end == path.len) segment_end else segment_end + 1;
+                        }
+                    }
+                    return true;
+                },
                 .group => continue,
             }
         }

src/bake/bake.d.ts

@@ -418,9 +418,9 @@ declare module "bun" {
     }
 
     type GetParamIterator =
-      | AsyncIterable<Record<string, string>, GetParamsFinalOpts>
-      | Iterable<Record<string, string>, GetParamsFinalOpts>
-      | ({ pages: Array<Record<string, string>> } & GetParamsFinalOpts);
+      | AsyncIterable<Record<string, string | string[]>, GetParamsFinalOpts>
+      | Iterable<Record<string, string | string[]>, GetParamsFinalOpts>
+      | ({ pages: Array<Record<string, string | string[]>> } & GetParamsFinalOpts);
 
     type GetParamsFinalOpts = void | null | {
       /**
@@ -478,7 +478,7 @@ declare module "bun" {
        */
       readonly layouts: ReadonlyArray<any>;
       /** Received route params. `null` if the route does not take params */
-      readonly params: null | Record<string, string>;
+      readonly params: null | Record<string, string | string[]>;
       /**
        * A list of js files that the route will need to be interactive.
        */