@sveltejs/kit 1.0.0-next.291 → 1.0.0-next.292

package/dist/chunks/index2.js

@@ -1,30 +1,42 @@
-import fs__default from 'fs';
-import path__default from 'path';
-import { e as print_config_conflicts, b as copy_assets, p as posixify, d as get_aliases, r as resolve_entry, g as get_runtime_path, l as load_template, m as mkdirp, f as rimraf } from '../cli.js';
-import { d as deep_merge, a as create_app, g as generate_tsconfig, c as create_manifest_data } from './tsconfig.js';
+import fs__default, { readFileSync, writeFileSync } from 'fs';
+import path__default, { join, dirname } from 'path';
+import { p as posixify, m as mkdirp, r as rimraf } from './filesystem.js';
+import { all } from './sync.js';
+import { p as print_config_conflicts, b as get_aliases, r as resolve_entry, g as get_runtime_path, l as load_template } from '../cli.js';
 import { g as generate_manifest } from './index3.js';
 import vite from 'vite';
 import { s } from './misc.js';
+import { d as deep_merge } from './object.js';
+import { n as normalize_path, r as resolve, i as is_root_relative } from './url.js';
 import { svelte } from '@sveltejs/vite-plugin-svelte';
+import { pathToFileURL, URL } from 'url';
+import { installFetch } from '../install-fetch.js';
 import 'sade';
 import 'child_process';
 import 'net';
-import 'url';
 import 'os';
+import 'node:http';
+import 'node:https';
+import 'node:zlib';
+import 'node:stream';
+import 'node:util';
+import 'node:url';
 
 /**
  * @param {{
  *   cwd: string;
  *   assets_base: string;
- *   config: import('types').ValidatedConfig
- *   manifest_data: import('types').ManifestData
+ *   config: import('types').ValidatedConfig;
+ *   manifest_data: import('types').ManifestData;
  *   output_dir: string;
  *   service_worker_entry_file: string | null;
  * }} options
+ * @param {import('types').Prerendered} prerendered
  * @param {import('vite').Manifest} client_manifest
  */
 async function build_service_worker(
 	{ cwd, assets_base, config, manifest_data, output_dir, service_worker_entry_file },
+	prerendered,
 	client_manifest
 ) {
 	// TODO add any assets referenced in template .html file, e.g. favicon?
@@ -57,6 +69,12 @@ async function build_service_worker(
 					.map((asset) => `${s(`${config.kit.paths.base}/${asset.file}`)}`)
 					.join(',\n\t\t\t\t')}
 			];
+
+			export const prerendered = [
+				${prerendered.paths
+					.map((path) => s(normalize_path(path, config.kit.trailingSlash)))
+					.join(',\n\t\t\t\t')}
+			];
 		`
 			.replace(/^\t{3}/gm, '')
 			.trim()
@@ -161,14 +179,6 @@ async function build_client({
 	process.env.VITE_SVELTEKIT_APP_VERSION_FILE = `${config.kit.appDir}/version.json`;
 	process.env.VITE_SVELTEKIT_APP_VERSION_POLL_INTERVAL = `${config.kit.version.pollInterval}`;
 
-	create_app({
-		config,
-		manifest_data,
-		cwd
-	});
-
-	copy_assets(path__default.join(config.kit.outDir, 'runtime'));
-
 	process.env.VITE_SVELTEKIT_AMP = config.kit.amp ? 'true' : '';
 
 	const client_out_dir = `${output_dir}/client/${config.kit.appDir}`;
@@ -227,7 +237,10 @@ async function build_client({
 					hydratable: !!config.kit.browser.hydrate
 				}
 			})
-		]
+		],
+		// prevent Vite copying the contents of `config.kit.files.assets`,
+		// if it happens to be 'public' instead of 'static'
+		publicDir: false
 	});
 
 	print_config_conflicts(conflicts, 'kit.vite.', 'build_client');
@@ -585,11 +598,630 @@ function get_methods(cwd, output, manifest_data) {
 	return methods;
 }
 
+/** @typedef {{
+ *   fn: () => Promise<any>,
+ *   fulfil: (value: any) => void,
+ *   reject: (error: Error) => void
+ * }} Task */
+
+/** @param {number} concurrency */
+function queue(concurrency) {
+	/** @type {Task[]} */
+	const tasks = [];
+
+	let current = 0;
+
+	/** @type {(value?: any) => void} */
+	let fulfil;
+
+	/** @type {(error: Error) => void} */
+	let reject;
+
+	let closed = false;
+
+	const done = new Promise((f, r) => {
+		fulfil = f;
+		reject = r;
+	});
+
+	done.catch(() => {
+		// this is necessary in case a catch handler is never added
+		// to the done promise by the user
+	});
+
+	function dequeue() {
+		if (current < concurrency) {
+			const task = tasks.shift();
+
+			if (task) {
+				current += 1;
+				const promise = Promise.resolve(task.fn());
+
+				promise
+					.then(task.fulfil, (err) => {
+						task.reject(err);
+						reject(err);
+					})
+					.then(() => {
+						current -= 1;
+						dequeue();
+					});
+			} else if (current === 0) {
+				closed = true;
+				fulfil();
+			}
+		}
+	}
+
+	return {
+		/** @param {() => any} fn */
+		add: (fn) => {
+			if (closed) throw new Error('Cannot add tasks to a queue that has ended');
+
+			const promise = new Promise((fulfil, reject) => {
+				tasks.push({ fn, fulfil, reject });
+			});
+
+			dequeue();
+			return promise;
+		},
+
+		done: () => {
+			if (current === 0) {
+				closed = true;
+				fulfil();
+			}
+
+			return done;
+		}
+	};
+}
+
+const DOCTYPE = 'DOCTYPE';
+const CDATA_OPEN = '[CDATA[';
+const CDATA_CLOSE = ']]>';
+const COMMENT_OPEN = '--';
+const COMMENT_CLOSE = '-->';
+
+const TAG_OPEN = /[a-zA-Z]/;
+const TAG_CHAR = /[a-zA-Z0-9]/;
+const ATTRIBUTE_NAME = /[^\t\n\f />"'=]/;
+
+const WHITESPACE = /[\s\n\r]/;
+
+/** @param {string} html */
+function crawl(html) {
+	/** @type {string[]} */
+	const hrefs = [];
+
+	let i = 0;
+	main: while (i < html.length) {
+		const char = html[i];
+
+		if (char === '<') {
+			if (html[i + 1] === '!') {
+				i += 2;
+
+				if (html.substr(i, DOCTYPE.length).toUpperCase() === DOCTYPE) {
+					i += DOCTYPE.length;
+					while (i < html.length) {
+						if (html[i++] === '>') {
+							continue main;
+						}
+					}
+				}
+
+				// skip cdata
+				if (html.substr(i, CDATA_OPEN.length) === CDATA_OPEN) {
+					i += CDATA_OPEN.length;
+					while (i < html.length) {
+						if (html.substr(i, CDATA_CLOSE.length) === CDATA_CLOSE) {
+							i += CDATA_CLOSE.length;
+							continue main;
+						}
+
+						i += 1;
+					}
+				}
+
+				// skip comments
+				if (html.substr(i, COMMENT_OPEN.length) === COMMENT_OPEN) {
+					i += COMMENT_OPEN.length;
+					while (i < html.length) {
+						if (html.substr(i, COMMENT_CLOSE.length) === COMMENT_CLOSE) {
+							i += COMMENT_CLOSE.length;
+							continue main;
+						}
+
+						i += 1;
+					}
+				}
+			}
+
+			// parse opening tags
+			const start = ++i;
+			if (TAG_OPEN.test(html[start])) {
+				while (i < html.length) {
+					if (!TAG_CHAR.test(html[i])) {
+						break;
+					}
+
+					i += 1;
+				}
+
+				const tag = html.slice(start, i).toUpperCase();
+
+				if (tag === 'SCRIPT' || tag === 'STYLE') {
+					while (i < html.length) {
+						if (
+							html[i] === '<' &&
+							html[i + 1] === '/' &&
+							html.substr(i + 2, tag.length).toUpperCase() === tag
+						) {
+							continue main;
+						}
+
+						i += 1;
+					}
+				}
+
+				let href = '';
+
+				while (i < html.length) {
+					const start = i;
+
+					const char = html[start];
+					if (char === '>') break;
+
+					if (ATTRIBUTE_NAME.test(char)) {
+						i += 1;
+
+						while (i < html.length) {
+							if (!ATTRIBUTE_NAME.test(html[i])) {
+								break;
+							}
+
+							i += 1;
+						}
+
+						const name = html.slice(start, i).toLowerCase();
+
+						while (WHITESPACE.test(html[i])) i += 1;
+
+						if (html[i] === '=') {
+							i += 1;
+							while (WHITESPACE.test(html[i])) i += 1;
+
+							let value;
+
+							if (html[i] === "'" || html[i] === '"') {
+								const quote = html[i++];
+
+								const start = i;
+								let escaped = false;
+
+								while (i < html.length) {
+									if (!escaped) {
+										const char = html[i];
+
+										if (html[i] === quote) {
+											break;
+										}
+
+										if (char === '\\') {
+											escaped = true;
+										}
+									}
+
+									i += 1;
+								}
+
+								value = html.slice(start, i);
+							} else {
+								const start = i;
+								while (html[i] !== '>' && !WHITESPACE.test(html[i])) i += 1;
+								value = html.slice(start, i);
+
+								i -= 1;
+							}
+
+							if (name === 'href') {
+								href = value;
+							} else if (name === 'src') {
+								hrefs.push(value);
+							} else if (name === 'srcset') {
+								const candidates = [];
+								let insideURL = true;
+								value = value.trim();
+								for (let i = 0; i < value.length; i++) {
+									if (value[i] === ',' && (!insideURL || (insideURL && value[i + 1] === ' '))) {
+										candidates.push(value.slice(0, i));
+										value = value.substring(i + 1).trim();
+										i = 0;
+										insideURL = true;
+									} else if (value[i] === ' ') {
+										insideURL = false;
+									}
+								}
+								candidates.push(value);
+								for (const candidate of candidates) {
+									const src = candidate.split(WHITESPACE)[0];
+									hrefs.push(src);
+								}
+							}
+						} else {
+							i -= 1;
+						}
+					}
+
+					i += 1;
+				}
+
+				if (href) {
+					hrefs.push(href);
+				}
+			}
+		}
+
+		i += 1;
+	}
+
+	return hrefs;
+}
+
+/**
+ * Inside a script element, only `</script` and `<!--` hold special meaning to the HTML parser.
+ *
+ * The first closes the script element, so everything after is treated as raw HTML.
+ * The second disables further parsing until `-->`, so the script element might be unexpectedly
+ * kept open until until an unrelated HTML comment in the page.
+ *
+ * U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR are escaped for the sake of pre-2018
+ * browsers.
+ *
+ * @see tests for unsafe parsing examples.
+ * @see https://html.spec.whatwg.org/multipage/scripting.html#restrictions-for-contents-of-script-elements
+ * @see https://html.spec.whatwg.org/multipage/syntax.html#cdata-rcdata-restrictions
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#script-data-state
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#script-data-double-escaped-state
+ * @see https://github.com/tc39/proposal-json-superset
+ * @type {Record<string, string>}
+ */
+const render_json_payload_script_dict = {
+	'<': '\\u003C',
+	'\u2028': '\\u2028',
+	'\u2029': '\\u2029'
+};
+
+new RegExp(
+	`[${Object.keys(render_json_payload_script_dict).join('')}]`,
+	'g'
+);
+
+/**
+ * When inside a double-quoted attribute value, only `&` and `"` hold special meaning.
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#attribute-value-(double-quoted)-state
+ * @type {Record<string, string>}
+ */
+const escape_html_attr_dict = {
+	'&': '&amp;',
+	'"': '&quot;'
+};
+
+const escape_html_attr_regex = new RegExp(
+	// special characters
+	`[${Object.keys(escape_html_attr_dict).join('')}]|` +
+		// high surrogate without paired low surrogate
+		'[\\ud800-\\udbff](?![\\udc00-\\udfff])|' +
+		// a valid surrogate pair, the only match with 2 code units
+		// we match it so that we can match unpaired low surrogates in the same pass
+		// TODO: use lookbehind assertions once they are widely supported: (?<![\ud800-udbff])[\udc00-\udfff]
+		'[\\ud800-\\udbff][\\udc00-\\udfff]|' +
+		// unpaired low surrogate (see previous match)
+		'[\\udc00-\\udfff]',
+	'g'
+);
+
+/**
+ * Formats a string to be used as an attribute's value in raw HTML.
+ *
+ * It escapes unpaired surrogates (which are allowed in js strings but invalid in HTML), escapes
+ * characters that are special in attributes, and surrounds the whole string in double-quotes.
+ *
+ * @param {string} str
+ * @returns {string} Escaped string surrounded by double-quotes.
+ * @example const html = `<tag data-value=${escape_html_attr('value')}>...</tag>`;
+ */
+function escape_html_attr(str) {
+	const escaped_str = str.replace(escape_html_attr_regex, (match) => {
+		if (match.length === 2) {
+			// valid surrogate pair
+			return match;
+		}
+
+		return escape_html_attr_dict[match] ?? `&#${match.charCodeAt(0)};`;
+	});
+
+	return `"${escaped_str}"`;
+}
+
+/**
+ * @typedef {import('types').PrerenderErrorHandler} PrerenderErrorHandler
+ * @typedef {import('types').PrerenderOnErrorValue} OnError
+ * @typedef {import('types').Logger} Logger
+ */
+
+/** @type {(details: Parameters<PrerenderErrorHandler>[0] ) => string} */
+function format_error({ status, path, referrer, referenceType }) {
+	return `${status} ${path}${referrer ? ` (${referenceType} from ${referrer})` : ''}`;
+}
+
+/** @type {(log: Logger, onError: OnError) => PrerenderErrorHandler} */
+function normalise_error_handler(log, onError) {
+	switch (onError) {
+		case 'continue':
+			return (details) => {
+				log.error(format_error(details));
+			};
+		case 'fail':
+			return (details) => {
+				throw new Error(format_error(details));
+			};
+		default:
+			return onError;
+	}
+}
+
+const OK = 2;
+const REDIRECT = 3;
+
+/**
+ * @param {{
+ *   config: import('types').ValidatedConfig;
+ *   entries: string[];
+ *   files: Set<string>;
+ *   log: Logger;
+ * }} opts
+ */
+async function prerender({ config, entries, files, log }) {
+	/** @type {import('types').Prerendered} */
+	const prerendered = {
+		pages: new Map(),
+		assets: new Map(),
+		redirects: new Map(),
+		paths: []
+	};
+
+	if (!config.kit.prerender.enabled) {
+		return prerendered;
+	}
+
+	installFetch();
+
+	const server_root = join(config.kit.outDir, 'output');
+
+	/** @type {import('types').ServerModule} */
+	const { Server, override } = await import(pathToFileURL(`${server_root}/server/index.js`).href);
+	const { manifest } = await import(pathToFileURL(`${server_root}/server/manifest.js`).href);
+
+	override({
+		paths: config.kit.paths,
+		prerendering: true,
+		read: (file) => readFileSync(join(config.kit.files.assets, file))
+	});
+
+	const server = new Server(manifest);
+
+	const error = normalise_error_handler(log, config.kit.prerender.onError);
+
+	const q = queue(config.kit.prerender.concurrency);
+
+	/**
+	 * @param {string} path
+	 * @param {boolean} is_html
+	 */
+	function output_filename(path, is_html) {
+		const file = path.slice(config.kit.paths.base.length + 1);
+
+		if (file === '') {
+			return 'index.html';
+		}
+
+		if (is_html && !file.endsWith('.html')) {
+			return file + (config.kit.trailingSlash === 'always' ? 'index.html' : '.html');
+		}
+
+		return file;
+	}
+
+	const seen = new Set();
+	const written = new Set();
+
+	/**
+	 * @param {string | null} referrer
+	 * @param {string} decoded
+	 * @param {string} [encoded]
+	 */
+	function enqueue(referrer, decoded, encoded) {
+		if (seen.has(decoded)) return;
+		seen.add(decoded);
+
+		const file = decoded.slice(config.kit.paths.base.length + 1);
+		if (files.has(file)) return;
+
+		return q.add(() => visit(decoded, encoded || encodeURI(decoded), referrer));
+	}
+
+	/**
+	 * @param {string} decoded
+	 * @param {string} encoded
+	 * @param {string?} referrer
+	 */
+	async function visit(decoded, encoded, referrer) {
+		if (!decoded.startsWith(config.kit.paths.base)) {
+			error({ status: 404, path: decoded, referrer, referenceType: 'linked' });
+			return;
+		}
+
+		/** @type {Map<string, import('types').PrerenderDependency>} */
+		const dependencies = new Map();
+
+		const response = await server.respond(new Request(`http://sveltekit-prerender${encoded}`), {
+			prerender: {
+				default: config.kit.prerender.default,
+				dependencies
+			}
+		});
+
+		const text = await response.text();
+
+		save('pages', response, text, decoded, encoded, referrer, 'linked');
+
+		for (const [dependency_path, result] of dependencies) {
+			// this seems circuitous, but using new URL allows us to not care
+			// whether dependency_path is encoded or not
+			const encoded_dependency_path = new URL(dependency_path, 'http://localhost').pathname;
+			const decoded_dependency_path = decodeURI(encoded_dependency_path);
+
+			const body = result.body ?? new Uint8Array(await result.response.arrayBuffer());
+			save(
+				'dependencies',
+				result.response,
+				body,
+				decoded_dependency_path,
+				encoded_dependency_path,
+				decoded,
+				'fetched'
+			);
+		}
+
+		if (config.kit.prerender.crawl && response.headers.get('content-type') === 'text/html') {
+			for (const href of crawl(text)) {
+				if (href.startsWith('data:') || href.startsWith('#')) continue;
+
+				const resolved = resolve(encoded, href);
+				if (!is_root_relative(resolved)) continue;
+
+				const parsed = new URL(resolved, 'http://localhost');
+
+				if (parsed.search) ;
+
+				const pathname = normalize_path(parsed.pathname, config.kit.trailingSlash);
+				enqueue(decoded, decodeURI(pathname), pathname);
+			}
+		}
+	}
+
+	/**
+	 * @param {'pages' | 'dependencies'} category
+	 * @param {Response} response
+	 * @param {string | Uint8Array} body
+	 * @param {string} decoded
+	 * @param {string} encoded
+	 * @param {string | null} referrer
+	 * @param {'linked' | 'fetched'} referenceType
+	 */
+	function save(category, response, body, decoded, encoded, referrer, referenceType) {
+		const response_type = Math.floor(response.status / 100);
+		const type = /** @type {string} */ (response.headers.get('content-type'));
+		const is_html = response_type === REDIRECT || type === 'text/html';
+
+		const file = output_filename(decoded, is_html);
+		const dest = `${config.kit.outDir}/output/prerendered/${category}/${file}`;
+
+		if (written.has(file)) return;
+		written.add(file);
+
+		if (response_type === REDIRECT) {
+			const location = response.headers.get('location');
+
+			if (location) {
+				mkdirp(dirname(dest));
+
+				log.warn(`${response.status} ${decoded} -> ${location}`);
+
+				writeFileSync(
+					dest,
+					`<meta http-equiv="refresh" content=${escape_html_attr(`0;url=${location}`)}>`
+				);
+
+				let resolved = resolve(encoded, location);
+				if (is_root_relative(resolved)) {
+					resolved = normalize_path(resolved, config.kit.trailingSlash);
+					enqueue(decoded, decodeURI(resolved), resolved);
+				}
+
+				if (!prerendered.redirects.has(decoded)) {
+					prerendered.redirects.set(decoded, {
+						status: response.status,
+						location: resolved
+					});
+
+					prerendered.paths.push(normalize_path(decoded, 'never'));
+				}
+			} else {
+				log.warn(`location header missing on redirect received from ${decoded}`);
+			}
+
+			return;
+		}
+
+		if (response.status === 200) {
+			mkdirp(dirname(dest));
+
+			log.info(`${response.status} ${decoded}`);
+			writeFileSync(dest, body);
+
+			if (is_html) {
+				prerendered.pages.set(decoded, {
+					file
+				});
+			} else {
+				prerendered.assets.set(decoded, {
+					type
+				});
+			}
+
+			prerendered.paths.push(normalize_path(decoded, 'never'));
+		} else if (response_type !== OK) {
+			error({ status: response.status, path: decoded, referrer, referenceType });
+		}
+	}
+
+	if (config.kit.prerender.enabled) {
+		for (const entry of config.kit.prerender.entries) {
+			if (entry === '*') {
+				for (const entry of entries) {
+					enqueue(null, normalize_path(config.kit.paths.base + entry, config.kit.trailingSlash)); // TODO can we pre-normalize these?
+				}
+			} else {
+				enqueue(null, normalize_path(config.kit.paths.base + entry, config.kit.trailingSlash));
+			}
+		}
+
+		await q.done();
+	}
+
+	const rendered = await server.respond(new Request('http://sveltekit-prerender/[fallback]'), {
+		prerender: {
+			fallback: true,
+			default: false,
+			dependencies: new Map()
+		}
+	});
+
+	const file = `${config.kit.outDir}/output/prerendered/fallback.html`;
+	mkdirp(dirname(file));
+	writeFileSync(file, await rendered.text());
+
+	return prerendered;
+}
+
 /**
  * @param {import('types').ValidatedConfig} config
- * @returns {Promise<import('types').BuildData>}
+ * @param {{ log: import('types').Logger }} opts
  */
-async function build(config) {
+async function build(config, { log }) {
 	const cwd = process.cwd(); // TODO is this necessary?
 
 	const build_dir = path__default.join(config.kit.outDir, 'build');
@@ -600,7 +1232,7 @@ async function build(config) {
 	rimraf(output_dir);
 	mkdirp(output_dir);
 
-	generate_tsconfig(config);
+	const { manifest_data } = all(config);
 
 	const options = {
 		cwd,
@@ -611,10 +1243,7 @@ async function build(config) {
 		// used relative paths, I _think_ this could get fixed. Issue here:
 		// https://github.com/vitejs/vite/issues/2009
 		assets_base: `${config.kit.paths.assets || config.kit.paths.base}/${config.kit.appDir}/`,
-		manifest_data: create_manifest_data({
-			config,
-			cwd
-		}),
+		manifest_data,
 		output_dir,
 		client_entry_file: path__default.relative(cwd, `${get_runtime_path(config)}/client/start.js`),
 		service_worker_entry_file: resolve_entry(config.kit.files.serviceWorker),
@@ -624,30 +1253,55 @@ async function build(config) {
 	const client = await build_client(options);
 	const server = await build_server(options, client);
 
-	if (options.service_worker_entry_file) {
-		if (config.kit.paths.assets) {
-			throw new Error('Cannot use service worker alongside config.kit.paths.assets');
-		}
-
-		await build_service_worker(options, client.vite_manifest);
-	}
-
+	/** @type {import('types').BuildData} */
 	const build_data = {
 		app_dir: config.kit.appDir,
 		manifest_data: options.manifest_data,
 		service_worker: options.service_worker_entry_file ? 'service-worker.js' : null, // TODO make file configurable?
 		client,
-		server,
-		static: options.manifest_data.assets.map((asset) => posixify(asset.file)),
-		entries: options.manifest_data.routes
-			.map((route) => (route.type === 'page' ? route.path : ''))
-			.filter(Boolean)
+		server
 	};
 
-	const manifest = `export const manifest = ${generate_manifest(build_data, '.')};\n`;
+	const manifest = `export const manifest = ${generate_manifest({
+		build_data,
+		relative_path: '.',
+		routes: options.manifest_data.routes
+	})};\n`;
 	fs__default.writeFileSync(`${output_dir}/server/manifest.js`, manifest);
 
-	return build_data;
+	const static_files = options.manifest_data.assets.map((asset) => posixify(asset.file));
+
+	const files = new Set([
+		...static_files,
+		...client.chunks.map((chunk) => `${config.kit.appDir}/${chunk.fileName}`),
+		...client.assets.map((chunk) => `${config.kit.appDir}/${chunk.fileName}`)
+	]);
+
+	// TODO is this right?
+	static_files.forEach((file) => {
+		if (file.endsWith('/index.html')) {
+			files.add(file.slice(0, -11));
+		}
+	});
+
+	const prerendered = await prerender({
+		config,
+		entries: options.manifest_data.routes
+			.map((route) => (route.type === 'page' ? route.path : ''))
+			.filter(Boolean),
+		files,
+		log
+	});
+
+	if (options.service_worker_entry_file) {
+		if (config.kit.paths.assets) {
+			throw new Error('Cannot use service worker alongside config.kit.paths.assets');
+		}
+
+		await build_service_worker(options, prerendered, client.vite_manifest);
+	}
+
+	return { build_data, prerendered };
 }
 
 export { build };