wirejs-scripts 3.0.176 → 3.0.178

package/bin.js

@@ -2,29 +2,20 @@
 
 import process from 'process';
 import { execSync, spawn } from 'child_process';
-import http from 'http';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
-import webpack from 'webpack';
-import webpackConfigure from './configs/webpack.config.js';
 import { rimraf } from 'rimraf';
 import esbuild from 'esbuild';
-import { contentType } from 'mime-types';
 
-import { JSDOM } from 'jsdom';
-import { useJSDOM } from 'wirejs-dom/v2';
 import {
-	requiresContext,
-	Context,
-	CookieJar,
 	CronJob,
-	Endpoint,
 	SystemAttribute,
 } from 'wirejs-resources';
 import { prebuildApi } from 'wirejs-resources/internal';
+import { createServer as wirejsCreateServer } from 'wirejs-hosting';
 import nodeCron from 'node-cron';
 
 import * as DefaultGateway from 'default-gateway';
@@ -33,7 +24,6 @@ import * as NatPmp from 'nat-pmp';
 const CWD = process.cwd();
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const getWebpackConfig = () => webpackConfigure(process.env, process.argv);
 const [_nodeBinPath, _scriptPath, action, ...actionArgs] = process.argv;
 const [subAction] = actionArgs;
 const processes = [];
@@ -243,530 +233,286 @@ async function startForwardingWSLPort(wslPort = httpPort, publicPort = httpPort)
 	}
 }
 
-/**
- * 
- * @param {http.IncomingMessage} req 
- * @returns 
- */
-async function createContext(req) {
-	const { url, headers, method } = req;
-	const body = method.toLowerCase() === 'post'
-		? (await postData(req))
-		: undefined;
-	const origin = headers.origin || `http://${headers.host}`;
-	const location = new URL(`${origin}${url}`);
-	const cookies = new CookieJar(headers.cookie);
-	return new Context({
-		cookies,
-		location,
-		httpMethod: method,
-		requestHeaders: headers,
-		requestBody: body,
-		runtimeAttributes: [
-			new SystemAttribute('wirejs', 'deployment-type', {
-				description: 'Deployment under which your system is running.',
-				value: 'dev'
-			}),
-			new SystemAttribute('wirejs', 'http-origin-local', {
-				description: 'HTTP origin (base address) to use for local development.',
-				value: `http://localhost:${httpPort}`,
-			}),
-			new SystemAttribute('wirejs', 'http-origin-network', {
-				description: 'HTTP origin (base address) for machines on your network to use.',
-				value: `http://${networkIp}:${httpPort}`,
-			}),
-			new SystemAttribute('wirejs', 'http-origin-public', {
-				description: 'HTTP origin (base address) for machines outside your network to use. Only populated for `npm run start:public`, and only accessible in environments that support NAT-PMP.',
-				value: publicIp ? `http://${publicIp}:${httpPort}` : null,
-			}),
-		]
-	});
-}
-
-/**
- * 
- * @param {object} api
- * @param {{method: string, args: any[]}} call
- * @param {Context} context
- * @returns {Promise<any>}
- */
-async function callApiMethod(api, call, context) {
-	try {
-		const [scope, ...rest] = call.method;
-		logger.info('api method parsed', { scope, rest });
-		if (rest.length === 0) {
-			logger.info('api method resolved. invoking...', requiresContext(api[scope]));
-			if (requiresContext(api[scope])) {
-				return {
-					data: await api[scope](context, ...call.args.slice(1))
-				};
-			} else {
-				return {
-					data: await api[scope](...call.args)
-				};
-			}
-		} else {
-			logger.info('nested scope found');
-			return callApiMethod(api[scope], {
-				...call,
-				method: rest,
-			}, context);
-		}
-	} catch (error) {
-		console.log(error);
-		return { error: error.message };
-	}
-}
-
-/**
- * 
- * @param {Context} context
- * @param {http.ServerResponse} res 
- * @returns 
- */
-async function handleApiResponse(context, res) {
-	const url = context.location.pathname;
-
-	if (url === '/api') {
-		const body = context.requestBody;
-		const calls = JSON.parse(body);
-		logger.info('handling API request', body);
-
-		const apiPath = path.join(CWD, 'api', 'dist', 'index.js');
-		const api = await import(`${apiPath}?cache-id=${new Date().getTime()}`);
-
-		const responses = [];
-		for (const call of calls) {
-			logger.info('handling API call', call);
-			responses.push(await callApiMethod(api, call, context));
-		}
-
-		logger.info('setting cookies', context.cookies.getSetCookies());
-		for (const cookie of context.cookies.getSetCookies()) {
-			const cookieOptions = [];
-			if (cookie.maxAge) cookieOptions.push(`Max-Age=${cookie.maxAge}`);
-			if (cookie.httpOnly) cookieOptions.push('HttpOnly');
-			if (cookie.secure) cookieOptions.push('Secure');
-			if (cookie.path) cookieOptions.push(`Path=${cookie.path}`);
-
-			logger.info('setting cookie', cookie.name, cookie.value, cookieOptions);
-			res.appendHeader(
-				'Set-Cookie',
-				`${cookie.name}=${cookie.value}; ${cookieOptions.join('; ')}`
-			);
-		}
-
-		res.setHeader('Content-Type', 'application/json; charset=utf-8');
-		// internal API isn't allowed to set individual response headers, codes, etc.
-		// because they may be batched.
-		res.end(JSON.stringify(
-			responses
-		));
-	} else {
-		logger.error('Bad endpoint given', { url });
-
-		res.statusCode = 404;
-		res.end("404 - Endpoint not found");
-	}
-}
+async function compile(watch = false) {
+	const srcDir = path.join(CWD, 'src');
+	const ssrDir = path.join(srcDir, 'ssr');
+	const ssgDir = path.join(srcDir, 'ssg');
+	const staticDir = path.join(CWD, 'static');
+	const distDir = path.join(CWD, 'dist');
+	const ssrOutDir = path.join(distDir, 'ssr');
 
-/**
- * 
- * @param {Context} context
- * @param {http.ServerResponse} res 
- * @returns 
- */
-async function tryEndpointPath(context, res) {
 	/**
-	 * @type Endpoint
+	 * Copy all files from src to dest recursively.
 	 */
-	let matchingEndpoint = undefined;
-
-	try {
-		const apiPath = path.join(CWD, 'api', 'dist', 'index.js');
-		await import(`${apiPath}?cache-id=${new Date().getTime()}`);
-		const allHandlers = [...Endpoint.list()];
-		const matchingHandlers = allHandlers
-			.filter(e => globMatch(e.path, context.location.pathname));
-		matchingEndpoint = matchingHandlers.sort(byLength).pop();
-	} catch (error) {
-		return;
-	}
-
-	if (!matchingEndpoint) return;
-
-	const response = await matchingEndpoint.handle(context)
-	setResponseDetailsFromContext(context, res);
-	res.end(response);
-	return true;
-}
-
-/**
- * 
- * @param {Context} context 
- * @returns 
- */
-function fullPathFrom(context) {
-	const relativePath = context.location.pathname === '/'
-		? 'index.html'
-		: context.location.pathname;
-	return path.join(CWD, 'dist', relativePath);
-}
-
-
-/**
- * 
- * @param {Context} context
- * @param {http.ServerResponse} res 
- * @returns 
- */
-async function tryStaticPath(context, res) {
-	const fullPath = fullPathFrom(context);
-
-	logger.info('checking static', fullPath);
-	if (!fs.existsSync(fullPath)) return false;
-	logger.info('static found');
-
-	res.setHeader('Content-Type', contentType(path.extname(fullPath)));
-
-	try {
-		res.end(fs.readFileSync(fullPath));
-	} catch {
-		res.statusCode = 404;
-		res.end("404 - File not found (b)");
+	async function copyStatic() {
+		if (!fs.existsSync(staticDir)) return;
+		await fs.promises.cp(staticDir, distDir, { recursive: true });
 	}
 
-	return true;
-}
-
-/**
- * Compare two strings by length for sorting in order of increasing length.
- * 
- * @param {string} a 
- * @param {string} b 
- * @returns 
- */
-function byLength(a, b) {
-	return a.length - b.length;
-}
-
-/**
- * @param {string} pattern - string pattern, where `*` matches anything
- * @param {string} text 
- * @returns 
- */
-function globMatch(pattern, text) {
-	const parts = pattern.split('%');
-	const regex = new RegExp(parts.join('.+'));
-	return regex.test(text);
-}
-
-function toJSPath(path) {
-	if (path.endsWith('/')) {
-		return path + 'index.js';
-	} else if (!path.endsWith('.js')) {
-		return path + '.js';
-	} else {
-		return path;
-	}
-}
-
-/**
- * 
- * @param {Context} context 
- * @param {string} [forceExt]
- */
-function routeSSR(context, forceExt) {
-	const SSR_ROOT = path.join(CWD, 'dist', 'ssr');
-
-	const asJSPath = forceExt
-		? toJSPath(context.location.pathname)
-		: context.location.pathname;
-
-	try {
-		const allHandlers = fs.readdirSync(SSR_ROOT, { recursive: true })
-			.filter(p => p.endsWith('.js'))
-			.map(p => `/${p}`)
-			;
-		const matchingHandlers = allHandlers.filter(h => globMatch(h, asJSPath));
-		const match = matchingHandlers.sort(byLength).pop();
-
-		if (match) {
-			return path.join(SSR_ROOT, match);
+	/**
+	 * Find all .ts files recursively in a directory.
+	 */
+	function findTs(dir) {
+		try {
+			return fs.readdirSync(dir, { recursive: true, withFileTypes: true })
+				.filter(e => e.isFile() && e.name.endsWith('.ts'))
+				.map(e => path.join(e.parentPath ?? e.path, e.name));
+		} catch {
+			return [];
 		}
-	} catch (error) {
-		return;
 	}
-}
 
-/**
- * @param {Context} context
- * @param {http.ServerResponse} res 
- * @returns 
- */
-async function trySSRScriptPath(context, res) {
-	const srcPath = routeSSR(context);
-	if (!srcPath) return false;
-
-	logger.info('SSR handler associated script found', srcPath);
-
-	res.setHeader('Content-Type', 'text/javascript');
-
-	try {
-		res.end(fs.readFileSync(srcPath));
-	} catch {
-		res.statusCode = 404;
-		res.end("404 - File not found (c)");
-	}
-
-	return true;
-}
-
-/**
- * 
- * @param {Context} context 
- * @param {http.ServerResponse} res 
- */
-function setResponseDetailsFromContext(context, res) {
-	for (const [k, v] of Object.entries(context.responseHeaders)) {
-		res.setHeader(k, v);
-	}
-	for (const cookie of context.cookies.getSetCookies()) {
-		const cookieOptions = [];
-		if (cookie.maxAge) cookieOptions.push(`Max-Age=${cookie.maxAge}`);
-		if (cookie.httpOnly) cookieOptions.push('HttpOnly');
-		if (cookie.secure) cookieOptions.push('Secure');
-		if (cookie.path) cookieOptions.push(`Path=${cookie.path}`);
-		const cookieStr = cookieOptions.length > 0
-			? `${cookie.name}=${cookie.value}; ${cookieOptions.join('; ')}`
-			: `${cookie.name}=${cookie.value}`;
-		res.appendHeader('Set-Cookie', cookieStr);
-	}
-	if (context.locationIsDirty) {
-		res.setHeader('Location', context.location.href);
-	}
-	if (context.responseCode) res.statusCode = context.responseCode;
-}
+	/**
+	 * Build SSG files and write the generated HTML to dist/.
+	 * Also produces browser-compatible IIFE bundles at dist/*.js so that
+	 * client-side hydration scripts referenced from the generated HTML are served.
+	 */
+	async function buildSsg() {
+		const ssgFiles = findTs(ssgDir);
+		if (ssgFiles.length === 0) return;
 
-/**
- * 
- * @param {Context} context
- * @param {http.ServerResponse} res
- * @returns 
- */
-async function trySSRPath(context, res) {
-	const asJSPath = context.location.pathname.replace(/\.(\w+)$/, '') + '.js';
-	const srcPath = routeSSR(context, 'js');
-	if (!srcPath) return false;
+		const preSsgDir = path.join(CWD, 'pre-dist', 'ssg');
 
-	logger.info('SSR handler found', srcPath);
+		// 1. Build server-side bundles (ESM, for ssg.js import()) into pre-dist/ssg/
+		await esbuild.build({
+			entryPoints: ssgFiles,
+			outdir: preSsgDir,
+			outbase: ssgDir,
+			bundle: true,
+			platform: 'node',
+			format: 'esm',
+			conditions: ['wirejs:client'],
+		});
 
-	try {
-		useJSDOM(JSDOM);
-		const self = {};
-		const moduleData = await fs.promises.readFile(srcPath);
-		eval(`${moduleData}`);
-		const module = self.exports;
-		if (typeof module.generate === 'function') {
-			const doc = await module.generate(context);
-			if (typeof doc.outerHTML === 'undefined') {
-				res.setHeader('Content-Type', contentType(
-					context.location.pathname.split('.').pop()
-				));
-				setResponseDetailsFromContext(context, res);
-				res.end(doc);
-			} else {
-				const doctype = doc.parentNode.doctype?.name || '';
-
-				let hydrationsFound = 0;
-				while (globalThis.pendingDehydrations?.length > 0) {
-					globalThis.pendingDehydrations.shift()(doc);
-					hydrationsFound++;
-				}
+		// 2. Build browser-side bundles (IIFE, for client hydration) into dist/
+		//    These are referenced by <script src="..."> tags injected by ssg.js.
+		await esbuild.build({
+			entryPoints: ssgFiles,
+			outdir: distDir,
+			outbase: ssgDir,
+			bundle: true,
+			platform: 'browser',
+			format: 'iife',
+			conditions: ['wirejs:client'],
+			sourcemap: true,
+		});
 
-				if (hydrationsFound) {
-					const script = doc.parentNode.createElement('script');
-					script.src = asJSPath;
-					doc.parentNode.body.appendChild(script);
-				}
+		// 3. Run ssg.js on each server-side bundle to produce HTML.
+		//    Pass CWD/pre-dist as SRC_DIR so ssg.js strips the correct prefix
+		//    when building the hydration <script src="..."> path (e.g. /index.js).
+		const preDist = path.join(CWD, 'pre-dist');
+		const compiledSsgFiles = fs.readdirSync(preSsgDir, { recursive: true, withFileTypes: true })
+			.filter(e => e.isFile() && e.name.endsWith('.js'))
+			.map(e => path.join(e.parentPath ?? e.path, e.name));
 
-				res.setHeader('Content-Type', 'text/html; charset=utf-8');
-				setResponseDetailsFromContext(context, res);
-				res.end([
-					doctype ? `<!doctype ${doctype}>\n` : '',
-					doc.outerHTML
-				].join(''));
+		for (const ssgFile of compiledSsgFiles) {
+			try {
+				const html = execSync(
+					`node ${path.join(__dirname, 'ssg.js')} ${preDist} ${ssgFile}`,
+					{ stdio: ['pipe', 'pipe', 'pipe'] }
+				).toString();
+				const relative = path.relative(preSsgDir, ssgFile).replace(/\.js$/, '.html');
+				const htmlOut = path.join(distDir, relative);
+				await fs.promises.mkdir(path.dirname(htmlOut), { recursive: true });
+				await fs.promises.writeFile(htmlOut, html);
+			} catch (err) {
+				logger.error(`Could not generate SSG page ${ssgFile}`, err);
 			}
-			return true;
-		} else {
-			logger.info('SSR module missing generate function');
-			return false;
 		}
-	} catch (error) {
-		logger.error('ssr error', error);
-		res.statusCode = 404;
-		res.end("404 - File not found (a)");
 	}
 
-	return true;
-}
+	if (watch) {
+		const apiDir = path.join(CWD, 'api');
 
-/**
- * 
- * @param {http.IncomingMessage} req 
- * @param {http.ServerResponse} res 
- * @param {any} compiler 
- * @returns 
- */
-async function handleRequest(req, res, compiler) {
-	logger.info('received', JSON.stringify({ url: req.url }, null, 2));
-	const context = await createContext(req);
-
-	if (req.url.startsWith('/api')) {
-		return handleApiResponse(context, res, compiler);
-	}
-
-	if (await tryStaticPath(context, res, fs)) return;
-	if (await trySSRScriptPath(context, res, fs)) return;
-	if (await trySSRPath(context, res, fs)) return;
-	if (await tryEndpointPath(context, res, fs)) return;
-
-	// if we've made it this far, we don't have what you're looking for
-	res.statusCode = '404';
-	res.end('404 - Not found');
-}
-
-/**
- * 
- * @param {http.IncomingMessage} request 
- * @returns 
- */
-async function postData(request) {
-	return new Promise((resolve, reject) => {
-		const buffer = [];
-		const timeout = setTimeout(() => {
-			reject("Post data not received.");
-		}, 5000);
-		request.on('data', data => buffer.push(data));
-		request.on('end', () => {
-			if (!timeout) return;
-			clearTimeout(timeout);
-			resolve(buffer.join(''));
+		// API watch (unchanged)
+		const prebuildApiCtx = await esbuild.context({
+			entryPoints: [path.join(CWD, 'api', '**', '*.ts')],
+			outdir: path.join(apiDir, 'dist'),
+			platform: 'node',
+			bundle: true,
+			packages: 'external',
+			format: 'esm',
+			plugins: [{
+				name: 'post-build-rebuild-api-client',
+				setup(build) {
+					build.onEnd(async () => {
+						await prebuildApi(apiDir);
+						await refreshCronSchedules(apiDir);
+					});
+				}
+			}]
 		});
-	});
-};
-
-async function compile(watch = false) {
-	const stats = await new Promise(async (resolve, reject) => {
-		let compiler;
-		if (watch) {
-			const apiDir = path.join(CWD, 'api');
-			const prebuildApiWatch = await esbuild.context({
-				entryPoints: [path.join(CWD, 'api', '**', '*.ts')],
-				outdir: path.join(apiDir, 'dist'),
-				platform: 'node',
+		await prebuildApiCtx.rebuild();
+		prebuildApiCtx.watch();
+
+		// Client index bundle (esbuild, replaces webpack)
+		const indexEntry = path.join(srcDir, 'index.ts');
+		if (fs.existsSync(indexEntry)) {
+			const clientCtx = await esbuild.context({
+				entryPoints: [indexEntry],
+				outdir: distDir,
 				bundle: true,
-				packages: 'external',
+				platform: 'browser',
 				format: 'esm',
+				conditions: ['wirejs:client'],
+				sourcemap: true,
+				// preserveSymlinks: true, // needed?
 				plugins: [{
-					name: 'post-build-rebuild-api-client',
+					name: 'client-build-done',
 					setup(build) {
-						build.onEnd(async () => {
-						await prebuildApi(apiDir);
-						await refreshCronSchedules(apiDir);
-					})
+						build.onEnd(() => {
+							console.log();
+							console.log('Compiled.\n');
+							console.log(`Local\nhttp://localhost:${httpPort}/\n`);
+							networkIp = getLocalIPv4();
+							if (networkIp) {
+								console.log(`Network\nhttp://${networkIp}:${httpPort}/\n`);
+							}
+							if (publicIp) {
+								console.log(`Public\nhttp://${publicIp}:${httpPort}/\n`);
+							}
+						});
 					}
 				}]
 			});
-			await prebuildApiWatch.rebuild();
-			prebuildApiWatch.watch();
+			await clientCtx.rebuild();
+			clientCtx.watch();
+		}
 
-			const prebuild = await esbuild.context({
-				entryPoints: [`${CWD}/src/**/*.ts`],
-				outdir: `${CWD}/pre-dist`,
-				bundle: false,
+		// SSR watch
+		const ssrFiles = findTs(ssrDir);
+		if (ssrFiles.length > 0) {
+			const ssrCtx = await esbuild.context({
+				entryPoints: ssrFiles,
+				outdir: ssrOutDir,
+				outbase: ssrDir,
+				entryNames: '[dir]/[name]',
+				bundle: true,
+				platform: 'browser',
 				format: 'esm',
 				conditions: ['wirejs:client'],
+				sourcemap: true,
 			});
-			await prebuild.rebuild();
-			prebuild.watch();
-
-			if (actionArgs.includes('--public') || actionArgs.includes('-p')) {
-				console.log("Attempting to open external port.");
-				const gatewayIp = await getGateway();
-				const natPmpClient = NatPmp.connect(gatewayIp);
-				natPmpClient.externalIp((err, info) => {
-					if (err) throw err;
-					const ip = info.ip.join('.');
-					console.log(`Found external address: ${ip} ... trying to connect.`);
-					for (const port of [httpPort, wsPort]) {
-						natPmpClient.portMapping({
-							private: port,
-							public: port,
-							ttl: 3600,
-						}, (err, info) => {
-							if (err) throw err;
-							console.log(`Listening externally at ${ip}:${port}`);
-							publicIp = ip
-						});
-					};
-				});
-				if (isWSL()) startForwardingWSLPort();
-			}
+			await ssrCtx.rebuild();
+			ssrCtx.watch();
+		}
 
-			webpack({
-				...getWebpackConfig(),
-				mode: 'development',
-				watch: true
-			}, () => {
-				console.log();
-				console.log('Compiled.\n');
-				console.log(`Local\nhttp://localhost:${httpPort}/\n`);
-				networkIp = getLocalIPv4();
-				if (networkIp) {
-					console.log(`Network\nhttp://${networkIp}:${httpPort}/\n`)
-				}
-				if (publicIp) {
-					console.log(`Public\nhttp://${publicIp}:${httpPort}/\n`);
+		// Static files
+		await copyStatic();
+		// SSG (run once; changes require a restart)
+		await buildSsg();
+
+		// NAT-PMP / --public flag
+		if (actionArgs.includes('--public') || actionArgs.includes('-p')) {
+			console.log("Attempting to open external port.");
+			const gatewayIp = await getGateway();
+			const natPmpClient = NatPmp.connect(gatewayIp);
+			natPmpClient.externalIp((err, info) => {
+				if (err) throw err;
+				const ip = info.ip.join('.');
+				console.log(`Found external address: ${ip} ... trying to connect.`);
+				for (const port of [httpPort, wsPort]) {
+					natPmpClient.portMapping({
+						private: port,
+						public: port,
+						ttl: 3600,
+					}, (err, info) => {
+						if (err) throw err;
+						console.log(`Listening externally at ${ip}:${port}`);
+						publicIp = ip;
+					});
 				}
-			}).run(() => { });
-
-			logger.log('Starting server...');
-			const server = http.createServer(handleRequest);
-			server.listen(httpPort).on('listening', () => {
-				console.log(`Started listening on port ${httpPort}`);
 			});
-		} else {
-			logger.log('prebundling JS');
+			if (isWSL()) startForwardingWSLPort();
+		}
+
+		logger.log('Starting server...');
+		const server = wirejsCreateServer({
+			apiDir: path.join(CWD, 'api'),
+			distDir,
+			port: httpPort,
+			attributes: () => [
+				new SystemAttribute('wirejs', 'deployment-type', {
+					description: 'Deployment under which your system is running.',
+					value: 'dev',
+				}),
+				new SystemAttribute('wirejs', 'http-origin-local', {
+					description: 'HTTP origin (base address) to use for local development.',
+					value: `http://localhost:${httpPort}`,
+				}),
+				new SystemAttribute('wirejs', 'http-origin-network', {
+					description: 'HTTP origin (base address) for machines on your network to use.',
+					value: networkIp ? `http://${networkIp}:${httpPort}` : null,
+				}),
+				new SystemAttribute('wirejs', 'http-origin-public', {
+					description: 'HTTP origin (base address) for machines outside your network to use. Only populated for `npm run start:public`.',
+					value: publicIp ? `http://${publicIp}:${httpPort}` : null,
+				}),
+			],
+		});
+		server.listen(httpPort).on('listening', () => {
+			console.log(`Started listening on port ${httpPort}`);
+		});
+	} else {
+		// Non-watch build
+		console.log('non-watch build');
+
+		// Client index bundle
+		console.log('building index.ts');
+		const indexEntry = path.join(srcDir, 'index.ts');
+		if (fs.existsSync(indexEntry)) {
 			await esbuild.build({
-				entryPoints: [`${CWD}/src/**/*.ts`],
-				outdir: `${CWD}/pre-dist`,
-				bundle: false,
+				entryPoints: [indexEntry],
+				outdir: distDir,
+				bundle: true,
+				platform: 'node',
 				format: 'esm',
 				conditions: ['wirejs:client'],
+				sourcemap: true,
+				// preserveSymlinks: true,
 			});
-			logger.log('starting webpack compiler');
-			compiler = webpack(getWebpackConfig());
-			compiler.run((err, res) => {
-				logger.log('invoking webpack compiler');
-				if (err) {
-					logger.error('webpack compiler failed');
-					logger.error(err);
-					reject(err);
-				} else {
-					logger.info('webpack compiler succeeded');
-					resolve(res);
-				}
+		}
+
+		// SSR bundles
+		console.log('building ssr');
+		const ssrFiles = findTs(ssrDir);
+		if (ssrFiles.length > 0) {
+			// server-side bundle
+			await esbuild.build({
+				entryPoints: ssrFiles,
+				outdir: ssrOutDir,
+				outbase: ssrDir,
+				entryNames: '[dir]/[name]',
+				bundle: true,
+				platform: 'node',
+				format: 'cjs',
+				conditions: ['wirejs:client'],
+				sourcemap: true,
+				// preserveSymlinks: true,
+			});
+			// client bundle
+			await esbuild.build({
+				entryPoints: ssrFiles,
+				outdir: ssrOutDir,
+				outbase: ssrDir,
+				entryNames: '[dir]/[name].client',
+				bundle: true,
+				platform: 'browser',
+				format: 'iife',
+				conditions: ['wirejs:client'],
+				sourcemap: true,
+				// preserveSymlinks: true,
 			});
 		}
-	});
 
-	if (stats?.compilation?.errors?.length > 0) {
-		logger.log('compilation errors', stats.compilation.errors);
-		throw new Error('Build failed.');
-	}
+		// Static files
+		console.log('copying static files');
+		await copyStatic();
 
-	return stats;
+		// SSG
+		console.log('copying ssg files');
+		await buildSsg();
+	}
 }
 
 const engine = {
@@ -835,10 +581,10 @@ const engine = {
 		await rimraf('pre-dist');
 		logger.log('cleared old pre-dist folder');
 
-		await fs.promises.mkdir('dist');
+		await fs.promises.mkdir('dist', { recursive: true });
 		logger.log('recreated dist folder');
 
-		await fs.promises.mkdir('pre-dist');
+		await fs.promises.mkdir('pre-dist', { recursive: true });
 		logger.log('recreated pre-dist folder');
 
 		await compile(watch);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wirejs-scripts",
-	"version": "3.0.176",
+	"version": "3.0.178",
 	"description": "Basic build and start commands for wirejs apps",
 	"type": "module",
 	"bin": {
@@ -22,22 +22,13 @@
 	},
 	"homepage": "https://github.com/svidgen/create-wirejs-app#readme",
 	"dependencies": {
-		"copy-webpack-plugin": "^10.2.4",
-		"css-loader": "^5.2.0",
 		"default-gateway": "^7.2.2",
 		"esbuild": "^0.24.2",
-		"file-loader": "^6.2.0",
-		"glob": "^7.2.0",
-		"jsdom": "^25.0.1",
-		"marked": "^2.0.1",
-		"mime-types": "^2.1.35",
 		"nat-pmp": "^1.0.0",
 		"node-cron": "^4.2.1",
-		"raw-loader": "^4.0.2",
 		"rimraf": "^6.0.1",
-		"style-loader": "^2.0.0",
-		"webpack": "^5.97.1",
 		"wirejs-dom": "^1.0.44",
-		"wirejs-resources": "^0.1.178"
+		"wirejs-hosting": "^0.1.180",
+		"wirejs-resources": "^0.1.180"
 	}
 }