@qwik.dev/router 2.0.0-beta.2 → 2.0.0-beta.21

package/lib/{static/node.mjs → chunks/index.mjs}

@@ -1,317 +1,17 @@
-// packages/qwik-router/src/static/node/node-system.ts
-import fs2 from "node:fs";
-import { dirname as dirname2, join } from "node:path";
+import fs from 'node:fs';
+import { isAbsolute, resolve, extname, join, dirname, relative } from 'node:path';
+import { cpus } from 'node:os';
+import { Worker, parentPort, isMainThread, workerData, threadId } from 'node:worker_threads';
+import { l as normalizePath, w as msToString, x as getPathnameForDynamicRoute } from './fs.mjs';
+import { bold, green, dim, red, magenta } from 'kleur/colors';
+import { pathToFileURL } from 'node:url';
+import { buildErrorMessage } from 'vite';
+import { f as formatError } from './format-error.mjs';
+import { getErrorHtml, RequestEvShareQData, requestHandler, RedirectMessage } from '@qwik.dev/router/middleware/request-handler';
+import { R as RouteDataProp } from './types.qwik.mjs';
+import { _serialize } from '@qwik.dev/core/internal';
+import { WritableStream } from 'node:stream/web';
 
-// packages/qwik-router/src/static/node/node-main.ts
-import fs from "node:fs";
-import { cpus as nodeCpus } from "node:os";
-import { Worker } from "node:worker_threads";
-import { isAbsolute, resolve } from "node:path";
-
-// packages/qwik-router/src/utils/fs.ts
-import { basename, dirname, normalize, relative } from "node:path";
-
-// packages/qwik-router/src/utils/format.ts
-function msToString(ms) {
-  if (ms < 1) {
-    return ms.toFixed(2) + " ms";
-  }
-  if (ms < 1e3) {
-    return ms.toFixed(1) + " ms";
-  }
-  if (ms < 6e4) {
-    return (ms / 1e3).toFixed(1) + " s";
-  }
-  return (ms / 6e4).toFixed(1) + " m";
-}
-
-// packages/qwik-router/src/utils/pathname.ts
-function getPathnameForDynamicRoute(originalPathname, paramNames, params) {
-  let pathname = originalPathname;
-  if (paramNames && params) {
-    for (const paramName of paramNames) {
-      const paramKey = `[${paramName}]`;
-      const restParamKey = `[...${paramName}]`;
-      const paramValue = params[paramName];
-      pathname = pathname.replace(restParamKey, paramValue);
-      pathname = pathname.replace(paramKey, paramValue);
-    }
-  }
-  return pathname;
-}
-
-// packages/qwik-router/src/utils/fs.ts
-function normalizePath(path) {
-  return normalizePathSlash(normalize(path));
-}
-function normalizePathSlash(path) {
-  const isExtendedLengthPath = /^\\\\\?\\/.test(path);
-  const hasNonAscii = /[^\u0000-\u0080]+/.test(path);
-  if (isExtendedLengthPath || hasNonAscii) {
-    return path;
-  }
-  path = path.replace(/\\/g, "/");
-  if (path.endsWith("/")) {
-    path = path.slice(0, path.length - 1);
-  }
-  return path;
-}
-
-// packages/qwik-router/src/static/worker-thread.ts
-import { _deserialize, _serialize, _verifySerializable } from "@qwik.dev/core/internal";
-import { requestHandler } from "../middleware/request-handler/index.mjs";
-import { WritableStream } from "node:stream/web";
-import { pathToFileURL } from "node:url";
-async function workerThread(sys) {
-  const ssgOpts = sys.getOptions();
-  const pendingPromises = /* @__PURE__ */ new Set();
-  const opts = {
-    ...ssgOpts,
-    render: (await import(pathToFileURL(ssgOpts.renderModulePath).href)).default,
-    qwikRouterConfig: (await import(pathToFileURL(ssgOpts.qwikRouterConfigModulePath).href)).default
-  };
-  sys.createWorkerProcess(async (msg) => {
-    switch (msg.type) {
-      case "render": {
-        return new Promise((resolve2) => {
-          workerRender(sys, opts, msg, pendingPromises, resolve2);
-        });
-      }
-      case "close": {
-        const promises = Array.from(pendingPromises);
-        pendingPromises.clear();
-        await Promise.all(promises);
-        return { type: "close" };
-      }
-    }
-  });
-}
-async function createSingleThreadWorker(sys) {
-  const ssgOpts = sys.getOptions();
-  const pendingPromises = /* @__PURE__ */ new Set();
-  const opts = {
-    ...ssgOpts,
-    render: (await import(pathToFileURL(ssgOpts.renderModulePath).href)).default,
-    qwikRouterConfig: (await import(pathToFileURL(ssgOpts.qwikRouterConfigModulePath).href)).default
-  };
-  return (staticRoute) => {
-    return new Promise((resolve2) => {
-      workerRender(sys, opts, staticRoute, pendingPromises, resolve2);
-    });
-  };
-}
-async function workerRender(sys, opts, staticRoute, pendingPromises, callback) {
-  const qwikSerializer = {
-    _deserialize,
-    _serialize,
-    _verifySerializable
-  };
-  const url = new URL(staticRoute.pathname, opts.origin);
-  const result = {
-    type: "render",
-    pathname: staticRoute.pathname,
-    url: url.href,
-    ok: false,
-    error: null,
-    filePath: null,
-    contentType: null,
-    resourceType: null
-  };
-  try {
-    let routeWriter = null;
-    let closeResolved;
-    const closePromise = new Promise((closePromiseResolve) => {
-      closeResolved = closePromiseResolve;
-    });
-    const request = new Request(url);
-    const requestCtx = {
-      mode: "static",
-      locale: void 0,
-      url,
-      request,
-      env: {
-        get(key) {
-          return sys.getEnv(key);
-        }
-      },
-      platform: sys.platform,
-      getClientConn: () => {
-        return {};
-      },
-      getWritableStream: (status, headers, _, _r, requestEv) => {
-        result.ok = status >= 200 && status < 300;
-        if (!result.ok) {
-          return noopWritableStream;
-        }
-        result.contentType = (headers.get("Content-Type") || "").toLowerCase();
-        const isHtml = result.contentType.includes("text/html");
-        const is404ErrorPage = url.pathname.endsWith("/404.html");
-        const routeFilePath = sys.getRouteFilePath(url.pathname, isHtml);
-        if (is404ErrorPage) {
-          result.resourceType = "404";
-        } else if (isHtml) {
-          result.resourceType = "page";
-        }
-        const hasRouteWriter = isHtml ? opts.emitHtml !== false : true;
-        const writeQDataEnabled = isHtml && opts.emitData !== false;
-        const stream = new WritableStream({
-          async start() {
-            try {
-              if (hasRouteWriter || writeQDataEnabled) {
-                await sys.ensureDir(routeFilePath);
-              }
-              if (hasRouteWriter) {
-                routeWriter = sys.createWriteStream(routeFilePath);
-                routeWriter.on("error", (e) => {
-                  console.error(e);
-                  routeWriter = null;
-                  result.error = {
-                    message: e.message,
-                    stack: e.stack
-                  };
-                });
-              }
-            } catch (e) {
-              routeWriter = null;
-              result.error = {
-                message: String(e),
-                stack: e.stack || ""
-              };
-            }
-          },
-          write(chunk) {
-            try {
-              if (routeWriter) {
-                routeWriter.write(Buffer.from(chunk.buffer));
-              }
-            } catch (e) {
-              routeWriter = null;
-              result.error = {
-                message: String(e),
-                stack: e.stack || ""
-              };
-            }
-          },
-          async close() {
-            const writePromises = [];
-            try {
-              if (writeQDataEnabled) {
-                const qData = requestEv.sharedMap.get("qData");
-                if (qData && !is404ErrorPage) {
-                  const qDataFilePath = sys.getDataFilePath(url.pathname);
-                  const dataWriter = sys.createWriteStream(qDataFilePath);
-                  dataWriter.on("error", (e) => {
-                    console.error(e);
-                    result.error = {
-                      message: e.message,
-                      stack: e.stack
-                    };
-                  });
-                  const serialized = await _serialize([qData]);
-                  dataWriter.write(serialized);
-                  writePromises.push(
-                    new Promise((resolve2) => {
-                      result.filePath = routeFilePath;
-                      dataWriter.end(resolve2);
-                    })
-                  );
-                }
-              }
-              if (routeWriter) {
-                writePromises.push(
-                  new Promise((resolve2) => {
-                    result.filePath = routeFilePath;
-                    routeWriter.end(resolve2);
-                  }).finally(closeResolved)
-                );
-              }
-              if (writePromises.length > 0) {
-                await Promise.all(writePromises);
-              }
-            } catch (e) {
-              routeWriter = null;
-              result.error = {
-                message: String(e),
-                stack: e.stack || ""
-              };
-            }
-          }
-        });
-        return stream;
-      }
-    };
-    const promise = requestHandler(requestCtx, opts, qwikSerializer).then((rsp) => {
-      if (rsp != null) {
-        return rsp.completion.then((r) => {
-          if (routeWriter) {
-            return closePromise.then(() => r);
-          }
-          return r;
-        });
-      }
-    }).then((e) => {
-      if (e !== void 0) {
-        if (e instanceof Error) {
-          result.error = {
-            message: e.message,
-            stack: e.stack
-          };
-        } else {
-          result.error = {
-            message: String(e),
-            stack: void 0
-          };
-        }
-      }
-    }).finally(() => {
-      pendingPromises.delete(promise);
-      callback(result);
-    });
-    pendingPromises.add(promise);
-  } catch (e) {
-    if (e instanceof Error) {
-      result.error = {
-        message: e.message,
-        stack: e.stack
-      };
-    } else {
-      result.error = {
-        message: String(e),
-        stack: void 0
-      };
-    }
-    callback(result);
-  }
-}
-var noopWriter = {
-  closed: Promise.resolve(void 0),
-  ready: Promise.resolve(void 0),
-  desiredSize: 0,
-  async close() {
-  },
-  async abort() {
-  },
-  async write() {
-  },
-  releaseLock() {
-  }
-};
-var noopWritableStream = {
-  get locked() {
-    return false;
-  },
-  set locked(_) {
-  },
-  async abort() {
-  },
-  async close() {
-  },
-  getWriter() {
-    return noopWriter;
-  }
-};
-
-// packages/qwik-router/src/static/node/node-main.ts
 async function createNodeMainProcess(sys, opts) {
   const ssgWorkers = [];
   const sitemapBuffer = [];
@@ -325,7 +25,7 @@ async function createNodeMainProcess(sys, opts) {
     throw new Error(`"outDir" must be an absolute file path, received: ${outDir}`);
   }
   outDir = normalizePath(outDir);
-  let maxWorkers = nodeCpus().length;
+  let maxWorkers = cpus().length;
   if (typeof opts.maxWorkers === "number") {
     maxWorkers = Math.max(1, Math.min(opts.maxWorkers, maxWorkers));
   }
@@ -342,36 +42,27 @@ async function createNodeMainProcess(sys, opts) {
       sitemapOutFile = resolve(outDir, sitemapOutFile);
     }
   }
-  const singleThreadWorker = await createSingleThreadWorker(sys);
-  const createWorker = (workerIndex) => {
-    if (workerIndex === 0) {
-      const ssgSameThreadWorker = {
-        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 = null;
     const mainTasks = /* @__PURE__ */ new Map();
     let workerFilePath;
+    let terminateTimeout = null;
     if (typeof __filename === "string") {
-      workerFilePath = __filename;
+      const ext = extname(__filename) || ".js";
+      workerFilePath = join(dirname(__filename), `index${ext}`);
     } else {
-      workerFilePath = import.meta.url;
-    }
-    if (typeof workerFilePath === "string" && workerFilePath.startsWith("file://")) {
-      workerFilePath = new URL(workerFilePath);
+      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);
     }
     const nodeWorker = new Worker(workerFilePath, { workerData: opts });
+    nodeWorker.unref();
     const ssgWorker = {
       activeTasks: 0,
       totalTasks: 0,
@@ -396,7 +87,9 @@ async function createNodeMainProcess(sys, opts) {
           terminateResolve = resolve2;
           nodeWorker.postMessage(msg);
         });
-        await nodeWorker.terminate();
+        terminateTimeout = setTimeout(async () => {
+          await nodeWorker.terminate();
+        }, 1e3);
       }
     };
     nodeWorker.on("message", (msg) => {
@@ -423,7 +116,11 @@ async function createNodeMainProcess(sys, opts) {
       console.error(`worker error`, e);
     });
     nodeWorker.on("exit", (code) => {
-      if (code !== 1) {
+      if (terminateTimeout) {
+        clearTimeout(terminateTimeout);
+        terminateTimeout = null;
+      }
+      if (code !== 0) {
         console.error(`worker exit ${code}`);
       }
     });
@@ -434,9 +131,9 @@ async function createNodeMainProcess(sys, opts) {
     const ssgWorker = getNextWorker();
     return ssgWorker.activeTasks < maxTasksPerWorker;
   };
-  const render = async (staticRoute) => {
+  const render = async (ssgRoute) => {
     const ssgWorker = getNextWorker();
-    const result = await ssgWorker.render(staticRoute);
+    const result = await ssgWorker.render(ssgRoute);
     if (sitemapOutFile && result.ok && result.resourceType === "page") {
       sitemapBuffer.push(`<url><loc>${result.url}</loc></url>`);
       if (sitemapBuffer.length > 50) {
@@ -467,8 +164,11 @@ async function createNodeMainProcess(sys, opts) {
         console.error(e);
       }
     }
-    ssgWorkers.length = 0;
     await Promise.all(promises);
+    ssgWorkers.length = 0;
+    if (process.platform === "win32") {
+      await new Promise((resolve2) => setTimeout(resolve2, 300));
+    }
   };
   if (sitemapOutFile) {
     await ensureDir(sitemapOutFile);
@@ -480,7 +180,10 @@ async function createNodeMainProcess(sys, opts) {
     );
   }
   for (let i = 0; i < maxWorkers; i++) {
-    ssgWorkers.push(createWorker(i));
+    ssgWorkers.push(createWorker());
+    if (process.platform === "win32" && i < maxWorkers - 1) {
+      await new Promise((resolve2) => setTimeout(resolve2, 100));
+    }
   }
   const mainCtx = {
     hasAvailableWorker,
@@ -499,20 +202,18 @@ function ssgWorkerCompare(a, b) {
   return a.totalTasks < b.totalTasks ? -1 : 1;
 }
 
-// packages/qwik-router/src/static/node/node-worker.ts
-import { parentPort } from "node:worker_threads";
 async function createNodeWorkerProcess(onMessage) {
-  var _a;
-  (_a = parentPort) == null ? void 0 : _a.on("message", async (msg) => {
-    var _a2;
-    (_a2 = parentPort) == null ? void 0 : _a2.postMessage(await onMessage(msg));
+  parentPort?.on("message", async (msg) => {
+    parentPort?.postMessage(await onMessage(msg));
+    if (msg.type === "close") {
+      parentPort?.close();
+    }
   });
 }
 
-// packages/qwik-router/src/static/node/node-system.ts
-async function createSystem(opts) {
+async function createSystem(opts, threadId) {
   const createWriteStream = (filePath) => {
-    return fs2.createWriteStream(filePath, {
+    return fs.createWriteStream(filePath, {
       flags: "w"
     });
   };
@@ -526,6 +227,14 @@ async function createSystem(opts) {
     };
   };
   const createLogger = async () => {
+    if (threadId !== void 0) {
+      return {
+        debug: opts.log === "debug" ? console.debug.bind(console, `[${threadId}]`) : () => {
+        },
+        error: console.error.bind(console, `[${threadId}]`),
+        info: console.info.bind(console, `[${threadId}]`)
+      };
+    }
     return {
       debug: opts.log === "debug" ? console.debug.bind(console) : () => {
       },
@@ -582,201 +291,18 @@ async function createSystem(opts) {
   sys.createMainProcess = () => createNodeMainProcess(sys, opts);
   return sys;
 }
-var ensureDir = async (filePath) => {
-  await fs2.promises.mkdir(dirname2(filePath), { recursive: true });
-};
-var access = async (path) => {
-  try {
-    await fs2.promises.access(path);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-// packages/qwik-router/src/static/node/index.ts
-import { isMainThread, workerData } from "node:worker_threads";
-
-// node_modules/.pnpm/kleur@4.1.5/node_modules/kleur/colors.mjs
-var FORCE_COLOR;
-var NODE_DISABLE_COLORS;
-var NO_COLOR;
-var TERM;
-var isTTY = true;
-if (typeof process !== "undefined") {
-  ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
-  isTTY = process.stdout && process.stdout.isTTY;
-}
-var $ = {
-  enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY)
-};
-function init(x, y) {
-  let rgx = new RegExp(`\\x1b\\[${y}m`, "g");
-  let open = `\x1B[${x}m`, close = `\x1B[${y}m`;
-  return function(txt) {
-    if (!$.enabled || txt == null) return txt;
-    return open + (!!~("" + txt).indexOf(close) ? txt.replace(rgx, close + open) : txt) + close;
-  };
-}
-var reset = init(0, 0);
-var bold = init(1, 22);
-var dim = init(2, 22);
-var italic = init(3, 23);
-var underline = init(4, 24);
-var inverse = init(7, 27);
-var hidden = init(8, 28);
-var strikethrough = init(9, 29);
-var black = init(30, 39);
-var red = init(31, 39);
-var green = init(32, 39);
-var yellow = init(33, 39);
-var blue = init(34, 39);
-var magenta = init(35, 39);
-var cyan = init(36, 39);
-var white = init(37, 39);
-var gray = init(90, 39);
-var grey = init(90, 39);
-var bgBlack = init(40, 49);
-var bgRed = init(41, 49);
-var bgGreen = init(42, 49);
-var bgYellow = init(43, 49);
-var bgBlue = init(44, 49);
-var bgMagenta = init(45, 49);
-var bgCyan = init(46, 49);
-var bgWhite = init(47, 49);
-
-// packages/qwik-router/src/static/main-thread.ts
-import { relative as relative2 } from "node:path";
-import { pathToFileURL as pathToFileURL2 } from "node:url";
-import { buildErrorMessage } from "vite";
-
-// packages/qwik/src/optimizer/src/plugins/vite-utils.ts
-var findLocation = (e) => {
-  const stack = e.stack;
-  if (typeof stack === "string") {
-    const lines = stack.split("\n").filter((l) => !l.includes("/node_modules/") && !l.includes("(node:"));
-    for (let i = 1; i < lines.length; i++) {
-      const line = lines[i].replace("file:///", "/");
-      if (/^\s+at/.test(line)) {
-        const start = line.indexOf("/");
-        const end = line.lastIndexOf(")", start);
-        if (start > 0) {
-          const path = line.slice(start, end);
-          const parts = path.split(":");
-          const nu0 = safeParseInt(parts[parts.length - 1]);
-          const nu1 = safeParseInt(parts[parts.length - 2]);
-          if (typeof nu0 === "number" && typeof nu1 === "number") {
-            parts.length -= 2;
-            return {
-              file: parts.join(":"),
-              line: nu1,
-              column: nu0
-            };
-          } else if (typeof nu0 === "number") {
-            parts.length -= 1;
-            return {
-              file: parts.join(":"),
-              line: nu0,
-              column: void 0
-            };
-          } else {
-            return {
-              file: parts.join(":"),
-              line: void 0,
-              column: void 0
-            };
-          }
-        }
-      }
-    }
-  }
-  return void 0;
+const ensureDir = async (filePath) => {
+  await fs.promises.mkdir(dirname(filePath), { recursive: true });
 };
-var safeParseInt = (nu) => {
+const access = async (path) => {
   try {
-    return parseInt(nu, 10);
+    await fs.promises.access(path);
+    return true;
   } catch {
-    return void 0;
+    return false;
   }
 };
-var splitRE = /\r?\n/;
-var range = 2;
-function posToNumber(source, pos) {
-  if (typeof pos === "number") {
-    return pos;
-  }
-  if (pos.lo != null) {
-    return pos.lo;
-  }
-  const lines = source.split(splitRE);
-  const { line, column } = pos;
-  let start = 0;
-  for (let i = 0; i < line - 1 && i < lines.length; i++) {
-    start += lines[i].length + 1;
-  }
-  return start + column;
-}
-function generateCodeFrame(source, start = 0, end) {
-  start = posToNumber(source, start);
-  end = end || start;
-  const lines = source.split(splitRE);
-  let count = 0;
-  const res = [];
-  for (let i = 0; i < lines.length; i++) {
-    count += lines[i].length + 1;
-    if (count >= start) {
-      for (let j = i - range; j <= i + range || end > count; j++) {
-        if (j < 0 || j >= lines.length) {
-          continue;
-        }
-        const line = j + 1;
-        res.push(`${line}${" ".repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`);
-        const lineLength = lines[j].length;
-        if (j === i) {
-          const pad = Math.max(start - (count - lineLength) + 1, 0);
-          const length = Math.max(1, end > count ? lineLength - pad : end - start);
-          res.push(`   |  ` + " ".repeat(pad) + "^".repeat(length));
-        } else if (j > i) {
-          if (end > count) {
-            const length = Math.max(Math.min(end - count, lineLength), 1);
-            res.push(`   |  ` + "^".repeat(length));
-          }
-          count += lineLength + 1;
-        }
-      }
-      break;
-    }
-  }
-  return res.join("\n");
-}
-
-// packages/qwik-router/src/buildtime/vite/format-error.ts
-import fs3 from "node:fs";
-function formatError(e) {
-  if (e instanceof Error) {
-    const err = e;
-    let loc = err.loc;
-    if (!err.frame && !err.plugin) {
-      if (!loc) {
-        loc = findLocation(err);
-      }
-      if (loc) {
-        err.loc = loc;
-        if (loc.file) {
-          err.id = normalizePath(err.loc.file);
-          try {
-            const code = fs3.readFileSync(err.loc.file, "utf-8");
-            err.frame = generateCodeFrame(code, err.loc);
-          } catch {
-          }
-        }
-      }
-    }
-  }
-  return e;
-}
 
-// packages/qwik-router/src/static/extract-params.ts
 function extractParamNames(routeName) {
   const params = [];
   let idx = 0;
@@ -794,27 +320,26 @@ function extractParamNames(routeName) {
   return params;
 }
 
-// packages/qwik-router/src/static/not-found.ts
-import { getErrorHtml } from "../middleware/request-handler/index.mjs";
 async function generateNotFoundPages(sys, opts, routes) {
   if (opts.emit404Pages !== false) {
     const basePathname = opts.basePathname || "/";
     const rootNotFoundPathname = basePathname + "404.html";
-    const hasRootNotFound = routes.some((r) => r[2] === rootNotFoundPathname);
+    const hasRootNotFound = routes.some(
+      (r) => r[RouteDataProp.OriginalPathname] === rootNotFoundPathname
+    );
     if (!hasRootNotFound) {
       const filePath = sys.getRouteFilePath(rootNotFoundPathname, true);
       const html = getErrorHtml(404, "Resource Not Found");
       await sys.ensureDir(filePath);
-      return new Promise((resolve2) => {
+      return new Promise((resolve) => {
         const writer = sys.createWriteStream(filePath);
         writer.write(html);
-        writer.end(resolve2);
+        writer.end(resolve);
       });
     }
   }
 }
 
-// packages/qwik-router/src/static/routes.ts
 function createRouteTester(basePathname, includeRoutes, excludeRoutes) {
   const includes = routesToRegExps(includeRoutes);
   const excludes = routesToRegExps(excludeRoutes);
@@ -861,20 +386,19 @@ function routeToRegExp(rule) {
   return new RegExp(transformedRule);
 }
 
-// packages/qwik-router/src/static/main-thread.ts
 async function mainThread(sys) {
   const opts = sys.getOptions();
   validateOptions(opts);
   const main = await sys.createMainProcess();
   const log = await sys.createLogger();
   log.info("\n" + bold(green("Starting Qwik Router SSG...")));
-  const qwikRouterConfig = (await import(pathToFileURL2(opts.qwikRouterConfigModulePath).href)).default;
+  const qwikRouterConfig = (await import(pathToFileURL(opts.qwikRouterConfigModulePath).href)).default;
   const queue = [];
   const active = /* @__PURE__ */ new Set();
   const routes = qwikRouterConfig.routes || [];
   const trailingSlash = !!qwikRouterConfig.trailingSlash;
   const includeRoute = createRouteTester(opts.basePathname || "/", opts.include, opts.exclude);
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     try {
       const timer = sys.createTimer();
       const generatorResult = {
@@ -909,19 +433,23 @@ ${green("SSG results")}`);
           log.info(``);
         }
         closePromise.then(() => {
-          setTimeout(() => resolve2(generatorResult));
+          setTimeout(() => resolve(generatorResult));
         }).catch(reject);
       };
       const next = () => {
         while (!isCompleted && main.hasAvailableWorker() && queue.length > 0) {
           const staticRoute = queue.shift();
           if (staticRoute) {
-            render(staticRoute);
+            render(staticRoute).catch((e) => {
+              console.error(`render failed for ${staticRoute.pathname}`, e);
+            });
           }
         }
         if (!isCompleted && isRoutesLoaded && queue.length === 0 && active.size === 0) {
           isCompleted = true;
-          completed();
+          completed().catch((e) => {
+            console.error("SSG completion failed", e);
+          });
         }
       };
       let isPendingDrain = false;
@@ -956,12 +484,13 @@ ${bold(red(`!!! ${result.pathname}: Error during SSG`))}`);
             generatorResult.rendered++;
             generatorResult.staticPaths.push(result.pathname);
             const base = opts.rootDir ?? opts.outDir;
-            const path = relative2(base, result.filePath);
+            const path = relative(base, result.filePath);
             const lastSlash = path.lastIndexOf("/");
             log.info(`${dim(path.slice(0, lastSlash + 1))}${path.slice(lastSlash + 1)}`);
           }
           flushQueue();
         } catch (e) {
+          console.error(`render failed for ${staticRoute.pathname}`, e);
           isCompleted = true;
           reject(e);
         }
@@ -1030,8 +559,12 @@ ${bold(red(`!!! ${result.pathname}: Error during SSG`))}`);
         isRoutesLoaded = true;
         flushQueue();
       };
-      loadStaticRoutes();
+      loadStaticRoutes().catch((e) => {
+        console.error("SSG route loading failed", e);
+        reject(e);
+      });
     } catch (e) {
+      console.error("SSG main thread failed", e);
       reject(e);
     }
   });
@@ -1062,11 +595,267 @@ function validateOptions(opts) {
   try {
     new URL(siteOrigin);
   } catch (e) {
-    throw new Error(`Invalid "origin": ${e}`);
+    throw new Error(`Invalid "origin"`, { cause: e });
+  }
+}
+
+async function workerThread(sys) {
+  delete globalThis.__qwik;
+  const ssgOpts = sys.getOptions();
+  const pendingPromises = /* @__PURE__ */ new Set();
+  const log = await sys.createLogger();
+  const opts = {
+    ...ssgOpts,
+    // TODO export this from server
+    render: (await import(pathToFileURL(ssgOpts.renderModulePath).href)).default,
+    // TODO this should be built-in
+    qwikRouterConfig: (await import(pathToFileURL(ssgOpts.qwikRouterConfigModulePath).href)).default
+  };
+  sys.createWorkerProcess(async (msg) => {
+    switch (msg.type) {
+      case "render": {
+        log.debug(`Worker thread rendering: ${msg.pathname}`);
+        return new Promise((resolve) => {
+          workerRender(sys, opts, msg, pendingPromises, resolve).catch((e) => {
+            console.error("Error during render", msg.pathname, e);
+          });
+        });
+      }
+      case "close": {
+        if (pendingPromises.size) {
+          log.debug(`Worker thread closing, waiting for ${pendingPromises.size} pending renders`);
+          const promises = Array.from(pendingPromises);
+          pendingPromises.clear();
+          await Promise.all(promises);
+        }
+        log.debug(`Worker thread closed`);
+        return { type: "close" };
+      }
+    }
+  })?.catch((e) => {
+    console.error("Worker process creation failed", e);
+  });
+}
+async function workerRender(sys, opts, staticRoute, pendingPromises, callback) {
+  const url = new URL(staticRoute.pathname, opts.origin);
+  const result = {
+    type: "render",
+    pathname: staticRoute.pathname,
+    url: url.href,
+    ok: false,
+    error: null,
+    filePath: null,
+    contentType: null,
+    resourceType: null
+  };
+  try {
+    let routeWriter = null;
+    let closeResolved;
+    const closePromise = new Promise((closePromiseResolve) => {
+      closeResolved = closePromiseResolve;
+    });
+    const request = new Request(url);
+    const requestCtx = {
+      mode: "static",
+      locale: void 0,
+      url,
+      request,
+      env: {
+        get(key) {
+          return sys.getEnv(key);
+        }
+      },
+      platform: sys.platform,
+      getClientConn: () => {
+        return {};
+      },
+      getWritableStream: (status, headers, _, _r, requestEv) => {
+        result.ok = status >= 200 && status < 300;
+        if (!result.ok) {
+          return noopWritableStream;
+        }
+        result.contentType = (headers.get("Content-Type") || "").toLowerCase();
+        const isHtml = result.contentType.includes("text/html");
+        const is404ErrorPage = url.pathname.endsWith("/404.html");
+        const routeFilePath = sys.getRouteFilePath(url.pathname, isHtml);
+        if (is404ErrorPage) {
+          result.resourceType = "404";
+        } else if (isHtml) {
+          result.resourceType = "page";
+        }
+        const hasRouteWriter = isHtml ? opts.emitHtml !== false : true;
+        const writeQDataEnabled = isHtml && opts.emitData !== false;
+        const stream = new WritableStream({
+          async start() {
+            try {
+              if (hasRouteWriter || writeQDataEnabled) {
+                await sys.ensureDir(routeFilePath);
+              }
+              if (hasRouteWriter) {
+                routeWriter = sys.createWriteStream(routeFilePath);
+                routeWriter.on("error", (e) => {
+                  console.error(e);
+                  routeWriter = null;
+                  result.error = {
+                    message: e.message,
+                    stack: e.stack
+                  };
+                });
+              }
+            } catch (e) {
+              console.error("Error during stream start", staticRoute.pathname, e);
+              routeWriter = null;
+              result.error = {
+                message: String(e),
+                stack: e.stack || ""
+              };
+            }
+          },
+          write(chunk) {
+            try {
+              if (routeWriter) {
+                routeWriter.write(Buffer.from(chunk.buffer));
+              }
+            } catch (e) {
+              console.error("Error during stream write", staticRoute.pathname, e);
+              routeWriter = null;
+              result.error = {
+                message: String(e),
+                stack: e.stack || ""
+              };
+            }
+          },
+          async close() {
+            const writePromises = [];
+            try {
+              if (writeQDataEnabled) {
+                const qData = requestEv.sharedMap.get(RequestEvShareQData);
+                if (qData && !is404ErrorPage) {
+                  const qDataFilePath = sys.getDataFilePath(url.pathname);
+                  const dataWriter = sys.createWriteStream(qDataFilePath);
+                  dataWriter.on("error", (e) => {
+                    console.error(e);
+                    result.error = {
+                      message: e.message,
+                      stack: e.stack
+                    };
+                  });
+                  const serialized = await _serialize([qData]);
+                  dataWriter.write(serialized);
+                  writePromises.push(
+                    new Promise((resolve) => {
+                      result.filePath = routeFilePath;
+                      dataWriter.end(resolve);
+                    })
+                  );
+                }
+              }
+              if (routeWriter) {
+                writePromises.push(
+                  new Promise((resolve) => {
+                    result.filePath = routeFilePath;
+                    routeWriter.end(resolve);
+                  }).finally(closeResolved)
+                );
+              }
+              if (writePromises.length > 0) {
+                await Promise.all(writePromises);
+              }
+            } catch (e) {
+              console.error("Error during stream close", staticRoute.pathname, e);
+              routeWriter = null;
+              result.error = {
+                message: String(e),
+                stack: e.stack || ""
+              };
+            }
+          }
+        });
+        return stream;
+      }
+    };
+    const promise = requestHandler(requestCtx, opts).then((rsp) => {
+      if (rsp != null) {
+        return rsp.completion.then((r) => {
+          if (routeWriter) {
+            return closePromise.then(() => r);
+          }
+          return r;
+        });
+      }
+    }).then((e) => {
+      if (e !== void 0) {
+        if (e instanceof RedirectMessage) {
+          return;
+        }
+        if (e instanceof Error) {
+          result.error = {
+            message: e.message,
+            stack: e.stack
+          };
+        } else {
+          result.error = {
+            message: String(e),
+            stack: void 0
+          };
+        }
+        console.error("Error during request handling", staticRoute.pathname, e);
+      }
+    }).catch((e) => {
+      console.error("Unhandled error during request handling", staticRoute.pathname, e);
+      result.error = {
+        message: String(e),
+        stack: e.stack || ""
+      };
+    }).finally(() => {
+      pendingPromises.delete(promise);
+      callback(result);
+    });
+    pendingPromises.add(promise);
+  } catch (e) {
+    console.error("Error during render", staticRoute.pathname, e);
+    if (e instanceof Error) {
+      result.error = {
+        message: e.message,
+        stack: e.stack
+      };
+    } else {
+      result.error = {
+        message: String(e),
+        stack: void 0
+      };
+    }
+    callback(result);
   }
 }
+const noopWriter = {
+  closed: Promise.resolve(void 0),
+  ready: Promise.resolve(void 0),
+  desiredSize: 0,
+  async close() {
+  },
+  async abort() {
+  },
+  async write() {
+  },
+  releaseLock() {
+  }
+};
+const noopWritableStream = {
+  get locked() {
+    return false;
+  },
+  set locked(_) {
+  },
+  async abort() {
+  },
+  async close() {
+  },
+  getWriter() {
+    return noopWriter;
+  }
+};
 
-// packages/qwik-router/src/static/node/index.ts
 async function generate(opts) {
   if (isMainThread) {
     const sys = await createSystem(opts);
@@ -1076,11 +865,20 @@ async function generate(opts) {
   throw new Error(`generate() cannot be called from a worker thread`);
 }
 if (!isMainThread && workerData) {
+  const opts = workerData;
   (async () => {
-    const sys = await createSystem(workerData);
-    await workerThread(sys);
-  })();
+    try {
+      if (opts.log === "debug") {
+        console.debug(`Worker thread starting (ID: ${threadId})`);
+      }
+      const sys = await createSystem(opts, threadId);
+      await workerThread(sys);
+    } catch (error) {
+      console.error(`Error occurred in worker thread (ID: ${threadId}): ${error}`);
+    }
+  })().catch((e) => {
+    console.error(e);
+  });
 }
-export {
-  generate
-};
+
+export { generate };