Turbopack hmr: preserve group factory consistency for compressed modules (#89976)

## Summary
- update `installCompressedModuleFactories` to reuse an existing factory
in a compressed ID group when filling missing IDs
- keep `newModuleId` notifications aligned with actual IDs installed
(`newModuleId(id)`)
- add an execution regression test for the mixed-group case where one ID
already has a factory and another is missing
- regenerate affected runtime snapshots
(runtime/debug-ids/workers/preset_env)

Aims to fix cases like this being seen recently:

```sh
Error: Module 8896 was instantiated because it was required from module 18500, but the module factory is not available.
```

```

## Test Plan
- `cargo test -p turbopack-tests --test execution test_tests__execution__turbopack__runtime__factory_group_existing_factory__input__index_js -- --nocapture`
- `cargo test -p turbopack-tests --test snapshot test_tests__snapshot__runtime__default_build_runtime__input__index_js -- --nocapture`
- `cargo test -p turbopack-tests --test snapshot test_tests__snapshot__runtime__default_dev_runtime__input__index_js -- --nocapture`
- `cargo test -p turbopack-tests --test snapshot test_tests__snapshot__debug_ids -- --nocapture`
- `cargo test -p turbopack-tests --test snapshot test_tests__snapshot__swc_transforms__preset_env__input__index_js -- --nocapture`
- `cargo test -p turbopack-tests --test snapshot test_tests__snapshot__workers__ -- --nocapture`

Author: ijjk

turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/runtime/runtime-utils.ts

@@ -551,7 +551,6 @@ function installCompressedModuleFactories(
 ) {
   let i = offset
   while (i < chunkModules.length) {
-    let moduleId = chunkModules[i] as ModuleId
     let end = i + 1
     // Find our factory function
     while (
@@ -565,19 +564,33 @@ function installCompressedModuleFactories(
     }
 
     // Install the factory for each module ID that doesn't already have one.
-    // This handles both the normal case and the case where some IDs in a group
-    // may have been registered separately (e.g., from another chunk or HMR update).
+    // When some IDs in this group already have a factory, reuse that existing
+    // group factory for the missing IDs to keep all IDs in the group consistent.
+    // Otherwise, install the factory from this chunk.
     const moduleFactoryFn = chunkModules[end] as Function
+    let existingGroupFactory: Function | undefined = undefined
+    for (let j = i; j < end; j++) {
+      const id = chunkModules[j] as ModuleId
+      const existingFactory = moduleFactories.get(id)
+      if (existingFactory) {
+        existingGroupFactory = existingFactory
+        break
+      }
+    }
+    const factoryToInstall = existingGroupFactory ?? moduleFactoryFn
+
     let didInstallFactory = false
     for (let j = i; j < end; j++) {
       const id = chunkModules[j] as ModuleId
       if (!moduleFactories.has(id)) {
         if (!didInstallFactory) {
-          applyModuleFactoryName(moduleFactoryFn)
-          newModuleId?.(moduleId)
+          if (factoryToInstall === moduleFactoryFn) {
+            applyModuleFactoryName(moduleFactoryFn)
+          }
           didInstallFactory = true
         }
-        moduleFactories.set(id, moduleFactoryFn)
+        moduleFactories.set(id, factoryToInstall)
+        newModuleId?.(id)
       }
     }
     i = end + 1 // end is pointing at the last factory advance to the next id or the end of the array.

turbopack/crates/turbopack-tests/tests/execution/turbopack/runtime/factory-group-existing-factory/input/index.js

@@ -0,0 +1,56 @@
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+
+function writeChunk(filePath, chunkModules) {
+  fs.writeFileSync(filePath, `module.exports = ${chunkModules};\n`)
+}
+
+it('reuses the existing group factory for missing IDs', () => {
+  const repoRoot = path.resolve(process.cwd(), '../../../../../../../..')
+  const runtimePath = path.join(
+    repoRoot,
+    'turbopack/crates/turbopack-tests/tests/snapshot/runtime/default_build_runtime/output/[turbopack]_runtime.js'
+  )
+  const createRuntime = eval('require')(runtimePath)
+
+  const suffix = `${Date.now()}-${Math.random().toString(16).slice(2)}`
+  const moduleA = `module-a-${suffix}`
+  const moduleB = `module-b-${suffix}`
+
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tp-factory-group-'))
+  try {
+    const firstChunk = path.join(tempDir, 'first.js')
+    const mixedChunk = path.join(tempDir, 'mixed.js')
+
+    writeChunk(
+      firstChunk,
+      `[
+        ${JSON.stringify(moduleA)},
+        function (__turbopack_context__, module) {
+          module.exports = "first-factory"
+        }
+      ]`
+    )
+
+    writeChunk(
+      mixedChunk,
+      `[
+        ${JSON.stringify(moduleA)},
+        ${JSON.stringify(moduleB)},
+        function (__turbopack_context__, module) {
+          module.exports = "second-factory"
+        }
+      ]`
+    )
+
+    const runtime = createRuntime('test-source')
+    runtime.c(firstChunk)
+    runtime.c(mixedChunk)
+
+    expect(runtime.m(moduleA).exports).toBe('first-factory')
+    expect(runtime.m(moduleB).exports).toBe('first-factory')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+})