[turbopack] Add registerEntry() to handle inline bootstrapping

Author: sampoder

turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/build-base.ts

@@ -10,7 +10,7 @@ contextPrototype.c = moduleCache
 // @ts-ignore
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 function getOrInstantiateRuntimeModule(
-  chunkPath: ChunkPath,
+  chunkPath: ChunkPath | undefined,
   moduleId: ModuleId
 ): Module {
   const module = moduleCache[moduleId]

turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/dev-base.ts

@@ -86,7 +86,7 @@ const chunkChunkListsMap: Map<ChunkPath, Set<ChunkListPath>> = new Map()
  */
 // @ts-ignore
 function getOrInstantiateRuntimeModule(
-  chunkPath: ChunkPath,
+  chunkPath: ChunkPath | undefined,
   moduleId: ModuleId
 ): Module {
   const module = devModuleCache[moduleId]

turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/runtime-base.ts

@@ -63,6 +63,11 @@ interface RuntimeBackend {
     chunkPath: ChunkPath | ChunkScript,
     params?: RuntimeParams
   ) => void
+  /**
+   * Registers an entry-only registration (inlined into the HTML): loads the params'
+   * other chunks and runs its runtime modules, with no self chunk identity.
+   */
+  registerEntry: (params: RuntimeParams) => void
   /**
    * Returns the same Promise for the same chunk URL.
    */
@@ -90,7 +95,12 @@ function loadChunk(
 }
 browserContextPrototype.l = loadChunk
 
-function loadInitialChunk(chunkPath: ChunkPath, chunkData: ChunkData) {
+// `chunkPath` is the source chunk; it is `undefined` for entry-only registrations,
+// which have no self chunk (`SourceData` already allows this).
+function loadInitialChunk(
+  chunkPath: ChunkPath | undefined,
+  chunkData: ChunkData
+) {
   return loadChunkInternal(SourceType.Runtime, chunkPath, chunkData)
 }
 

turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/dom/runtime-backend-dom.ts

@@ -67,6 +67,25 @@ const chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()
       }
     },
 
+    // Handles an inlined entry-only registration. Load the entry's other chunks and run its
+    // runtime modules with no source chunk (`undefined`).
+    async registerEntry(params) {
+      for (const otherChunkData of params.otherChunks) {
+        const otherChunkUrl = getChunkRelativeUrl(getChunkPath(otherChunkData))
+        getOrCreateResolver(otherChunkUrl)
+      }
+
+      await Promise.all(
+        params.otherChunks.map((otherChunkData) =>
+          loadInitialChunk(undefined, otherChunkData)
+        )
+      )
+
+      for (const moduleId of params.runtimeModuleIds) {
+        getOrInstantiateRuntimeModule(undefined, moduleId)
+      }
+    },
+
     /**
      * Loads the given chunk, and returns a promise that resolves once the chunk
      * has been loaded.

turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/edge/runtime-backend-edge.ts

@@ -53,6 +53,13 @@ let BACKEND: RuntimeBackend
       }
     },
 
+    // Entry-only registrations are inlined into the HTML and only produced for
+    // the browser/DOM runtime; the edge ("none") runtime never receives them
+    // (its chunks self-register via `registerChunk`).
+    registerEntry(_params) {
+      throw new Error('inline entry registration is not supported')
+    },
+
     loadChunkCached(_sourceType: SourceType, _chunkUrl: ChunkUrl) {
       throw new Error('chunk loading is not supported')
     },

turbopack/crates/turbopack-ecmascript-runtime/src/browser_runtime.rs

@@ -211,14 +211,23 @@ pub async fn get_browser_runtime_code(
         );
     }
 
-    // Registering chunks and chunk lists depends on the BACKEND variable, which is set by the
-    // specific runtime code, hence it must be appended after it.
+    // Registering chunks/chunk lists depends on the BACKEND variable set by the specific
+    // runtime code, so it must be appended after it. `registerChunkOrEntry` dispatches
+    // each queued registration: arrays are chunk registrations, while the inlined entry
+    // objects (`{ otherChunks, runtimeModuleIds }`) go to `BACKEND.registerEntry`.
     writedoc!(
         code,
         r#"
+            function registerChunkOrEntry(registration) {{
+                if (Array.isArray(registration)) {{
+                    registerChunk(registration);
+                }} else {{
+                    BACKEND.registerEntry(registration);
+                }}
+            }}
             var chunksToRegister = globalThis[{chunk_loading_global}];
-            globalThis[{chunk_loading_global}] = {{ push: registerChunk }};
-            chunksToRegister.forEach(registerChunk);
+            globalThis[{chunk_loading_global}] = {{ push: registerChunkOrEntry }};
+            chunksToRegister.forEach(registerChunkOrEntry);
         "#,
         chunk_loading_global = StringifyJs(&chunk_loading_global),
     )?;