@qwik.dev/router 2.0.0-beta.4 → 2.0.0-beta.40

package/lib/middleware/vercel-edge/index.mjs

@@ -1,109 +1,84 @@
-// packages/qwik-router/src/middleware/vercel-edge/index.ts
-import { getNotFound } from "@qwik-router-not-found-paths";
-import { isStaticPath } from "@qwik-router-static-paths";
-import { _deserialize, _serialize, _verifySerializable } from "@qwik.dev/core/internal";
+import { isDev } from "@qwik.dev/core/build";
 import { setServerPlatform } from "@qwik.dev/core/server";
-import { mergeHeadersCookies, requestHandler } from "../request-handler/index.mjs";
+import { getErrorHtml, isStaticPath, mergeHeadersCookies, requestHandler } from "@qwik.dev/router/middleware/request-handler";
 var COUNTRY_HEADER_NAME = "x-vercel-ip-country";
 var IP_HEADER_NAME = "x-real-ip";
 var VERCEL_COOKIE = "__vdpl";
 var VERCEL_SKEW_PROTECTION_ENABLED = "VERCEL_SKEW_PROTECTION_ENABLED";
 var VERCEL_DEPLOYMENT_ID = "VERCEL_DEPLOYMENT_ID";
 var BASE_URL = "BASE_URL";
-function createQwikRouter(opts) {
-  if (opts.qwikCityPlan && !opts.qwikRouterConfig) {
-    console.warn("qwikCityPlan is deprecated. Use qwikRouterConfig instead.");
-    opts.qwikRouterConfig = opts.qwikCityPlan;
-  } else if (!opts.qwikRouterConfig) {
-    throw new Error("qwikRouterConfig is required.");
-  }
-  const qwikSerializer = {
-    _deserialize,
-    _serialize,
-    _verifySerializable
-  };
-  if (opts.manifest) {
-    setServerPlatform(opts.manifest);
-  }
-  async function onVercelEdgeRequest(request) {
-    try {
-      const url = new URL(request.url);
-      if (isStaticPath(request.method, url)) {
-        return new Response(null, {
-          headers: {
-            "x-middleware-next": "1"
-          }
-        });
-      }
-      const p = (() => globalThis.process)();
-      const serverRequestEv = {
-        mode: "server",
-        locale: void 0,
-        url,
-        request,
-        env: {
-          get(key) {
-            return p.env[key];
-          }
-        },
-        getWritableStream: (status, headers, cookies, resolve) => {
-          const { readable, writable } = new TransformStream();
-          if (serverRequestEv.env.get(VERCEL_SKEW_PROTECTION_ENABLED)) {
-            const deploymentId = serverRequestEv.env.get(VERCEL_DEPLOYMENT_ID) || "";
-            const baseUrl = serverRequestEv.env.get(BASE_URL) || "/";
-            if (request.headers.has("Sec-Fetch-Dest")) {
-              cookies.set(VERCEL_COOKIE, deploymentId, {
-                path: baseUrl,
-                secure: true,
-                sameSite: true,
-                httpOnly: true
-              });
-            }
-          }
-          const response = new Response(readable, {
-            status,
-            headers: mergeHeadersCookies(headers, cookies)
-          });
-          resolve(response);
-          return writable;
-        },
-        platform: {},
-        getClientConn: () => {
-          return {
-            ip: request.headers.get(IP_HEADER_NAME) ?? void 0,
-            country: request.headers.get(COUNTRY_HEADER_NAME) ?? void 0
-          };
-        }
-      };
-      const handledResponse = await requestHandler(serverRequestEv, opts, qwikSerializer);
-      if (handledResponse) {
-        handledResponse.completion.then((v) => {
-          if (v) {
-            console.error(v);
-          }
-        });
-        const response = await handledResponse.response;
-        if (response) {
-          return response;
-        }
-      }
-      const notFoundHtml = isStaticPath(request.method || "GET", url) ? "Not Found" : getNotFound(url.pathname);
-      return new Response(notFoundHtml, {
-        status: 404,
-        headers: { "Content-Type": "text/html; charset=utf-8", "X-Not-Found": url.pathname }
-      });
-    } catch (e) {
-      console.error(e);
-      return new Response(String(e || "Error"), {
-        status: 500,
-        headers: { "Content-Type": "text/plain; charset=utf-8", "X-Error": "vercel-edge" }
-      });
-    }
-  }
-  return onVercelEdgeRequest;
+/** @public */ function createQwikRouter(opts) {
+	if (opts.manifest) setServerPlatform(opts.manifest);
+	async function onVercelEdgeRequest(request) {
+		try {
+			const url = new URL(request.url);
+			if (isStaticPath(request.method, url)) return new Response(null, { headers: { "x-middleware-next": "1" } });
+			const p = (() => globalThis.process)();
+			const serverRequestEv = {
+				mode: "server",
+				locale: void 0,
+				url,
+				request,
+				env: { get(key) {
+					return p.env[key];
+				} },
+				getWritableStream: (status, headers, cookies, resolve) => {
+					const { readable, writable } = new TransformStream();
+					if (serverRequestEv.env.get(VERCEL_SKEW_PROTECTION_ENABLED)) {
+						const deploymentId = serverRequestEv.env.get(VERCEL_DEPLOYMENT_ID) || "";
+						const baseUrl = serverRequestEv.env.get(BASE_URL) || "/";
+						if (request.headers.has("Sec-Fetch-Dest")) cookies.set(VERCEL_COOKIE, deploymentId, {
+							path: baseUrl,
+							secure: true,
+							sameSite: true,
+							httpOnly: true
+						});
+					}
+					resolve(new Response(readable, {
+						status,
+						headers: mergeHeadersCookies(headers, cookies)
+					}));
+					return writable;
+				},
+				platform: {},
+				getClientConn: () => {
+					return {
+						ip: request.headers.get(IP_HEADER_NAME) ?? void 0,
+						country: request.headers.get(COUNTRY_HEADER_NAME) ?? void 0
+					};
+				}
+			};
+			const handledResponse = await requestHandler(serverRequestEv, opts);
+			if (handledResponse) {
+				handledResponse.completion.then((completion) => {
+					if (completion) console.error(completion);
+				});
+				const response = await handledResponse.response;
+				if (response) return response;
+			}
+			const notFoundHtml = !request.headers.get("accept")?.includes("text/html") || isStaticPath(request.method || "GET", url) ? "Not Found" : getErrorHtml(404, "Not Found");
+			return new Response(notFoundHtml, {
+				status: 404,
+				headers: {
+					"Content-Type": "text/html; charset=utf-8",
+					"X-Not-Found": url.pathname
+				}
+			});
+		} catch (e) {
+			console.error(e);
+			return new Response(isDev ? String(e || "Error") : "Internal Server Error", {
+				status: 500,
+				headers: {
+					"Content-Type": "text/plain; charset=utf-8",
+					"X-Error": "vercel-edge"
+				}
+			});
+		}
+	}
+	return onVercelEdgeRequest;
 }
-var createQwikCity = createQwikRouter;
-export {
-  createQwikCity,
-  createQwikRouter
-};
+/**
+* @deprecated Use `createQwikRouter` instead. Will be removed in V3
+* @public
+*/ var createQwikCity = createQwikRouter;
+export { createQwikCity, createQwikRouter };

package/lib/modules.d.ts

@@ -1,15 +1,18 @@
 declare module '@qwik-router-config' {
-  export const routes: any[];
-  export const menus: any[];
+  import type { RouteData, RouteModule } from '@qwik.dev/router';
+  export const routes: RouteData;
+  export const serverPlugins: RouteModule[];
   export const trailingSlash: boolean;
   export const basePathname: string;
   export const cacheModules: boolean;
+  export const fallthrough: boolean;
   const defaultExport: {
-    routes: any[];
-    menus: any[];
+    routes: RouteData;
+    serverPlugins: RouteModule[];
     trailingSlash: boolean;
     basePathname: string;
     cacheModules: boolean;
+    fallthrough: boolean;
   };
   export default defaultExport;
 }
@@ -19,20 +22,12 @@ declare module '@qwik-city-plan' {
   export { default } from '@qwik-router-config';
 }
 
-declare module '@qwik-router-not-found-paths' {
-  function getNotFound(_pathname: string): string;
-  export { getNotFound };
-}
-
 declare module '@qwik-city-not-found-paths' {
-  export * from '@qwik-router-not-found-paths';
-}
-
-declare module '@qwik-router-static-paths' {
-  function isStaticPath(method: string, url: URL): boolean;
-  export { isStaticPath };
+  /** @deprecated Use `getNotFound` from `@qwik.dev/router/middleware/request-handler` instead. */
+  export { getNotFound } from '@qwik.dev/router/middleware/request-handler';
 }
 
 declare module '@qwik-city-static-paths' {
-  export * from '@qwik-router-static-paths';
+  /** @deprecated Use `isStaticPath` from `@qwik.dev/router/middleware/request-handler` instead. */
+  export { isStaticPath } from '@qwik.dev/router/middleware/request-handler';
 }

package/lib/service-worker/index.mjs

@@ -0,0 +1,13 @@
+/**
+* @deprecated This is no longer needed, Qwik now automatically embeds preloading logic into the
+*   application.
+*
+*   If your service-worker.ts file contains no custom code, you should deploy to production until
+*   you're sure that all users picked up the new version, then you can remove it and also remove
+*   the `<ServiceWorkerRegister />` component from your `Root.tsx`.
+*
+*   If you do have custom service worker logic, you should keep the `service-worker.ts` file and
+*   `<ServiceWorkerRegister />` component, but remove the `setupServiceWorker()` call.
+* @public
+*/ var setupServiceWorker = () => {};
+export { setupServiceWorker };

package/lib/{static → ssg}/index.d.ts

@@ -1,3 +1,5 @@
+import type { QwikRouterConfig } from '@qwik.dev/router';
+import type { Render } from '@qwik.dev/core/server';
 import type { RenderOptions } from '@qwik.dev/core/server';
 
 /**
@@ -6,26 +8,43 @@ import type { RenderOptions } from '@qwik.dev/core/server';
  *
  * @public
  */
-export declare function generate(opts: StaticGenerateOptions): Promise<StaticGenerateResult>;
+export declare function generate(opts: SsgInternalOptions): Promise<StaticGenerateResult>;
+
+/**
+ * Run SSG as a standalone process. Writes `_static-paths.json` to `outDir` and exits with code 0 on
+ * success, 1 on error.
+ *
+ * Intended to be called from a generated `run-ssg.js` wrapper that provides render/config.
+ *
+ * @public
+ */
+export declare function runSsg(opts: SsgInternalOptions): Promise<never>;
+
+/**
+ * Internal SSG options that include the render function and router config.
+ *
+ * @public
+ */
+export declare interface SsgInternalOptions extends SsgOptions {
+    /** SSR render function (default export from `entry.ssr`); worker-only — the main entry omits it. */
+    render: Render;
+    /** The Qwik Router Config object (default export from `@qwik-router-config`). */
+    qwikRouterConfig: QwikRouterConfig;
+    /** Path or URL to the worker entry file (`run-ssg-worker.js`); workers are spawned from it. */
+    workerFilePath?: string | URL;
+}
 
 /** @public */
-export declare interface StaticGenerateOptions extends StaticGenerateRenderOptions {
-    /**
-     * Path to the SSR module exporting the default render function. In most cases it'll be
-     * `./src/entry.ssr.tsx`.
-     */
-    renderModulePath: string;
-    /** Path to the Qwik Router Config module exporting the default `@qwik-router-config`. */
-    qwikRouterConfigModulePath: string;
-    /** @deprecated Use `qwikRouterConfigModulePath` instead. Will be removed in V3 */
-    qwikCityPlanModulePath?: string;
+declare interface SsgOptions extends SsgRenderOptions {
     /** Defaults to `/` */
     basePathname?: string;
     rootDir?: string;
 }
+export { SsgOptions }
+export { SsgOptions as StaticGenerateOptions }
 
 /** @public */
-export declare interface StaticGenerateRenderOptions extends RenderOptions {
+export declare interface SsgRenderOptions extends RenderOptions {
     /** File system directory where the static files should be written. */
     outDir: string;
     /**
@@ -53,24 +72,19 @@ export declare interface StaticGenerateRenderOptions extends RenderOptions {
      * root of the `outDir`. Setting to `null` will prevent the sitemap from being created.
      */
     sitemapOutFile?: string | null;
-    /** Log level. */
-    log?: 'debug';
+    /** Log level. `'quiet'` suppresses per-page output, `'debug'` enables verbose logging. */
+    log?: 'debug' | 'quiet';
     /**
      * Set to `false` if the generated static HTML files should not be written to disk. Setting to
-     * `false` is useful if the SSG should only write the `q-data.json` files to disk. Defaults to
+     * `false` is useful if the SSG should only write the per-loader data files to disk. Defaults to
      * `true`.
      */
     emitHtml?: boolean;
     /**
-     * Set to `false` if the generated `q-data.json` data files should not be written to disk.
-     * Defaults to `true`.
+     * Set to `false` if the generated per-loader data files should not be written to disk. Defaults
+     * to `true`.
      */
     emitData?: boolean;
-    /**
-     * Set to `false` if the static build should not write custom or default `404.html` pages.
-     * Defaults to `true`.
-     */
-    emit404Pages?: boolean;
     /**
      * Defines file system routes relative to the source `routes` directory that should be static
      * generated. Accepts wildcard behavior. This should not include the "base" pathname. If not
@@ -85,6 +99,16 @@ export declare interface StaticGenerateRenderOptions extends RenderOptions {
     exclude?: string[];
 }
 
+/**
+ * Bootstrap a worker thread for SSG rendering. Called from the generated `run-ssg.js` when it
+ * detects it's running as a worker thread.
+ *
+ * @param opts - Must include `render` and `qwikRouterConfig` (imported by the worker entry). The
+ *   remaining serializable options come from `workerData`.
+ * @public
+ */
+export declare function startWorker(opts: Pick<SsgInternalOptions, 'render' | 'qwikRouterConfig'>): Promise<void>;
+
 /** @public */
 export declare interface StaticGenerateResult {
     duration: number;

package/lib/ssg/index.mjs

@@ -0,0 +1,257 @@
+import { n as getPathnameForDynamicRoute, t as ensureSlash } from "../chunks/pathname.mjs";
+import { r as msToString } from "../chunks/format.mjs";
+import { t as createRouteTester } from "../chunks/routes.mjs";
+import { relative } from "node:path";
+import { bold, dim, green, magenta, red } from "kleur/colors";
+function validateOptions(opts) {
+	if (!opts.qwikRouterConfig) throw new Error(`Missing "qwikRouterConfig" option`);
+	let siteOrigin = opts.origin;
+	if (typeof siteOrigin !== "string" || siteOrigin.trim().length === 0) throw new Error(`Missing "origin" option`);
+	siteOrigin = siteOrigin.trim();
+	if (!/:\/\//.test(siteOrigin) || siteOrigin.startsWith("://")) throw new Error(`"origin" must start with a valid protocol, such as "https://" or "http://", received "${siteOrigin}"`);
+	try {
+		new URL(siteOrigin);
+	} catch (e) {
+		throw new Error(`Invalid "origin"`, { cause: e });
+	}
+}
+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 = opts.qwikRouterConfig;
+	const renderTimeout = 3e4;
+	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((resolve, reject) => {
+		try {
+			const timer = sys.createTimer();
+			const generatorResult = {
+				duration: 0,
+				rendered: 0,
+				errors: 0,
+				staticPaths: []
+			};
+			let isCompleted = false;
+			let isRoutesLoaded = false;
+			const completed = async () => {
+				const closePromise = main.close();
+				generatorResult.duration = timer();
+				if (generatorResult.errors === 0) {
+					log.info(`\n${green("SSG results")}`);
+					if (generatorResult.rendered > 0) log.info(`- Generated: ${dim(`${generatorResult.rendered} page${generatorResult.rendered === 1 ? "" : "s"}`)}`);
+					log.info(`- Duration: ${dim(msToString(generatorResult.duration))}`);
+					const total = generatorResult.rendered + generatorResult.errors;
+					if (total > 0) log.info(`- Average: ${dim(msToString(generatorResult.duration / total) + " per page")}`);
+					log.info(``);
+				}
+				closePromise.then(() => {
+					setTimeout(() => resolve(generatorResult));
+				}).catch(reject);
+			};
+			const next = () => {
+				while (!isCompleted && main.hasAvailableWorker() && queue.length > 0) {
+					const staticRoute = queue.shift();
+					if (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().catch((e) => {
+						console.error("SSG completion failed", e);
+					});
+				}
+			};
+			let isPendingDrain = false;
+			const flushQueue = () => {
+				if (!isPendingDrain) {
+					isPendingDrain = true;
+					setTimeout(() => {
+						isPendingDrain = false;
+						next();
+					});
+				}
+			};
+			const render = async (staticRoute) => {
+				try {
+					active.add(staticRoute.pathname);
+					log.debug(`render start: ${staticRoute.pathname}`);
+					const result = await Promise.race([main.render({
+						type: "render",
+						...staticRoute
+					}), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`SSG render timed out after ${renderTimeout}ms`)), renderTimeout))]);
+					active.delete(staticRoute.pathname);
+					log.debug(`render done: ${staticRoute.pathname}`);
+					if (result.error) {
+						const err = new Error(result.error.message);
+						err.stack = result.error.stack;
+						log.error(`\n${bold(red(`!!! ${result.pathname}: Error during SSG`))}`);
+						log.error(red(err.message));
+						log.error(`  Pathname: ${magenta(staticRoute.pathname)}`);
+						if (err.stack) log.error(dim(err.stack));
+						generatorResult.errors++;
+					}
+					if (result.filePath != null) {
+						generatorResult.rendered++;
+						generatorResult.staticPaths.push(result.pathname);
+						const base = opts.rootDir ?? opts.outDir;
+						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);
+				}
+			};
+			const addToQueue = (pathname, params) => {
+				if (pathname) {
+					pathname = new URL(pathname, `https://qwik.dev`).pathname;
+					if (pathname !== opts.basePathname) {
+						if (trailingSlash) {
+							if (!pathname.endsWith("/")) {
+								const segments = pathname.split("/");
+								if (!segments[segments.length - 1].includes(".")) pathname = ensureSlash(pathname);
+							}
+						} else if (pathname.endsWith("/")) pathname = pathname.slice(0, pathname.length - 1);
+					}
+					if (includeRoute(pathname) && !queue.some((s) => s.pathname === pathname)) {
+						queue.push({
+							pathname,
+							params
+						});
+						flushQueue();
+					}
+				}
+			};
+			/**
+			* Traverse the route tree and call the callback for each route that has module loaders.
+			* Reconstructs the original pathname and param names from the tree path. Accumulates _L
+			* layout loaders from ancestors during traversal.
+			*/ const traverseRouteTree = async (node, pathParts, basePathname, ancestorLoaders) => {
+				const currentLoaders = node._L ? [...ancestorLoaders, node._L] : ancestorLoaders;
+				const index = node._I;
+				if (index) {
+					const pageLoaders = Array.isArray(index) ? index : [...currentLoaders, index];
+					const joinedParts = pathParts.join("/");
+					const originalPathname = basePathname + (joinedParts ? ensureSlash(joinedParts) : "");
+					const paramNames = pathParts.filter((p) => p.startsWith("[") && p.endsWith("]")).map((p) => p.startsWith("[...") ? p.slice(4, -1) : p.slice(1, -1));
+					if (paramNames.length === 0) addToQueue(originalPathname, void 0);
+					else {
+						const pageLoader = pageLoaders[pageLoaders.length - 1];
+						if (typeof pageLoader === "function") {
+							const pageModule = await pageLoader();
+							if (typeof pageModule.onStaticGenerate === "function") {
+								const staticGenerate = await pageModule.onStaticGenerate({ env: { get(key) {
+									return sys.getEnv(key);
+								} } });
+								if (Array.isArray(staticGenerate.params)) for (const params of staticGenerate.params) {
+									const pathname = getPathnameForDynamicRoute(originalPathname, paramNames, params);
+									addToQueue(pathname, params);
+								}
+							}
+						}
+					}
+				}
+				if (node._4 || node._E) {
+					if (!pathParts.some((p) => p.startsWith("["))) {
+						const joinedParts = pathParts.join("/");
+						const dirPathname = basePathname + (joinedParts ? ensureSlash(joinedParts) : "");
+						addToQueue(dirPathname + "404.html", void 0);
+					}
+				}
+				if (node._M) for (const group of node._M) await traverseRouteTree(group, pathParts, basePathname, currentLoaders);
+				if (node._W && typeof node._W === "object") {
+					const childNode = node._W;
+					const paramName = childNode._P;
+					const pathPart = paramName ? `[${paramName}]` : "[param]";
+					await traverseRouteTree(childNode, [...pathParts, pathPart], basePathname, currentLoaders);
+				}
+				if (node._A && typeof node._A === "object") {
+					const childNode = node._A;
+					const paramName = childNode._P;
+					const pathPart = paramName ? `[...${paramName}]` : "[...rest]";
+					await traverseRouteTree(childNode, [...pathParts, pathPart], basePathname, currentLoaders);
+				}
+				for (const [key, child] of Object.entries(node)) {
+					if (key.charCodeAt(0) === 95) continue;
+					await traverseRouteTree(child, [...pathParts, key], basePathname, currentLoaders);
+				}
+			};
+			const loadStaticRoutes = async () => {
+				log.debug("traversing route tree...");
+				await traverseRouteTree(routes, [], "/", []);
+				log.debug(`route tree traversed, ${queue.length} routes queued, ${active.size} active`);
+				isRoutesLoaded = true;
+				flushQueue();
+			};
+			loadStaticRoutes().catch((e) => {
+				console.error("SSG route loading failed", e);
+				reject(e);
+			});
+		} catch (e) {
+			console.error("SSG main thread failed", e);
+			reject(e);
+		}
+	});
+}
+/**
+* Use this function when SSG should be generated from another module, such as a Vite plugin. This
+* function's should be passed the paths of the entry module and Qwik Router Plan.
+*
+* @public
+*/ async function generate(opts) {
+	const { createSystem } = await import("../chunks/system.mjs");
+	return mainThread(await createSystem(opts));
+}
+/**
+* Run SSG as a standalone process. Writes `_static-paths.json` to `outDir` and exits with code 0 on
+* success, 1 on error.
+*
+* Intended to be called from a generated `run-ssg.js` wrapper that provides render/config.
+*
+* @public
+*/ async function runSsg(opts) {
+	try {
+		const result = await generate(opts);
+		const fs = await import("node:fs");
+		const { join } = await import("node:path");
+		const staticPathsFile = join(opts.outDir, "_static-paths.json");
+		await fs.promises.writeFile(staticPathsFile, JSON.stringify(result.staticPaths));
+		if (result.errors > 0) {
+			console.error(`SSG completed with ${result.errors} error(s)`);
+			process.exit(1);
+		}
+		process.exit(0);
+	} catch (e) {
+		console.error("SSG failed:", e);
+		process.exit(1);
+	}
+}
+/**
+* Bootstrap a worker thread for SSG rendering. Called from the generated `run-ssg.js` when it
+* detects it's running as a worker thread.
+*
+* @param opts - Must include `render` and `qwikRouterConfig` (imported by the worker entry). The
+*   remaining serializable options come from `workerData`.
+* @public
+*/ async function startWorker(opts) {
+	const { workerData } = await import("node:worker_threads");
+	const mergedOpts = {
+		...workerData,
+		render: opts.render,
+		qwikRouterConfig: opts.qwikRouterConfig
+	};
+	const { createSystem } = await import("../chunks/system.mjs");
+	const { workerThread } = await import("../chunks/worker-thread.mjs");
+	await workerThread(await createSystem(mergedOpts, workerData?.threadId));
+}
+export { generate, runSsg, startWorker };