fix(optimizer): resolve pending discovered dep processing on close before init

packages/vite/src/node/__tests__/optimizer/discoverBeforeListen.spec.ts

@@ -90,3 +90,72 @@ test('does not crash when a dep is discovered before the server starts listening
   await ssr.depsOptimizer?.scanProcessing
   expect(errors).toStrictEqual([])
 })
+
+// regression test for https://github.com/vitejs/vite/issues/23143
+// When a module importing a bare specifier is transformed through the JS API
+// before server.listen() is called, the dep is discovered and a pending warmup
+// request is issued for the optimized dep. That warmup waits on the dep's
+// processing promise, which is never resolved because depsOptimizer.init() has
+// not run. server.close() then waits forever for the pending warmup request.
+// The fix is for depsOptimizer.close() to resolve the processing promise so
+// in-flight requests can unblock during shutdown.
+test('resolves discovered dep processing promise on close before init', async () => {
+  const errors: string[] = []
+  const logger = createLogger('error')
+  logger.error = (msg) => {
+    errors.push(typeof msg === 'string' ? msg : String(msg))
+  }
+
+  server = await createServer({
+    configFile: false,
+    customLogger: logger,
+    root: path.join(
+      import.meta.dirname,
+      '../fixtures/optimizer-discover-before-listen',
+    ),
+    cacheDir: 'node_modules/.vite-client-close',
+    environments: {
+      client: {
+        dev: {
+          preTransformRequests: false,
+        },
+        optimizeDeps: {
+          // ensure no cached metadata/file is reused so the dep is discovered
+          // and its processing promise stays unresolved until close()
+          force: true,
+          noDiscovery: false,
+        },
+      },
+    },
+  })
+
+  const client = server.environments.client
+
+  // Transform a module importing a bare specifier before the server is listening.
+  // This discovers the dep and leaves its processing promise pending because
+  // depsOptimizer.init() is deferred to listen().
+  await client.transformRequest('/entry.js')
+
+  const info = client.depsOptimizer?.metadata.discovered?.vue
+  expect(info).toBeDefined()
+
+  const processingPromise = info!.processing?.then(() => true)
+
+  // The dep's processing promise should still be pending at this point.
+  const resolvedBeforeClose = await Promise.race([
+    processingPromise,
+    setTimeout(500, false),
+  ])
+  expect(resolvedBeforeClose).toBe(false)
+
+  // close() should resolve the processing promise so any in-flight or future
+  // requests waiting on it (including server.close()) can unblock.
+  await client.depsOptimizer?.close()
+
+  const resolvedAfterClose = await Promise.race([
+    processingPromise,
+    setTimeout(500, false),
+  ])
+  expect(resolvedAfterClose).toBe(true)
+  expect(errors).toStrictEqual([])
+})

packages/vite/src/node/optimizer/optimizer.ts

@@ -148,11 +148,19 @@ export function createDepsOptimizer(
 
   async function close() {
     closed = true
+
+    // Ensure that a rerun will not be issued
+    if (debounceProcessingHandle) clearTimeout(debounceProcessingHandle)
+    debounceProcessingHandle = undefined
+
     await Promise.allSettled([
       discover?.cancel(),
       depsOptimizer.scanProcessing,
       optimizationResult?.cancel(),
     ])
+
+    depOptimizationProcessing.resolve()
+    resolveEnqueuedProcessingPromises()
   }
 
   async function init() {
@@ -337,11 +345,8 @@ export function createDepsOptimizer(
 
     if (closed) {
       currentlyProcessing = false
-      depOptimizationProcessing.resolve()
-      resolveEnqueuedProcessingPromises()
       return
     }
-
     currentlyProcessing = true
 
     try {
@@ -360,7 +365,6 @@ export function createDepsOptimizer(
       if (closed) {
         currentlyProcessing = false
         processingResult.cancel()
-        resolveEnqueuedProcessingPromises()
         return
       }