fix: ssg on windows 2nd attempt

Author: Varixo

.github/workflows/ci.yml

@@ -684,8 +684,8 @@ jobs:
           #   browser: firefox
           - host: macos-latest
             browser: webkit
-          # - host: windows-latest
-          #   browser: chromium
+          - host: windows-latest
+            browser: chromium
 
     runs-on: ${{ matrix.settings.host }}
 

e2e/adapters-e2e/playwright.config.ts

@@ -44,5 +44,6 @@ export default defineConfig({
     port: 3000,
     stdout: 'pipe',
     reuseExistingServer: !process.env.CI,
+    timeout: 120000,
   },
 });

packages/qwik-city/src/static/main-thread.ts

@@ -216,7 +216,10 @@ export async function mainThread(sys: System) {
         flushQueue();
       };
 
-      loadStaticRoutes();
+      loadStaticRoutes().catch((e) => {
+        console.error('SSG route loading failed', e);
+        reject(e);
+      });
     } catch (e) {
       reject(e);
     }

packages/qwik-city/src/static/node/node-main.ts

@@ -10,10 +10,9 @@ import type {
 import fs from 'node:fs';
 import { cpus as nodeCpus } from 'node:os';
 import { Worker } from 'node:worker_threads';
-import { isAbsolute, resolve } from 'node:path';
+import { dirname, extname, isAbsolute, join, resolve } from 'node:path';
 import { ensureDir } from './node-system';
 import { normalizePath } from '../../utils/fs';
-import { createSingleThreadWorker } from '../worker-thread';
 
 export async function createNodeMainProcess(sys: System, opts: StaticGenerateOptions) {
   const ssgWorkers: StaticGeneratorWorker[] = [];
@@ -50,45 +49,37 @@ export async function createNodeMainProcess(sys: System, opts: StaticGenerateOpt
       sitemapOutFile = resolve(outDir, sitemapOutFile);
     }
   }
-
-  const singleThreadWorker = await createSingleThreadWorker(sys);
-
-  const createWorker = (workerIndex: number) => {
-    if (workerIndex === 0) {
-      // same thread worker, don't start a new process
-      const ssgSameThreadWorker: StaticGeneratorWorker = {
-        activeTasks: 0,
-        totalTasks: 0,
-
-        render: async (staticRoute) => {
-          ssgSameThreadWorker.activeTasks++;
-          ssgSameThreadWorker.totalTasks++;
-          const result = await singleThreadWorker(staticRoute);
-          ssgSameThreadWorker.activeTasks--;
-          return result;
-        },
-
-        terminate: async () => {},
-      };
-      return ssgSameThreadWorker;
-    }
-
+  const createWorker = () => {
     let terminateResolve: (() => void) | null = null;
     const mainTasks = new Map<string, WorkerMainTask>();
 
     let workerFilePath: string | URL;
+    let terminateTimeout: number | null = null;
 
+    // Launch the worker using the package's index module, which bootstraps the worker thread.
     if (typeof __filename === 'string') {
-      workerFilePath = __filename;
+      // CommonJS path
+      const ext = extname(__filename) || '.js';
+      workerFilePath = join(dirname(__filename), `index${ext}`);
     } else {
-      workerFilePath = import.meta.url;
+      // ESM path (import.meta.url)
+      const thisUrl = new URL(import.meta.url);
+      const pathname = thisUrl.pathname || '';
+      let ext = '.js';
+      if (pathname.endsWith('.ts')) {
+        ext = '.ts';
+      } else if (pathname.endsWith('.mjs')) {
+        ext = '.mjs';
+      }
+      workerFilePath = new URL(`./index${ext}`, thisUrl);
     }
 
     if (typeof workerFilePath === 'string' && workerFilePath.startsWith('file://')) {
       workerFilePath = new URL(workerFilePath);
     }
 
     const nodeWorker = new Worker(workerFilePath, { workerData: opts });
+    nodeWorker.unref();
 
     const ssgWorker: StaticGeneratorWorker = {
       activeTasks: 0,
@@ -116,7 +107,9 @@ export async function createNodeMainProcess(sys: System, opts: StaticGenerateOpt
           terminateResolve = resolve;
           nodeWorker.postMessage(msg);
         });
-        await nodeWorker.terminate();
+        terminateTimeout = setTimeout(async () => {
+          await nodeWorker.terminate();
+        }, 1000) as unknown as number;
       },
     };
 
@@ -146,7 +139,11 @@ export async function createNodeMainProcess(sys: System, opts: StaticGenerateOpt
     });
 
     nodeWorker.on('exit', (code) => {
-      if (code !== 1) {
+      if (terminateTimeout) {
+        clearTimeout(terminateTimeout);
+        terminateTimeout = null;
+      }
+      if (code !== 0) {
         console.error(`worker exit ${code}`);
       }
     });
@@ -200,9 +197,15 @@ export async function createNodeMainProcess(sys: System, opts: StaticGenerateOpt
         console.error(e);
       }
     }
-    ssgWorkers.length = 0;
 
     await Promise.all(promises);
+    ssgWorkers.length = 0;
+
+    // On Windows, give extra time for all workers to fully exit
+    // This prevents resource conflicts in back-to-back builds
+    if (process.platform === 'win32') {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+    }
   };
 
   if (sitemapOutFile) {
@@ -214,7 +217,11 @@ export async function createNodeMainProcess(sys: System, opts: StaticGenerateOpt
   }
 
   for (let i = 0; i < maxWorkers; i++) {
-    ssgWorkers.push(createWorker(i));
+    ssgWorkers.push(createWorker());
+    // On Windows, add delay between worker creation to avoid resource contention
+    if (process.platform === 'win32' && i < maxWorkers - 1) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
   }
 
   const mainCtx: MainContext = {

packages/qwik-city/src/static/node/node-worker.ts

@@ -6,5 +6,8 @@ export async function createNodeWorkerProcess(
 ) {
   parentPort?.on('message', async (msg: WorkerInputMessage) => {
     parentPort?.postMessage(await onMessage(msg));
+    if (msg.type === 'close') {
+      parentPort?.close();
+    }
   });
 }

packages/qwik-city/src/static/worker-thread.ts

@@ -39,23 +39,6 @@ export async function workerThread(sys: System) {
   });
 }
 
-export async function createSingleThreadWorker(sys: System) {
-  const ssgOpts = sys.getOptions();
-  const pendingPromises = new Set<Promise<any>>();
-
-  const opts: StaticGenerateHandlerOptions = {
-    ...ssgOpts,
-    render: (await import(pathToFileURL(ssgOpts.renderModulePath).href)).default,
-    qwikCityPlan: (await import(pathToFileURL(ssgOpts.qwikCityPlanModulePath).href)).default,
-  };
-
-  return (staticRoute: StaticRoute) => {
-    return new Promise<StaticWorkerRenderResult>((resolve) => {
-      workerRender(sys, opts, staticRoute, pendingPromises, resolve);
-    });
-  };
-}
-
 async function workerRender(
   sys: System,
   opts: StaticGenerateHandlerOptions,