gofront 1.0.1 → 1.1.0

package/README.md

@@ -387,13 +387,15 @@ gofront <dir>                    compile all *.go in directory → stdout
 gofront <input> -o out.js        write output to file (prints elapsed compile time e.g. "15ms")
 gofront <input> --check                    type-check only
 gofront <input> --watch                    watch for changes and recompile
-gofront <input> -o out.js --serve          watch + serve with live reload (default port 3000)
+gofront <input> -o out.js --serve          watch + serve with live reload & SPA fallback (default port 3000)
 gofront <input> -o out.js --serve --port 8080  use a custom port
+gofront <input> -o out.js --copy-assets    compile and synchronize static assets from package.json assetCopy
 gofront <input> --source-map               append inline source map (single file or directory; multi-file packages emit per-file mappings)
 gofront <input> --minify                   minify output (built-in minifier)
 gofront <input> --minify --mangle          minify and rename local identifiers
 gofront <file.go> --ast                    dump AST (debug)
 gofront <file.go> --tokens                 dump tokens (debug)
+gofront prep [dir]                         copy static assets and bundle vendor dependencies
 gofront init [dir]                         scaffold a new project
 gofront --version / -v                     print version
 gofront --help / -h                        print this help
@@ -401,6 +403,37 @@ gofront --help / -h                        print this help
 
 ---
 
+## Static assets & vendor bundling
+
+GoFront includes native tooling to manage static assets and package external npm dependencies for the browser without requiring external wrappers or complex build tools.
+
+### Asset copying (`assetCopy`)
+
+Specify static assets (fonts, stylesheets, images) in `package.json` (or `gofront.json`):
+
+```json
+{
+  "assetCopy": [
+    { "source": "node_modules/@fontsource/raleway/files", "dest": "app/fonts" },
+    { "source": "node_modules/prismjs/themes", "dest": "app/css/prism-themes" }
+  ]
+}
+```
+
+Run `gofront prep` to copy them, or pass `--copy-assets` to automatically synchronize assets on build.
+
+### Vendor bundling (`gofront prep`)
+
+Package external npm dependencies for the browser:
+
+```sh
+gofront prep
+```
+
+GoFront inspects your `dependencies`, dynamically uses `rolldown` or `esbuild` from your `devDependencies`, and bundles them into an ES module (defaulting to `app/vendor.js` or `vendor.js`).
+
+---
+
 ## Multi-file packages
 
 All `.go` files in a directory share the same namespace and are compiled as one unit.
@@ -625,7 +658,7 @@ you know exactly what to expect.
 
 ## Roadmap
 
-See [`docs/ROADMAP.md`](docs/ROADMAP.md) for the full roadmap and release history.
+See [`docs/roadmap.md`](docs/roadmap.md) for the full roadmap and release history.
 Design documents for planned features are organised by release under `docs/v*/`
 (e.g. [`docs/v0.0.8/`](docs/v0.0.8/), [`docs/v0.0.9/`](docs/v0.0.9/)).
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gofront",
-	"version": "1.0.1",
+	"version": "1.1.0",
 	"author": "Luuk van Venrooij",
 	"license": "MIT",
 	"repository": {
@@ -42,14 +42,14 @@
 		"test:e2e": "npm run build:all && playwright test",
 		"format": "biome format --write .",
 		"check": "biome check . && sentrux check && sentrux gate && node src/index.js example/simple/src --check && node src/index.js example/reactive/src --check && node src/index.js example/gom/src --check && node src/index.js example/templ/src --check",
-		"prepare": "husky"
+		"prepare": "lefthook install"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.4.12",
-		"@playwright/test": "^1.59.1",
-		"c8": "^11.0.0",
-		"husky": "^9.1.7",
-		"jsdom": "^29.0.2",
+		"@biomejs/biome": "^2.5.14",
+		"@playwright/test": "^1.63.0",
+		"c8": "^12.0.0",
+		"jsdom": "^30.1.0",
+		"lefthook": "^2.1.14",
 		"serve": "^14.2.6"
 	}
 }

package/src/asset-manager.js

@@ -0,0 +1,125 @@
+// Native static asset manager for GoFront projects.
+// Zero-dependency file and directory copier using node:fs.
+
+import {
+	copyFileSync,
+	cpSync,
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	statSync,
+} from "node:fs";
+import {
+	basename,
+	dirname,
+	isAbsolute,
+	join,
+	relative,
+	resolve,
+} from "node:path";
+
+export function loadAssetConfig(projectDir) {
+	const gofrontJsonPath = join(projectDir, "gofront.json");
+	if (existsSync(gofrontJsonPath)) {
+		try {
+			const parsed = JSON.parse(readFileSync(gofrontJsonPath, "utf8"));
+			if (Array.isArray(parsed.assetCopy)) return parsed.assetCopy;
+		} catch {}
+	}
+
+	const pkgJsonPath = join(projectDir, "package.json");
+	if (existsSync(pkgJsonPath)) {
+		try {
+			const parsed = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+			if (Array.isArray(parsed.assetCopy)) return parsed.assetCopy;
+		} catch {}
+	}
+
+	return [];
+}
+
+function copyFileAsset(srcPath, destPath, dest) {
+	let targetFile = destPath;
+	if (
+		dest.endsWith("/") ||
+		(existsSync(destPath) && statSync(destPath).isDirectory())
+	) {
+		targetFile = join(destPath, basename(srcPath));
+	}
+	mkdirSync(dirname(targetFile), { recursive: true });
+	copyFileSync(srcPath, targetFile);
+	return targetFile;
+}
+
+function copyAssetEntry(entry, projectRoot) {
+	if (!entry || typeof entry !== "object") return null;
+	const { source, dest } = entry;
+	if (!source || !dest) return null;
+
+	const destPath = resolve(projectRoot, dest);
+	const relDest = relative(projectRoot, destPath);
+	if (relDest.startsWith("..") || isAbsolute(relDest)) {
+		throw new Error(
+			`gofront: asset destination '${dest}' is outside project directory`,
+		);
+	}
+
+	const srcPath = resolve(projectRoot, source);
+	if (!existsSync(srcPath)) {
+		console.warn(`gofront: asset source '${source}' not found — skipping`);
+		return {
+			status: "skipped",
+			item: { source, dest, status: "skipped", reason: "source not found" },
+		};
+	}
+
+	try {
+		const stat = statSync(srcPath);
+		if (stat.isDirectory()) {
+			mkdirSync(destPath, { recursive: true });
+			cpSync(srcPath, destPath, { recursive: true, force: true });
+			return {
+				status: "copied",
+				item: { source, dest, type: "directory", status: "copied" },
+			};
+		}
+		const targetFile = copyFileAsset(srcPath, destPath, dest);
+		return {
+			status: "copied",
+			item: { source, dest: targetFile, type: "file", status: "copied" },
+		};
+	} catch (err) {
+		console.warn(`gofront: failed to copy asset '${source}': ${err.message}`);
+		return {
+			status: "failed",
+			item: { source, dest, status: "failed", reason: err.message },
+		};
+	}
+}
+
+export function copyAssets(projectDir = ".", config = null) {
+	const projectRoot = resolve(projectDir);
+	let entries;
+
+	if (Array.isArray(config)) {
+		entries = config;
+	} else if (config && Array.isArray(config.assetCopy)) {
+		entries = config.assetCopy;
+	} else {
+		entries = loadAssetConfig(projectRoot);
+	}
+
+	const items = [];
+	let copied = 0;
+	let skipped = 0;
+
+	for (const entry of entries) {
+		const result = copyAssetEntry(entry, projectRoot);
+		if (!result) continue;
+		if (result.status === "copied") copied++;
+		else skipped++;
+		items.push(result.item);
+	}
+
+	return { copied, skipped, items };
+}

package/src/cli-core.js

@@ -3,8 +3,10 @@
 
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
+import { copyAssets } from "./asset-manager.js";
 import { compileDir, compileSingleFile } from "./compiler.js";
 import { minify } from "./minifier.js";
+import { bundleVendor } from "./vendor.js";
 
 export function runCompile(inputPath, isDir, options) {
 	const {
@@ -63,3 +65,10 @@ export function handleInit(targetDir) {
 
 	return { mainPath };
 }
+
+export async function handlePrep(targetDir, options = {}) {
+	const resolvedTarget = resolve(targetDir);
+	const assets = copyAssets(resolvedTarget, options.assetConfig);
+	const vendor = await bundleVendor(resolvedTarget, options.vendorConfig);
+	return { assets, vendor };
+}

package/src/dev-server.js

@@ -1,11 +1,11 @@
 // Minimal dev server for gofront --serve watch mode.
 // Serves static files and pushes a reload event via SSE after each build.
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { createServer } from "node:http";
-import { extname, join } from "node:path";
+import { extname, join, resolve } from "node:path";
 
-const MIME = {
+export const MIME = {
 	".html": "text/html; charset=utf-8",
 	".js": "application/javascript; charset=utf-8",
 	".css": "text/css; charset=utf-8",
@@ -22,42 +22,97 @@ const MIME = {
 // Injected at the bottom of compiled JS in serve mode.
 export const liveReloadClient = `(function(){var es=new EventSource('/_gofront/events');es.addEventListener('reload',function(){location.reload();});})();`;
 
-export function createDevServer(serveDir, port) {
-	const clients = new Set();
+export function handleDevRequest(req, res, serveDir, clients = new Set()) {
+	// SSE endpoint — browser connects here to receive reload events
+	if (req.url === "/_gofront/events") {
+		res.writeHead(200, {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive",
+		});
+		res.write(": connected\n\n");
+		clients.add(res);
+		req.on?.("close", () => clients.delete(res));
+		return;
+	}
 
-	const server = createServer((req, res) => {
-		// SSE endpoint — browser connects here to receive reload events
-		if (req.url === "/_gofront/events") {
-			res.writeHead(200, {
-				"Content-Type": "text/event-stream",
-				"Cache-Control": "no-cache",
-				Connection: "keep-alive",
-			});
-			res.write(": connected\n\n");
-			clients.add(res);
-			req.on("close", () => clients.delete(res));
-			return;
-		}
+	let urlPath = req.url.split("?")[0].split("#")[0];
+	try {
+		urlPath = decodeURIComponent(urlPath);
+	} catch {
+		// Ignore malformed URL encoding and use raw path
+	}
+
+	if (urlPath === "/" || urlPath === "") urlPath = "/index.html";
 
-		let urlPath = req.url.split("?")[0];
-		if (urlPath === "/" || urlPath === "") urlPath = "/index.html";
+	const resolvedServe = resolve(serveDir);
+	const filePath = resolve(serveDir, `.${urlPath}`);
+	if (!filePath.startsWith(resolvedServe)) {
+		res.writeHead(403, { "Content-Type": "text/plain" });
+		res.end("Forbidden");
+		return;
+	}
+
+	if (!existsSync(filePath)) {
+		// SPA fallback: clean paths with no file extension fall back to index.html
+		const ext = extname(urlPath);
+		if (!ext) {
+			const indexPath = join(serveDir, "index.html");
+			if (existsSync(indexPath)) {
+				try {
+					const data = readFileSync(indexPath);
+					res.writeHead(200, { "Content-Type": MIME[".html"] });
+					res.end(data);
+					return;
+				} catch {
+					res.writeHead(500, { "Content-Type": "text/plain" });
+					res.end("Server error");
+					return;
+				}
+			}
+		}
+		res.writeHead(404, { "Content-Type": "text/plain" });
+		res.end("Not found");
+		return;
+	}
 
-		const filePath = join(serveDir, urlPath);
-		if (!existsSync(filePath)) {
+	try {
+		const stat = statSync(filePath);
+		if (stat.isDirectory()) {
+			const dirIndex = join(filePath, "index.html");
+			if (existsSync(dirIndex)) {
+				const data = readFileSync(dirIndex);
+				res.writeHead(200, { "Content-Type": MIME[".html"] });
+				res.end(data);
+				return;
+			}
+			const rootIndex = join(serveDir, "index.html");
+			if (existsSync(rootIndex)) {
+				const data = readFileSync(rootIndex);
+				res.writeHead(200, { "Content-Type": MIME[".html"] });
+				res.end(data);
+				return;
+			}
 			res.writeHead(404, { "Content-Type": "text/plain" });
 			res.end("Not found");
 			return;
 		}
 
-		try {
-			const data = readFileSync(filePath);
-			const mime = MIME[extname(filePath)] ?? "application/octet-stream";
-			res.writeHead(200, { "Content-Type": mime });
-			res.end(data);
-		} catch {
-			res.writeHead(500, { "Content-Type": "text/plain" });
-			res.end("Server error");
-		}
+		const data = readFileSync(filePath);
+		const mime = MIME[extname(filePath)] ?? "application/octet-stream";
+		res.writeHead(200, { "Content-Type": mime });
+		res.end(data);
+	} catch {
+		res.writeHead(500, { "Content-Type": "text/plain" });
+		res.end("Server error");
+	}
+}
+
+export function createDevServer(serveDir, port = 3000) {
+	const clients = new Set();
+
+	const server = createServer((req, res) => {
+		handleDevRequest(req, res, serveDir, clients);
 	});
 
 	server.on("error", (err) => {
@@ -70,8 +125,12 @@ export function createDevServer(serveDir, port) {
 		}
 		process.exit(1);
 	});
+
 	server.listen(port, () => {
-		console.error(`gofront: dev server → http://localhost:${port}`);
+		const actualPort = server.address()?.port ?? port;
+		if (port !== 0) {
+			console.error(`gofront: dev server → http://localhost:${actualPort}`);
+		}
 	});
 
 	function notify() {
@@ -80,5 +139,9 @@ export function createDevServer(serveDir, port) {
 		}
 	}
 
-	return { notify };
+	return {
+		notify,
+		server,
+		close: () => new Promise((res) => server.close(res)),
+	};
 }

package/src/index.js

@@ -18,9 +18,10 @@ import { createRequire } from "node:module";
 const _require = createRequire(import.meta.url);
 const { version } = _require("../package.json");
 
-import { statSync, watch, writeFileSync } from "node:fs";
+import { mkdirSync, statSync, watch, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { handleInit, maybeMinify, runCompile } from "./cli-core.js";
+import { copyAssets } from "./asset-manager.js";
+import { handleInit, handlePrep, maybeMinify, runCompile } from "./cli-core.js";
 import { createDevServer, liveReloadClient } from "./dev-server.js";
 
 // ── Parse CLI args ───────────────────────────────────────────
@@ -44,11 +45,13 @@ Usage:
   gofront <input> --watch        Watch for changes and recompile
   gofront <input> -o out.js --serve          Watch + serve with live reload (default port 3000)
   gofront <input> -o out.js --serve --port 8080  Use a custom port
+  gofront <input> -o out.js --copy-assets    Compile and synchronize static assets
   gofront <input> --source-map   Append inline source map to output
   gofront <input> --minify       Minify output
   gofront <input> --minify --mangle  Minify and mangle identifiers
   gofront <file.go> --ast        Dump AST (debug)
   gofront <file.go> --tokens     Dump tokens (debug)
+  gofront prep [dir]             Copy static assets and bundle vendor dependencies
   gofront init [dir]             Scaffold a new GoFront project
   gofront --version              Print version
 `.trim(),
@@ -56,6 +59,30 @@ Usage:
 	process.exit(0);
 }
 
+// ── prep / vendor subcommand ──────────────────────────────────
+
+if (args[0] === "prep" || args[0] === "vendor") {
+	const targetArg = args[1] ?? ".";
+	const targetDir = resolve(targetArg);
+	try {
+		const { assets, vendor } = await handlePrep(targetDir);
+		if (assets.copied > 0 || assets.skipped > 0) {
+			console.error(
+				`gofront: copied ${assets.copied} assets (${assets.skipped} skipped)`,
+			);
+		}
+		if (vendor.bundled?.length > 0) {
+			console.error(
+				`gofront: bundled ${vendor.bundled.length} vendor dependencies → ${vendor.dest}`,
+			);
+		}
+	} catch (e) {
+		console.error(`gofront: ${e.message}`);
+		process.exit(1);
+	}
+	process.exit(0);
+}
+
 // ── init subcommand ──────────────────────────────────────────
 
 if (args[0] === "init") {
@@ -84,6 +111,7 @@ const dumpTokens = args.includes("--tokens");
 const sourceMap = args.includes("--source-map");
 const serveMode = args.includes("--serve");
 const watchMode = args.includes("--watch") || serveMode;
+const copyAssetsFlag = args.includes("--copy-assets");
 const minifyOutput = args.includes("--minify");
 const mangleOutput = args.includes("--mangle");
 const portFlag = args.indexOf("--port");
@@ -148,6 +176,7 @@ if (!watchMode) {
 
 	if (outputFile) {
 		try {
+			mkdirSync(dirname(resolve(outputFile)), { recursive: true });
 			writeFileSync(outputFile, `${js}\n`);
 			console.error(`gofront: wrote ${outputFile} (${elapsedMs}ms)`);
 		} catch (e) {
@@ -157,6 +186,19 @@ if (!watchMode) {
 	} else {
 		console.log(js);
 	}
+
+	if (copyAssetsFlag) {
+		try {
+			const projectDir = resolve(".");
+			const { copied, skipped } = copyAssets(projectDir);
+			if (copied > 0 || skipped > 0) {
+				console.error(`gofront: copied ${copied} assets (${skipped} skipped)`);
+			}
+		} catch (e) {
+			console.error(`gofront: asset copy failed: ${e.message}`);
+		}
+	}
+
 	process.exit(0);
 }
 
@@ -210,6 +252,15 @@ function buildOnce(changedFile = null) {
 				`[${timestamp()}] gofront: OK (${elapsedMs}ms${changeNote})`,
 			);
 		}
+
+		if (copyAssetsFlag) {
+			try {
+				copyAssets(resolve("."));
+			} catch (e) {
+				console.error(`gofront: asset copy failed: ${e.message}`);
+			}
+		}
+
 		devServer?.notify();
 	} catch (e) {
 		console.error(`[${timestamp()}] gofront: ERROR`);

package/src/vendor.js

@@ -0,0 +1,228 @@
+// Vendor dependency bundler for GoFront projects.
+// Dynamically loads a bundler (rolldown or esbuild) from consumer devDependencies.
+
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+export function getExportNames(pkgName) {
+	const base = pkgName.replace(/^@[^/]+\//, "");
+	const clean = base.replace(/[^a-zA-Z0-9_]/g, "_");
+	const names = new Set([pkgName, base, clean]);
+
+	if (pkgName === "@emailjs/browser") names.add("emailjs");
+	if (pkgName === "fuse.js") {
+		names.add("Fuse");
+		names.add("fuse");
+	}
+	if (pkgName === "prismjs") {
+		names.add("Prism");
+		names.add("prism");
+	}
+	if (pkgName === "marked") {
+		names.add("marked");
+	}
+
+	return [...names];
+}
+
+export function generateVendorEntry(packages) {
+	const imports = [];
+	const assignments = [];
+	const exports = [];
+
+	packages.forEach((pkg, idx) => {
+		const id = `_dep_${idx}`;
+		imports.push(`import * as ${id} from ${JSON.stringify(pkg)};`);
+
+		const names = getExportNames(pkg);
+		for (const name of names) {
+			assignments.push(
+				`    window[${JSON.stringify(name)}] = ${id}.default || ${id};`,
+			);
+		}
+
+		const cleanId = pkg
+			.replace(/^@[^/]+\//, "")
+			.replace(/[^a-zA-Z0-9_$]/g, "_");
+		exports.push(`    ${id} as ${cleanId}`);
+	});
+
+	return `// Auto-generated GoFront vendor entry point
+${imports.join("\n")}
+
+if (typeof window !== "undefined") {
+${assignments.join("\n")}
+}
+
+export {
+${exports.join(",\n")}
+};
+`;
+}
+
+export function findBundler(projectDir) {
+	const pkgPath = join(projectDir, "package.json");
+	let req;
+	if (existsSync(pkgPath)) {
+		req = createRequire(pkgPath);
+	} else {
+		req = createRequire(join(projectDir, "dummy.js"));
+	}
+
+	try {
+		const path = req.resolve("rolldown");
+		return { name: "rolldown", path };
+	} catch {}
+
+	try {
+		const path = req.resolve("esbuild");
+		return { name: "esbuild", path };
+	} catch {}
+
+	return null;
+}
+
+export function loadVendorConfig(projectDir) {
+	const pkgPath = join(projectDir, "package.json");
+	let pkg = {};
+	if (existsSync(pkgPath)) {
+		try {
+			pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+		} catch {}
+	}
+
+	const gfjPath = join(projectDir, "gofront.json");
+	let gfj = {};
+	if (existsSync(gfjPath)) {
+		try {
+			gfj = JSON.parse(readFileSync(gfjPath, "utf8"));
+		} catch {}
+	}
+
+	const vendorConfig = gfj.vendor ?? pkg.vendor ?? null;
+	const dependencies = Object.keys(pkg.dependencies ?? {});
+
+	let dest = null;
+	let packages = dependencies;
+
+	if (typeof vendorConfig === "string") {
+		dest = vendorConfig;
+	} else if (vendorConfig && typeof vendorConfig === "object") {
+		if (vendorConfig.dest) dest = vendorConfig.dest;
+		if (Array.isArray(vendorConfig.packages)) packages = vendorConfig.packages;
+	}
+
+	if (!dest) {
+		dest = existsSync(join(projectDir, "app")) ? "app/vendor.js" : "vendor.js";
+	}
+
+	return { dest, packages };
+}
+
+export async function bundleVendor(projectDir = ".", options = {}) {
+	const projectRoot = resolve(projectDir);
+	const config = loadVendorConfig(projectRoot);
+
+	const packages = options.packages ?? config.packages;
+	const dest = options.dest ?? config.dest;
+
+	if (!packages || packages.length === 0) {
+		return {
+			bundled: [],
+			skipped: 0,
+			dest,
+			message: "no external dependencies found",
+		};
+	}
+
+	const destPath = resolve(projectRoot, dest);
+	const relDest = relative(projectRoot, destPath);
+	if (relDest.startsWith("..") || isAbsolute(relDest)) {
+		throw new Error(
+			`gofront: vendor destination '${dest}' is outside project directory`,
+		);
+	}
+
+	const bundlerInfo = options.bundler ?? findBundler(projectRoot);
+	if (!bundlerInfo) {
+		console.warn(
+			"gofront: no bundler found (rolldown or esbuild). Run 'npm install --save-dev rolldown' to enable vendor bundling.",
+		);
+		return {
+			bundled: [],
+			skipped: packages.length,
+			dest,
+			bundler: null,
+			reason: "no bundler installed",
+		};
+	}
+
+	mkdirSync(dirname(destPath), { recursive: true });
+
+	// Allow custom bundler execution function (useful for tests and plugins)
+	if (typeof bundlerInfo.bundle === "function") {
+		await bundlerInfo.bundle({
+			projectRoot,
+			packages,
+			dest: destPath,
+		});
+		return { bundled: packages, bundler: bundlerInfo.name ?? "custom", dest };
+	}
+
+	const entryCode = generateVendorEntry(packages);
+	const entryFile = join(
+		projectRoot,
+		`.gofront-vendor-entry-${Date.now()}.mjs`,
+	);
+	writeFileSync(entryFile, entryCode);
+
+	try {
+		if (bundlerInfo.name === "rolldown") {
+			const rolldownModule =
+				bundlerInfo.instance ??
+				(await import(pathToFileURL(bundlerInfo.path).href));
+			const rolldownFn =
+				rolldownModule.rolldown ||
+				rolldownModule.default?.rolldown ||
+				rolldownModule.default;
+
+			const bundle = await rolldownFn({
+				input: entryFile,
+				cwd: projectRoot,
+			});
+			await bundle.write({
+				file: destPath,
+				format: "esm",
+			});
+			await bundle.close();
+		} else if (bundlerInfo.name === "esbuild") {
+			const esbuildModule =
+				bundlerInfo.instance ??
+				(await import(pathToFileURL(bundlerInfo.path).href));
+			const buildFn =
+				esbuildModule.build || esbuildModule.default?.build || esbuildModule;
+
+			await buildFn({
+				entryPoints: [entryFile],
+				bundle: true,
+				format: "esm",
+				outfile: destPath,
+				absWorkingDir: projectRoot,
+			});
+		}
+	} finally {
+		if (existsSync(entryFile)) {
+			rmSync(entryFile, { force: true });
+		}
+	}
+
+	return { bundled: packages, bundler: bundlerInfo.name, dest };
+}